AI 에이전트가 마치 사람처럼 대화를 기억하고, 과거 경험을 학습하며, 필요한 정보를 빠르게 찾는 기억 시스템을 구축하는 방법을 알려드립니다. 이 가이드에서는 短期記憶(단기 기억), 長期記憶(장기 기억), 벡터 검색(Vector Retrieval) 세 가지 기억 시스템을 구현합니다.
왜 AI Agent에게 기억이 필요한가?
기본 AI 채팅은 각 대화마다 기억하지 못합니다. 하지만 실제 어시스턴트를 만들려면:
- 이전 대화 내용을 이해해야 합니다
- 사용자의 선호도를 학습해야 합니다
- 과거 해결한 문제를 기억해야 합니다
- 방대한 문서에서 빠르게 답을 찾아야 합니다
📸 화면 구성 예시: 사용자 → AI Agent → 기억 시스템(단기/장기/벡터) → 응답
기억 시스템의 세 가지 층
1. 단기 기억 (Short-Term Memory)
현재 대화 중에만 유지되는 기억입니다. 대화창이 닫히면 사라집니다. 마치 인간의 "작업 기억"과 같습니다.
2. 장기 기억 (Long-Term Memory)
대화가 끝난 후에도 영구적으로 저장되는 기억입니다. 사용자의 프로필, 선호도, 과거 기록을 보관합니다.
3. 벡터 검색 (Vector Retrieval)
문서의 "의미적 유사도"를 찾아주는 기술입니다. "비슷한 내용을 가진 문서를 찾아주세요"라고 요청하면 관련 문서를 빠르게 가져옵니다.
第一步: 基础环境准备
필요한 도구를 설치합니다. 터미널(명령 프롬프트)에서 아래 명령어를 실행하세요.
pip install openai pandas numpy scikit-learn📸 터미널 화면: 설치 완료 메시지가 보이면 성공
第二步: HolySheep AI 설정
HolySheep AI는 모든 주요 AI 모델을 하나의 API 키로 사용할 수 있게 해주는 게이트웨이 서비스입니다. 여러 공급자를 개별적으로 가입할 필요 없이 단일 엔드포인트로 관리할 수 있습니다.
import os
HolySheep AI 설정
1. https://holysheep.ai/register 에서 무료 API 키를 발급받으세요
os.environ["HOLYSHEEP_API_KEY"] = "YOUR_HOLYSHEEP_API_KEY"
os.environ["OPENAI_BASE_URL"] = "https://api.holysheep.ai/v1"
print("HolySheep AI 설정 완료!")💡 팁: HolySheep AI는 해외 신용카드 없이 로컬 결제를 지원하며, GPT-4.1, Claude, Gemini, DeepSeek 등 모든 주요 모델을 단일 키로 통합 제공합니다.
第三步: 단기 기억 시스템 구현
단기 기억은 대화 기록을 리스트로 관리합니다. 간단하지만 강력한 방법입니다.
import json
from datetime import datetime
class ShortTermMemory:
"""현재 대화의 기록을 저장하는 단기 기억 클래스"""
def __init__(self, max_history=10):
self.history = []
self.max_history = max_history # 최대 기억 개수
def add(self, role, content):
"""새로운 대화를 기억에 추가합니다"""
message = {
"role": role, # "user" 또는 "assistant"
"content": content,
"timestamp": datetime.now().isoformat()
}
self.history.append(message)
# 기억이 너무 많으면 오래된 것부터 삭제
if len(self.history) > self.max_history:
self.history.pop(0)
def get_context(self):
"""AI에게 보낼 대화 기록을 반환합니다"""
return self.history.copy()
def clear(self):
"""모든 단기 기억을 삭제합니다"""
self.history = []
print("단기 기억이 초기화되었습니다")
사용 예시
memory = ShortTermMemory(max_history=5)
memory.add("user", "안녕하세요, 저는 개발자입니다")
memory.add("assistant", "안녕하세요! 무엇을 도와드릴까요?")
memory.add("user", "Python으로 웹사이트를 만들고 싶어요")
print("현재 기억:")
for msg in memory.get_context():
print(f" {msg['role']}: {msg['content']}")📸 실행 결과: user와 assistant 메시지가 시간순으로 저장된 모습
第四步: 长期记忆系统实现
장기 기억은 파일이나 데이터베이스에 정보를 영구 저장합니다. 사용자의 프로필, 선호도, 중요 정보를 보관합니다.
import json
import os
from datetime import datetime
class LongTermMemory:
"""사용자에 대한 영구 기억을 저장하는 장기 기억 클래스"""
def __init__(self, user_id, storage_file="memory.json"):
self.user_id = user_id
self.storage_file = f"{storage_file}"
self.data = self._load()
def _load(self):
"""저장된 기억을 파일에서 불러옵니다"""
if os.path.exists(self.storage_file):
with open(self.storage_file, "r", encoding="utf-8") as f:
return json.load(f)
return {"user_id": self.user_id, "facts": [], "preferences": {}}
def _save(self):
"""기억을 파일에 저장합니다"""
with open(self.storage_file, "w", encoding="utf-8") as f:
json.dump(self.data, f, ensure_ascii=False, indent=2)
def add_fact(self, fact):
"""새로운 사실을 기억합니다"""
self.data["facts"].append({
"content": fact,
"added_at": datetime.now().isoformat()
})
self._save()
print(f"새 사실 기억됨: {fact}")
def add_preference(self, key, value):
"""사용자 선호도를 저장합니다"""
self.data["preferences"][key] = value
self._save()
print(f"선호도 저장됨: {key} = {value}")
def get_all(self):
"""모든 기억을 반환합니다"""
return self.data
def search_facts(self, keyword):
"""특정 키워드를 포함한 기억을 찾습니다"""
results = []
for fact in self.data["facts"]:
if keyword in fact["content"]:
results.append(fact["content"])
return results
사용 예시
user_memory = LongTermMemory(user_id="user_001")
user_memory.add_fact("사용자는 Python 개발자입니다")
user_memory.add_fact("좋아하는 색은 파란색입니다")
user_memory.add_preference("언어", "한국어")
user_memory.add_preference("알림", True)
기억 확인
print("\n저장된 모든 기억:")
print(json.dumps(user_memory.get_all(), ensure_ascii=False, indent=2))📸 실행 결과: facts 배열과 preferences 객체가 저장된 JSON 구조
第五步: 向量检索系统实现
벡터 검색은 문서를 숫자(벡터)로 변환하여 의미가 비슷한 문서를 빠르게 찾는 기술입니다.
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
class VectorMemory:
"""문서를 벡터로 변환하여 의미적 유사도를 찾는 기억 시스템"""
def __init__(self):
self.documents = [] # 원본 문서들
self.vectorizer = TfidfVectorizer() # 텍스트를 벡터로 변환
self.vectors = None # 벡터화된 문서들
def add_document(self, text, metadata=None):
"""새 문서를 기억에 추가합니다"""
doc = {
"text": text,
"metadata": metadata or {},
"added_at": datetime.now().isoformat()
}
self.documents.append(doc)
self._rebuild_index()
print(f"문서 추가됨: {text[:50]}...")
def _rebuild_index(self):
"""모든 문서를 다시 벡터화합니다"""
if not self.documents:
self.vectors = None
return
texts = [doc["text"] for doc in self.documents]
self.vectors = self.vectorizer.fit_transform(texts)
def search(self, query, top_k=3):
"""쿼리와 가장 유사한 문서를 찾습니다"""
if not self.documents:
return []
# 쿼리를 벡터로 변환
query_vector = self.vectorizer.transform([query])
# 코사인 유사도 계산
similarities = cosine_similarity(query_vector, self.vectors)[0]
# 상위 k개 결과 반환
top_indices = similarities.argsort()[-top_k:][::-1]
results = []
for idx in top_indices:
results.append({
"text": self.documents[idx]["text"],
"metadata": self.documents[idx]["metadata"],
"score": float(similarities[idx])
})
return results
사용 예시
knowledge_base = VectorMemory()
FAQ 문서 추가
knowledge_base.add_document(
"Python 설치 방법은 python.org에서 다운로드하세요",
{"category": "설치", "difficulty": "초급"}
)
knowledge_base.add_document(
"pip는 Python 패키지 설치 도구입니다",
{"category": "패키지", "difficulty": "초급"}
)
knowledge_base.add_document(
"가상환경은 프로젝트마다 독립적인 Python 환경을 만듭니다",
{"category": "환경", "difficulty": "중급"}
)
knowledge_base.add_document(
"Docker는 컨테이너 기반 개발 도구입니다",
{"category": " DevOps", "difficulty": "고급"}
)
검색 테스트
print("\n'Python 패키지 설치'에 대한 검색 결과:")
results = knowledge_base.search("Python 패키지 설치", top_k=2)
for i, result in enumerate(results, 1):
print(f" {i}. [{result['score']:.2f}] {result['text']}")
print(f" 카테고리: {result['metadata']['category']}")📸 실행 결과: "Python 패키지 설치" 쿼리에 대해 관련성 높은 문서가 순위대로 반환됨
第六步: 完整 Agent 实现
이제 세 가지 기억 시스템을 하나의 AI Agent로 통합합니다.
from openai import OpenAI
class IntelligentAgent:
"""세 가지 기억 시스템을 통합한 지능형 AI Agent"""
def __init__(self):
# HolySheep AI 클라이언트 초기화
self.client = OpenAI(
api_key=os.environ.get("HOLYSHEEP_API_KEY"),
base_url="https://api.holysheep.ai/v1"
)
# 세 가지 기억 시스템 초기화
self.short_term = ShortTermMemory(max_history=10)
self.long_term = LongTermMemory(user_id="default_user")
self.vector_memory = VectorMemory()
def think(self, user_input):
"""사용자 입력을 분석하고 응답을 생성합니다"""
# 1단계: 단기 기억에 사용자 입력 추가
self.short_term.add("user", user_input)
# 2단계: 관련 장기 기억 검색
relevant_facts = self.long_term.search_facts(user_input)
# 3단계: 관련 벡터 기억 검색
relevant_docs = self.vector_memory.search(user_input, top_k=2)
# 시스템 프롬프트 구성
system_prompt = self._build_system_prompt(relevant_facts, relevant_docs)
# 메시지 목록 구성
messages = [{"role": "system", "content": system_prompt}]
messages.extend(self.short_term.get_context())
# AI 응답 생성
response = self.client.chat.completions.create(
model="gpt-4.1",
messages=messages,
temperature=0.7,
max_tokens=500
)
assistant_response = response.choices[0].message.content
# 4단계: 단기 기억에 AI 응답 추가
self.short_term.add("assistant", assistant_response)
# 5단계: 중요한 정보를 장기 기억에 저장
self._extract_and_store(user_input, assistant_response)
return assistant_response
def _build_system_prompt(self, facts, docs):
"""시스템 프롬프트를 구성합니다"""
prompt = "당신은 도움이 되는 AI 어시스턴트입니다.\n\n"
if facts:
prompt += "사용자에 대한 알림:\n"
for fact in facts:
prompt += f"- {fact}\n"
if docs:
prompt += "\n관련 지식:\n"
for doc in docs:
prompt += f"- {doc['text']}\n"
return prompt
def _extract_and_store(self, user_input, response):
"""응답에서 중요 정보를 장기 기억에 저장합니다"""
# 실제로는 AI에게 "기억해야 할 정보가 있나요?"라고 물어볼 수 있습니다
if "좋아하는" in user_input or "선호하는" in user_input:
# 단순화된 예시 - 실제로는 더 정교한 NLP 처리가 필요합니다
pass
완전한 에이전트 사용 예시
agent = IntelligentAgent()
print("=== 첫 번째 대화 ===")
response = agent.think("안녕하세요! 저는 웹 개발을 시작하고 싶어요")
print(f"AI: {response}\n")
print("=== 두 번째 대화 (이전 기억 활용) ===")
response = agent.think("무엇을 먼저 배워야 하나요?")
print(f"AI: {response}")第七步: 进阶 - 使用真实向量数据库
실제 프로덕션에서는 ChromaDB나 Pinecone 같은 전문 벡터 데이터베이스를 사용합니다.
# 설치: pip install chromadb
import chromadb
from chromadb.config import Settings
class AdvancedVectorMemory:
"""ChromaDB를 사용한 고급 벡터 기억 시스템"""
def __init__(self, collection_name="agent_memory"):
self.client = chromadb.Client(Settings(
persist_directory="./vector_db", # 데이터 저장 경로
anonymized_telemetry=False
))
self.collection = self.client.create_collection(
name=collection_name,
metadata={"description": "AI Agent 벡터 기억 저장소"}
)
def add(self, text, metadata=None, doc_id=None):
"""문서를 벡터로 변환하여 저장합니다"""
doc_id = doc_id or f"doc_{datetime.now().timestamp()}"
self.collection.add(
documents=[text],
metadatas=[metadata or {}],
ids=[doc_id]
)
print(f"벡터 저장 완료: {doc_id}")
def search(self, query, n_results=5):
"""의미적 유사도 검색을 수행합니다"""
results = self.collection.query(
query_texts=[query],
n_results=n_results
)
search_results = []
if results["documents"]:
for i in range(len(results["documents"][0])):
search_results.append({
"text": results["documents"][0][i],
"metadata": results["metadatas"][0][i],
"distance": results["distances"][0][i]
})
return search_results
고급 벡터 메모리 사용
advanced_memory = AdvancedVectorMemory()
advanced_memory.add(
"Python은 Interpreted 언어입니다",
{"category": "programming", "language": "Python"}
)
advanced_memory.add(
"JavaScript는 웹 개발용 스크립트 언어입니다",
{"category": "programming", "language": "JavaScript"}
)
print("\n'프로그래밍 언어'에 대한 검색:")
results = advanced_memory.search("프로그래밍 언어", n_results=2)
for r in results:
print(f" [{r['distance']:.3f}] {r['text']}")第八步: 记忆系统监控和管理
class MemoryManager:
"""기억 시스템의 상태를 모니터링하고 관리합니다"""
def __init__(self, agent):
self.agent = agent
def get_status(self):
"""현재 기억 시스템 상태를 반환합니다"""
status = {
"단기 기억": {
"대화 수": len(self.agent.short_term.history),
"용량": f"{len(self.agent.short_term.history)}/{self.agent.short_term.max_history}"
},
"장기 기억": {
"사실 수": len(self.agent.long_term.data["facts"]),