Ver3.0 ๐ง AI์ ์ฅ๊ธฐ๊ธฐ์ต(Long-Term Memory) ๊ตฌํ ์คํ: ๊ธฐ๊ณ์๊ฒ ๊ธฐ์ต์ ์ ๋ฌผํ๋ค

๐ง AI์ ์ฅ๊ธฐ๊ธฐ์ต(Long-Term Memory) ๊ตฌํ ์คํ: ๊ธฐ๊ณ์๊ฒ ๊ธฐ์ต์ ์ ๋ฌผํ๋ค
๐ฏ AI์๊ฒ ๊ธฐ์ต์ด๋ ๋ฌด์์ธ๊ฐ?
์น๊ตฌ์ผ, ์์ํด๋ด. ๋งค์ผ ์์นจ ๋์ ๋จ๋ฉด ์ด์ ์ ๊ธฐ์ต์ด ๋ชจ๋ ์ฌ๋ผ์ง๋ค๋ฉด? ๐ฑ ๋์ฐํ์ง? ๊ทธ๋ฐ๋ฐ ์ฌ์ค ๋๋ถ๋ถ์ AI ์ฑ๋ด์ด ๋ฐ๋ก ์ด๋ฐ ์ํ์ผ. ๋ํ๋ฅผ ์์ํ๋ฉด ์ด์ ๋ํ ๋ด์ฉ์ ์ ํ ๊ธฐ์ตํ์ง ๋ชปํ๋ ๊ฑฐ์ง.
ChatGPT๋ Claude ๊ฐ์ ์ต์ AI๋ค๋ ์ฌ์ค์ ์ธ์
๊ธฐ๋ฐ์ ๋จ๊ธฐ๊ธฐ์ต๋ง ๊ฐ์ง๊ณ ์์ด. ๋ธ๋ผ์ฐ์ ๋ฅผ ๋ซ๊ฑฐ๋ ์๋ก์ด ๋ํ๋ฅผ ์์ํ๋ฉด? ์ง ! ๋ชจ๋ ๊ฒ ๋ฆฌ์
๋๋ ๊ฑฐ์ผ. ๋ง์น ์ํ '๋ฉ๋ฉํ '์ ์ฃผ์ธ๊ณต์ฒ๋ผ ๋ง์ด์ผ. ๐ฌ
๊ทธ๋์ ๋ฑ์ฅํ ๊ฐ๋
์ด ๋ฐ๋ก AI์ ์ฅ๊ธฐ๊ธฐ์ต(Long-Term Memory)์ด์ผ. ์ธ๊ฐ์ฒ๋ผ ๊ณผ๊ฑฐ์ ๊ฒฝํ์ ์ ์ฅํ๊ณ , ํ์ํ ๋ ๊บผ๋ด ์ธ ์ ์๋ ์์คํ
์ ๋ง๋๋ ๊ฑฐ์ง. ์ด๊ฑด ๋จ์ํ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ฒ ์ด์์ ์๋ฏธ๋ฅผ ๊ฐ์ ธ.
2. ์ปจํ ์คํธ ์ ์ง: ๋ฉฐ์น , ๋ช ์ฃผ ์ ์ ๋ํ ๋งฅ๋ฝ์ ์ด์ด๊ฐ ์ ์์
3. ํ์ต ํจ์จ: ๋ฐ๋ณต๋๋ ์ง๋ฌธ์ ๋ํ ๋ต๋ณ์ ๊ธฐ์ตํด์ ๋ ๋น ๋ฅด๊ณ ์ ํํ ์๋ต
4. ๊ด๊ณ ๊ตฌ์ถ: ๋ง์น ์ค๋ ์น๊ตฌ์ฒ๋ผ ์ฌ์ฉ์๋ฅผ ์ดํดํ๋ AI ๊ตฌํ
๐๏ธ ์ฅ๊ธฐ๊ธฐ์ต ์์คํ ์ ํต์ฌ ์ํคํ ์ฒ
์, ์ด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ์ด๋ป๊ฒ AI์๊ฒ ์ฅ๊ธฐ๊ธฐ์ต์ ์ฌ์ด์ค ์ ์๋์ง ์์๋ณด์. ๐ง ๊ธฐ๋ณธ์ ์ผ๋ก ์ธ ๊ฐ์ง ํต์ฌ ์ปดํฌ๋ํธ๊ฐ ํ์ํด.
1๏ธโฃ ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์ (Memory Storage)
๊ฐ์ฅ ๊ธฐ๋ณธ์ด ๋๋ ๋ถ๋ถ์ด์ผ. ๋ํ ๋ด์ฉ, ์ฌ์ฉ์ ์ ๋ณด, ํ์ต๋ ํจํด ๋ฑ์ ์ด๋๊ฐ์ ์ ์ฅํด์ผ ํ์์? ์ฌ๋ฌ ๊ฐ์ง ์ต์ ์ด ์์ด:
| ์ ์ฅ์ ํ์ | ํน์ง | ์ ํฉํ ์ฉ๋ |
|---|---|---|
| ๊ด๊ณํ DB (PostgreSQL, MySQL) |
๊ตฌ์กฐํ๋ ๋ฐ์ดํฐ ์ ์ฅ ํธ๋์ญ์ ์ง์ |
์ฌ์ฉ์ ํ๋กํ, ๋ฉํ๋ฐ์ดํฐ ๋ํ ์ธ์ ์ ๋ณด |
| ๋ฒกํฐ DB (Pinecone, Weaviate) |
์๋ฏธ ๊ธฐ๋ฐ ๊ฒ์ ์๋ฒ ๋ฉ ์ ์ฅ |
๋ํ ๋ด์ฉ ๊ฒ์ ์ ์ฌ ์ปจํ ์คํธ ์ฐพ๊ธฐ |
| NoSQL DB (MongoDB, Redis) |
์ ์ฐํ ์คํค๋ง ๋น ๋ฅธ ์ฝ๊ธฐ/์ฐ๊ธฐ |
์ธ์
์บ์ ์์ ๋ฉ๋ชจ๋ฆฌ |
| ๊ทธ๋ํ DB (Neo4j) |
๊ด๊ณ ์ค์ฌ ์ ์ฅ ๋ณต์กํ ์ฐ๊ฒฐ ํํ |
์ง์ ๊ทธ๋ํ ๊ฐ๋ ๊ฐ ๊ด๊ณ |
์ค์ ์์๋ ๋ณดํต ํ์ด๋ธ๋ฆฌ๋ ์ ๊ทผ๋ฒ์ ์ฌ์ฉํด. ์๋ฅผ ๋ค์ด, ์ฌ์ฉ์ ๊ธฐ๋ณธ ์ ๋ณด๋ PostgreSQL์, ๋ํ ๋ด์ฉ์ ์๋ฒ ๋ฉ์ Pinecone์, ์ธ์ ๋ฐ์ดํฐ๋ Redis์ ์ ์ฅํ๋ ์์ด์ง. ๐ฏ
2๏ธโฃ ์๋ฒ ๋ฉ & ๋ฒกํฐํ (Embedding & Vectorization)
์ฌ๊ธฐ๊ฐ ์ง์ง ๋ง๋ฒ์ด ์ผ์ด๋๋ ๊ณณ์ด์ผ! โจ ํ
์คํธ๋ฅผ ๊ทธ๋ฅ ์ ์ฅํ๋ฉด ๋์ค์ ์ฐพ๊ธฐ๊ฐ ์ด๋ ค์. "์ด์ ํผ์ ์๊ธฐํ๋ ๊ฑฐ ๊ธฐ์ต๋?"๋ผ๊ณ ๋ฌผ์ด๋ดค์ ๋, ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ ํํ "ํผ์"๋ผ๋ ๋จ์ด๊ฐ ๋ค์ด๊ฐ ๋ํ๋ง ์ฐพ์ผ๋ฉด ์ ๋์์?
๊ทธ๋์ ์๋ฒ ๋ฉ(Embedding)์ ์ฌ์ฉํด. ํ
์คํธ๋ฅผ ๊ณ ์ฐจ์ ๋ฒกํฐ ๊ณต๊ฐ์ ์ ์ผ๋ก ๋ณํํ๋ ๊ฑฐ์ผ. ๋น์ทํ ์๋ฏธ๋ฅผ ๊ฐ์ง ๋ฌธ์ฅ๋ค์ ๋ฒกํฐ ๊ณต๊ฐ์์๋ ๊ฐ๊น์ด ์์นํ๊ฒ ๋ผ.
"ํผ์ ๋ง์์ด" โ [0.25, -0.43, 0.69, ..., 0.15] (์ ์ฌํ ๋ฒกํฐ ๊ฐ)
"๋ ์จ๊ฐ ์ข๋ค" โ [-0.12, 0.78, -0.34, ..., 0.89] (์ ํ ๋ค๋ฅธ ๋ฒกํฐ ๊ฐ)
์ด๋ ๊ฒ ๋ณํํ๋ฉด ์ฝ์ฌ์ธ ์ ์ฌ๋(Cosine Similarity) ๊ฐ์ ์ํ์ ๋ฐฉ๋ฒ์ผ๋ก ์๋ฏธ์ ์ผ๋ก ์ ์ฌํ ๋ํ๋ฅผ ์ฐพ์ ์ ์์ด! ๐
์ฃผ๋ก ์ฌ์ฉํ๋ ์๋ฒ ๋ฉ ๋ชจ๋ธ๋ค:
โข OpenAI text-embedding-ada-002: 1536์ฐจ์, ๋ฒ์ฉ์ฑ ์ข์, API ํธ์ถ ๋ฐฉ์
โข Sentence-BERT: ์คํ์์ค, ๋ก์ปฌ ์คํ ๊ฐ๋ฅ, ๋ค์ํ ํฌ๊ธฐ ๋ชจ๋ธ
โข Cohere Embed: ๋ค๊ตญ์ด ์ง์ ๊ฐ๋ ฅ, 4096์ฐจ์ ์ต์
โข Google PaLM Embeddings: ๊ตฌ๊ธ ์ํ๊ณ์ ํตํฉ ์ฉ์ด
3๏ธโฃ ๊ฒ์ & ๋ฆฌํธ๋ฆฌ๋ฒ (Retrieval)
์ ์ฅ๋ง ํ๋ฉด ๋ญํด? ํ์ํ ๋ ๊บผ๋ด ์ธ ์ ์์ด์ผ์ง! ๐ฃ ์ด ๋ถ๋ถ์ด ์๊ฐ๋ณด๋ค ๊น๋ค๋ก์. ๋จ์ํ ๊ฐ์ฅ ์ ์ฌํ ๋ฒกํฐ๋ฅผ ์ฐพ๋ ๊ฒ๋ง์ผ๋ก๋ ๋ถ์กฑํด.
๐ฏ ํจ๊ณผ์ ์ธ ๊ฒ์ ์ ๋ต
1. ํ์ด๋ธ๋ฆฌ๋ ๊ฒ์ (Hybrid Search)
๋ฒกํฐ ์ ์ฌ๋ ๊ฒ์ + ํค์๋ ๊ธฐ๋ฐ ๊ฒ์์ ๊ฒฐํฉํด. ์๋ฅผ ๋ค์ด, "์ง๋์ฃผ ํ์์ผ์ ์๊ธฐํ๋ ํ๋ก์ ํธ"๋ผ๊ณ ํ๋ฉด, ์๊ฐ ์ ๋ณด(ํ์์ผ)๋ ๋ฉํ๋ฐ์ดํฐ ํํฐ๋ก, "ํ๋ก์ ํธ"๋ ๋ฒกํฐ ๊ฒ์์ผ๋ก ์ฒ๋ฆฌํ๋ ๊ฑฐ์ง.
2. ๋ฆฌ๋ญํน (Re-ranking)
์ฒซ ๋ฒ์งธ ๊ฒ์์์ ์์ 20๊ฐ๋ฅผ ๋ฝ๊ณ , ๋ ์ ๊ตํ ๋ชจ๋ธ๋ก ๋ค์ ์์๋ฅผ ๋งค๊ฒจ. ์ ํ๋๋ ์ฌ๋ผ๊ฐ์ง๋ง ์๋๋ ์กฐ๊ธ ๋๋ ค์ ธ. ํธ๋ ์ด๋์คํ๊ฐ ์์ด! โ๏ธ
3. ์๊ฐ ๊ฐ์ค์น (Temporal Weighting)
์ต๊ทผ ๋ํ์ ๋ ๋์ ๊ฐ์ค์น๋ฅผ ์ค. 3๊ฐ์ ์ ๋ํ๋ณด๋ค ์ด์ ๋ํ๊ฐ ๋ ๊ด๋ จ์ฑ์ด ๋์ ๊ฐ๋ฅ์ฑ์ด ํฌ๋๊น.
4. ์ปจํ
์คํธ ์๋์ฐ ๊ด๋ฆฌ
๊ฒ์๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ AI์๊ฒ ์ ๋ฌํ ๋, ํ ํฐ ์ ํ์ ๊ณ ๋ คํด์ผ ํด. GPT-4์ ๊ฒฝ์ฐ 8K~32K ํ ํฐ ์ ํ์ด ์์ผ๋, ๊ฐ์ฅ ๊ด๋ จ์ฑ ๋์ ๋ฉ๋ชจ๋ฆฌ๋ง ์ ๋ณํด์ ๋ฃ์ด์ค์ผ ํด. ๐
๐ป ์ค์ ๊ตฌํ: ๋จ๊ณ๋ณ ๊ฐ์ด๋
์ด๋ก ์ ์ถฉ๋ถํ ๋ดค์ผ๋, ์ด์ ์ค์ ๋ก ์ฝ๋๋ฅผ ์ง๋ณด์! ๐ Python ๊ธฐ๋ฐ์ผ๋ก ๊ฐ๋จํ ์ฅ๊ธฐ๊ธฐ์ต ์์คํ ์ ๋ง๋ค์ด๋ณผ ๊ฑฐ์ผ. ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ AI ๊ฐ๋ฐ ์ฌ๋ฅ์ ๊ณต์ ํ๋ ๊ฐ๋ฐ์๋ค๋ ์ด๋ฐ ์์คํ ์ ๋ง์ด ๊ตฌํํ๋๋ผ๊ณ .
๐ง Step 1: ํ๊ฒฝ ์ค์
๋จผ์ ํ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ ์ค์นํด์ผ ํด:
pip install openai pinecone-client langchain chromadb sentence-transformers
๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ญํ :
openai: GPT ๋ชจ๋ธ ๋ฐ ์๋ฒ ๋ฉ API
pinecone-client: ๋ฒกํฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค (๋์: Weaviate, Qdrant)
langchain: LLM ์ ํ๋ฆฌ์ผ์ด์
ํ๋ ์์ํฌ
chromadb: ๋ก์ปฌ ๋ฒกํฐ DB (๊ฐ๋ฐ/ํ
์คํธ์ฉ)
sentence-transformers: ๋ก์ปฌ ์๋ฒ ๋ฉ ๋ชจ๋ธ
๐๏ธ Step 2: ๋ฉ๋ชจ๋ฆฌ ํด๋์ค ์ค๊ณ
๊ธฐ๋ณธ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ํด๋์ค๋ฅผ ๋ง๋ค์ด๋ณด์:
import openai
from datetime import datetime
import json
from typing import List, Dict, Optional
class LongTermMemory:
def __init__(self, user_id: str, api_key: str):
self.user_id = user_id
openai.api_key = api_key
self.memories = [] # ์ค์ ๋ก๋ DB ์ฐ๊ฒฐ
def add_memory(self, content: str, metadata: Dict = None):
"""์๋ก์ด ๊ธฐ์ต ์ถ๊ฐ"""
embedding = self._get_embedding(content)
memory = {
'id': self._generate_id(),
'user_id': self.user_id,
'content': content,
'embedding': embedding,
'timestamp': datetime.now().isoformat(),
'metadata': metadata or {},
'access_count': 0
}
self.memories.append(memory)
return memory['id']
def _get_embedding(self, text: str) -> List[float]:
"""ํ
์คํธ๋ฅผ ๋ฒกํฐ๋ก ๋ณํ"""
response = openai.Embedding.create(
model="text-embedding-ada-002",
input=text
)
return response['data'][0]['embedding']
def search_memories(self, query: str, top_k: int = 5) -> List[Dict]:
"""์ฟผ๋ฆฌ์ ์ ์ฌํ ๊ธฐ์ต ๊ฒ์"""
query_embedding = self._get_embedding(query)
# ์ฝ์ฌ์ธ ์ ์ฌ๋ ๊ณ์ฐ
similarities = []
for memory in self.memories:
similarity = self._cosine_similarity(
query_embedding,
memory['embedding']
)
similarities.append((similarity, memory))
# ์์ k๊ฐ ๋ฐํ
similarities.sort(reverse=True, key=lambda x: x[0])
return [mem for _, mem in similarities[:top_k]]
def _cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float:
"""์ฝ์ฌ์ธ ์ ์ฌ๋ ๊ณ์ฐ"""
import numpy as np
return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
def _generate_id(self) -> str:
"""๊ณ ์ ID ์์ฑ"""
import uuid
return str(uuid.uuid4())
์ด ์ฝ๋๋ ๊ธฐ๋ณธ ๊ณจ๊ฒฉ์ด์ผ. ์ค์ ํ๋ก๋์ ์์๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ, ์๋ฌ ํธ๋ค๋ง, ๋น๋๊ธฐ ์ฒ๋ฆฌ ๋ฑ์ด ์ถ๊ฐ๋์ด์ผ ํด. ๐ ๏ธ
๐จ Step 3: ๋ฒกํฐ DB ํตํฉ
์ด์ Pinecone ๊ฐ์ ์ ๋ฌธ ๋ฒกํฐ DB๋ฅผ ์ฐ๊ฒฐํด๋ณด์. ๋ก์ปฌ ํ ์คํธ์๋ ChromaDB๊ฐ ์ข์:
import chromadb
from chromadb.config import Settings
class VectorMemoryStore:
def __init__(self, collection_name: str = "memories"):
self.client = chromadb.Client(Settings(
chroma_db_impl="duckdb+parquet",
persist_directory="./chroma_db"
))
self.collection = self.client.get_or_create_collection(
name=collection_name,
metadata={"hnsw:space": "cosine"} # ์ฝ์ฌ์ธ ์ ์ฌ๋ ์ฌ์ฉ
)
def add(self, id: str, embedding: List[float],
document: str, metadata: Dict):
"""๋ฒกํฐ์ ๋ฌธ์ ์ ์ฅ"""
self.collection.add(
ids=[id],
embeddings=[embedding],
documents=[document],
metadatas=[metadata]
)
def query(self, query_embedding: List[float],
n_results: int = 5,
where: Dict = None) -> Dict:
"""์ ์ฌ ๋ฒกํฐ ๊ฒ์"""
results = self.collection.query(
query_embeddings=[query_embedding],
n_results=n_results,
where=where # ๋ฉํ๋ฐ์ดํฐ ํํฐ๋ง
)
return results
def update_metadata(self, id: str, metadata: Dict):
"""๋ฉํ๋ฐ์ดํฐ ์
๋ฐ์ดํธ (์ ๊ทผ ํ์ ๋ฑ)"""
self.collection.update(
ids=[id],
metadatas=[metadata]
)
ChromaDB๋ ์ค์ ์ด ๊ฐ๋จํ๊ณ ๋ก์ปฌ์์ ๋์๊ฐ์ ๊ฐ๋ฐํ ๋ ์ ๋ง ํธํด. ํ์ง๋ง ํ๋ก๋์ ์์๋ Pinecone์ด๋ Weaviate ๊ฐ์ ํด๋ผ์ฐ๋ ์๋น์ค๋ฅผ ์ถ์ฒํด. ํ์ฅ์ฑ๊ณผ ์ฑ๋ฅ์ด ํจ์ฌ ์ข๊ฑฐ๋ ! โ๏ธ
๐งฉ Step 4: LangChain๊ณผ ํตํฉ
LangChain์ ์ฌ์ฉํ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๊ฐ ํจ์ฌ ์ฌ์์ ธ. ์ด๋ฏธ ๋ง๋ค์ด์ง ์ปดํฌ๋ํธ๋ค์ ์กฐํฉํ๋ฉด ๋๊ฑฐ๋ :
from langchain.memory import VectorStoreRetrieverMemory
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import ConversationChain
from langchain.llms import OpenAI
# ๋ฒกํฐ ์คํ ์ด ์ค์
embeddings = OpenAIEmbeddings()
vectorstore = Chroma(
collection_name="conversation_memory",
embedding_function=embeddings,
persist_directory="./chroma_langchain"
)
# ๋ฉ๋ชจ๋ฆฌ ๋ฆฌํธ๋ฆฌ๋ฒ ์์ฑ
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
memory = VectorStoreRetrieverMemory(retriever=retriever)
# ๋ํ ์ฒด์ธ ๊ตฌ์ฑ
llm = OpenAI(temperature=0.7)
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=True
)
# ์ฌ์ฉ ์์
response1 = conversation.predict(input="๋ด ์ด๋ฆ์ ์ฒ ์์ผ")
# AI: "์๋
ํ์ธ์ ์ฒ ์๋! ๋ง๋์ ๋ฐ๊ฐ์ต๋๋ค."
response2 = conversation.predict(input="๋ด ์ด๋ฆ์ด ๋ญ์์ง?")
# AI: "์ฒ ์๋์ด๋ผ๊ณ ๋ง์ํ์
จ์ต๋๋ค!"
LangChain์ ์ฅ์ ์ ๋ฉ๋ชจ๋ฆฌ ํ์ ์ ์ฝ๊ฒ ๋ฐ๊ฟ ์ ์๋ค๋ ๊ฑฐ์ผ. ConversationBufferMemory, ConversationSummaryMemory, VectorStoreRetrieverMemory ๋ฑ ์ํฉ์ ๋ง๊ฒ ์ ํํ ์ ์์ด. ๐๏ธ
๐ญ ๊ณ ๊ธ ๊ธฐ๋ฒ: ๋ฉ๋ชจ๋ฆฌ ๊ณ์ธตํ
์ธ๊ฐ์ ๊ธฐ์ต๋ ๋จ๊ธฐ๊ธฐ์ต, ์ฅ๊ธฐ๊ธฐ์ต, ์์ ๊ธฐ์ต ๋ฑ์ผ๋ก ๋๋์์? AI๋ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ณ์ธตํ๋ ๋ฉ๋ชจ๋ฆฌ ์์คํ ์ ๊ตฌํํ๋ฉด ํจ์ฌ ํจ์จ์ ์ด์ผ. ๐ง
๐ 3-Tier ๋ฉ๋ชจ๋ฆฌ ์ํคํ ์ฒ
๐ฅ Tier 1: Working Memory (์์ ๋ฉ๋ชจ๋ฆฌ)
ํ์ฌ ์งํ ์ค์ธ ๋ํ๋ฅผ ์ํ ์ด๊ณ ์ ๋ฉ๋ชจ๋ฆฌ์ผ. Redis ๊ฐ์ ์ธ๋ฉ๋ชจ๋ฆฌ DB๋ฅผ ์ฌ์ฉํด์ ๋ฐ๋ฆฌ์ด ๋จ์๋ก ์ ๊ทผ ๊ฐ๋ฅํด. ๐จ
ํน์ง:
โข ํ์ฌ ์ธ์
์ ์ต๊ทผ 10-100๊ฐ ๋ฉ์์ง ์ ์ฅ
โข TTL(Time To Live) ์ค์ ์ผ๋ก ์๋ ๋ง๋ฃ
โข ํ ํฐ ์นด์ดํ
์ผ๋ก ์ปจํ
์คํธ ์๋์ฐ ๊ด๋ฆฌ
โข ๋ํ ํ๋ฆ ์ ์ง์ ์ต์ ํ
import redis
import json
class WorkingMemory:
def __init__(self, session_id: str):
self.redis_client = redis.Redis(host='localhost', port=6379, db=0)
self.session_id = session_id
self.key = f"session:{session_id}"
def add_message(self, role: str, content: str):
"""๋ฉ์์ง ์ถ๊ฐ (์ต๋ 100๊ฐ ์ ์ง)"""
message = {
'role': role,
'content': content,
'timestamp': datetime.now().isoformat()
}
self.redis_client.lpush(self.key, json.dumps(message))
self.redis_client.ltrim(self.key, 0, 99) # ์ต์ 100๊ฐ๋ง
self.redis_client.expire(self.key, 7200) # 2์๊ฐ ํ ๋ง๋ฃ
def get_recent_messages(self, count: int = 10) -> List[Dict]:
"""์ต๊ทผ ๋ฉ์์ง ๊ฐ์ ธ์ค๊ธฐ"""
messages = self.redis_client.lrange(self.key, 0, count-1)
return [json.loads(msg) for msg in messages]
๐ Tier 2: Recent Memory (์ต๊ทผ ๋ฉ๋ชจ๋ฆฌ)
์ง๋ ๋ฉฐ์น ๊ฐ์ ๋ํ๋ฅผ ๋ฒกํฐ ๊ฒ์์ผ๋ก ๋น ๋ฅด๊ฒ ์ฐพ์ ์ ์๋ ๊ณ์ธต์ด์ผ. ์ฌ๊ธฐ๊ฐ ์ง์ง ์ฅ๊ธฐ๊ธฐ์ต์ ํต์ฌ์ด์ง! ๐ฏ
ํน์ง:
โข ๋ฒกํฐ ์๋ฒ ๋ฉ์ผ๋ก ์๋ฏธ ๊ธฐ๋ฐ ๊ฒ์
โข ์ต๊ทผ 1์ฃผ์ผ~1๊ฐ์ ๋ฐ์ดํฐ hot storage
โข ๋ฉํ๋ฐ์ดํฐ ํํฐ๋ง (๋ ์ง, ์ฃผ์ , ์ค์๋)
โข ์๋ ์์ฝ ๋ฐ ์์ถ
1. ์ํฐํฐ ์ถ์ถ: ์ด๋ฆ, ๋ ์ง, ์ฅ์, ์ค์ ํค์๋๋ง ์ ์ฅ
2. ๋ํ ์์ฝ: GPT๋ก ๊ธด ๋ํ๋ฅผ 3-4๋ฌธ์ฅ์ผ๋ก ์์ฝ
3. ์ค์๋ ์ ์: ์ฌ์ฉ์๊ฐ ๊ฐ์กฐํ ๋ด์ฉ์ ๋์ ์ ์ ๋ถ์ฌ
4. ์ค๋ณต ์ ๊ฑฐ: ๋น์ทํ ๋ด์ฉ์ ํ๋๋ก ํตํฉ
๐๏ธ Tier 3: Long-Term Memory (์ฅ๊ธฐ ๋ฉ๋ชจ๋ฆฌ)
๋ชจ๋ ๋ํ ํ์คํ ๋ฆฌ๋ฅผ ์๊ตฌ ๋ณด๊ดํ๋ ๊ณ์ธต์ด์ผ. ์์ฃผ ์ ๊ทผํ์ง๋ ์์ง๋ง, ํ์ํ ๋ ๊บผ๋ด ์ธ ์ ์์ด.
ํน์ง:
โข PostgreSQL ๊ฐ์ ๊ด๊ณํ DB ์ฌ์ฉ
โข ์์ถ ๋ฐ ์์นด์ด๋น
โข ๋ถ์ ๋ฐ ํต๊ณ ์ถ์ถ
โข ๊ท์ ์ค์ ๋ฐ ๊ฐ์ฌ ๋ก๊ทธ
-- PostgreSQL ์คํค๋ง ์์
CREATE TABLE long_term_memories (
id UUID PRIMARY KEY,
user_id VARCHAR(255) NOT NULL,
session_id VARCHAR(255),
content TEXT,
summary TEXT,
entities JSONB,
embedding_id VARCHAR(255),
importance_score FLOAT,
created_at TIMESTAMP DEFAULT NOW(),
accessed_at TIMESTAMP,
access_count INTEGER DEFAULT 0,
INDEX idx_user_created (user_id, created_at),
INDEX idx_importance (importance_score DESC)
);
๐ช ์ค์ ์๋๋ฆฌ์ค: ๊ฐ์ธ ๋น์ AI ๋ง๋ค๊ธฐ
์ด๋ก ๊ณผ ์ฝ๋๋ง ๋ณด๋ฉด ์ฌ๋ฏธ์์ง? ์ค์ ๋ก ์ด๋ป๊ฒ ํ์ฉ๋๋์ง ์๋๋ฆฌ์ค๋ฅผ ํตํด ์์๋ณด์! ๐ฌ ๊ฐ์ธ ๋น์ AI๋ฅผ ๋ง๋ ๋ค๊ณ ์๊ฐํด๋ด.
๐ ์๋๋ฆฌ์ค 1: ์ผ์ ๊ด๋ฆฌ
AI: "๋ค, ๋ค์ ์ฃผ ํ์์ผ(12์ 17์ผ) ์คํ 3์์ ์น๊ณผ ์์ฝ์ ๊ธฐ๋กํ์ต๋๋ค."
[3์ผ ํ]
์ฌ์ฉ์: "์ด๋ฒ ์ฃผ์ ๋ญ ํ ์ผ ์์์ง?"
AI: "ํ์์ผ ์คํ 3์์ ์น๊ณผ ์์ฝ์ด ์์ผ์ญ๋๋ค. ๋ฏธ๋ฆฌ ์๋ฆผ์ ์ค์ ํด๋๋ฆด๊น์?"
์ด๊ฒ ๊ฐ๋ฅํ๋ ค๋ฉด:
1. ์ฒซ ๋ํ์์ "์น๊ณผ ์์ฝ", "ํ์์ผ", "์คํ 3์" ๊ฐ์ ์ํฐํฐ๋ฅผ ์ถ์ถํด์ ๊ตฌ์กฐํ๋ ํํ๋ก ์ ์ฅ
2. ๋ ์ง ์ ๋ณด๋ฅผ ๋ฉํ๋ฐ์ดํฐ๋ก ์ธ๋ฑ์ฑ
3. "์ด๋ฒ ์ฃผ" ๊ฐ์ ์๊ฐ ์ฟผ๋ฆฌ๋ฅผ ํ์ฌ ๋ ์ง ๊ธฐ์ค์ผ๋ก ํํฐ๋ง
4. ๊ด๋ จ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฒ์ํด์ ์ปจํ
์คํธ์ ํฌํจ
class PersonalAssistantMemory:
def process_appointment(self, user_input: str):
# 1. ์ํฐํฐ ์ถ์ถ (NER ์ฌ์ฉ)
entities = self.extract_entities(user_input)
# {'type': '์น๊ณผ', 'date': '2024-12-17', 'time': '15:00'}
# 2. ๊ตฌ์กฐํ๋ ๋ฉ๋ชจ๋ฆฌ ์์ฑ
memory = {
'type': 'appointment',
'raw_text': user_input,
'entities': entities,
'date': entities['date'],
'importance': 0.9 # ์์ฝ์ ์ค์!
}
# 3. ๋ค์ค ์ ์ฅ
self.working_memory.add(memory) # ์ฆ์ ์ ๊ทผ์ฉ
self.vector_store.add(memory) # ๊ฒ์์ฉ
self.sql_db.insert(memory) # ์๊ตฌ ๋ณด๊ด
# 4. ์๋ฆผ ์ค์ผ์ค๋ง
self.schedule_reminder(entities['date'], memory)
def query_schedule(self, time_range: str):
# "์ด๋ฒ ์ฃผ" โ ๋ ์ง ๋ฒ์๋ก ๋ณํ
start_date, end_date = self.parse_time_range(time_range)
# ๋ฉํ๋ฐ์ดํฐ ํํฐ๋ก ๊ฒ์
results = self.vector_store.query(
query="์ผ์ ์์ฝ",
where={
"date": {"$gte": start_date, "$lte": end_date},
"type": "appointment"
}
)
return results
๐ ์๋๋ฆฌ์ค 2: ์ ํธ๋ ํ์ต
AI: "์ง๋์ฃผ์ ํผ์ ๋์๊ณ ์ถ๋ค๊ณ ํ์ จ๋๋ฐ, ์์ง ์ ๋์ จ๋ค์. ๊ทผ์ฒ ๋ง์๋ ํผ์์ง ์ถ์ฒํด๋๋ฆด๊น์?"
์ฌ์ฉ์: "์ค ์ข์! ๊ทธ๋ฐ๋ฐ ํ์ธ์ ํ ํผ์๋ ๋นผ๊ณ ."
AI: "์๊ฒ ์ต๋๋ค. ํ์ธ์ ํ ํผ์๋ ์ ํธํ์ง ์์ผ์ ๋ค๊ณ ๊ธฐ์ตํ๊ฒ ์ต๋๋ค."
์ด๋ฐ ๊ฐ์ธํ๊ฐ ๊ฐ๋ฅํ๋ ค๋ฉด:
1. ์ ํธ๋ ์ ๋ณด๋ฅผ ๋ณ๋ ์นดํ
๊ณ ๋ฆฌ๋ก ๋ถ๋ฅ
2. ๊ธ์ /๋ถ์ ๊ฐ์ ๋ถ์
3. ์๊ฐ์ ๋ฐ๋ฅธ ์ ํธ๋ ๋ณํ ์ถ์
4. ์ปจํ
์คํธ ๊ธฐ๋ฐ ์ถ์ฒ
class PreferenceMemory:
def __init__(self):
self.preferences = {} # ์ค์ ๋ก๋ DB
def update_preference(self, item: str, sentiment: float):
"""์ ํธ๋ ์
๋ฐ์ดํธ (-1.0 ~ 1.0)"""
if item not in self.preferences:
self.preferences[item] = {
'score': sentiment,
'count': 1,
'last_updated': datetime.now()
}
else:
# ์ด๋ ํ๊ท ์ผ๋ก ์
๋ฐ์ดํธ
old_score = self.preferences[item]['score']
old_count = self.preferences[item]['count']
new_score = (old_score * old_count + sentiment) / (old_count + 1)
self.preferences[item].update({
'score': new_score,
'count': old_count + 1,
'last_updated': datetime.now()
})
def get_recommendations(self, category: str, exclude: List[str] = None):
"""์ ํธ๋ ๊ธฐ๋ฐ ์ถ์ฒ"""
items = [
(item, data['score'])
for item, data in self.preferences.items()
if data['score'] > 0.5 and item not in (exclude or [])
]
items.sort(key=lambda x: x[1], reverse=True)
return items[:5]
โ ๏ธ ์ฃผ์์ฌํญ๊ณผ ๋ฒ ์คํธ ํ๋ํฐ์ค
์ฅ๊ธฐ๊ธฐ์ต ์์คํ ์ ๊ตฌํํ ๋ ๊ผญ ๊ณ ๋ คํด์ผ ํ ๊ฒ๋ค์ด ์์ด. ์ค์ํ๋ฉด ํฐ์ผ ๋๋ ๊ฒ๋ค์ด์ง! ๐ฐ
๐ 1. ํ๋ผ์ด๋ฒ์์ ๋ณด์
์ฌ์ฉ์์ ๋ชจ๋ ๋ํ๋ฅผ ์ ์ฅํ๋ค๋ ๊ฑด ์์ฒญ๋ ์ฑ
์์ด ๋ฐ๋ผ. ๊ฐ์ธ์ ๋ณด ๋ณดํธ๋ฒ, GDPR ๊ฐ์ ๊ท์ ์ ๋ฐ๋์ ์ค์ํด์ผ ํด.
ํ์ ๊ตฌํ ์ฌํญ:
โข ์ํธํ: ์ ์ฅ ์ AES-256 ์ํธํ, ์ ์ก ์ TLS/SSL
โข ์ ๊ทผ ์ ์ด: ์ฌ์ฉ์๋ณ ๊ฒฉ๋ฆฌ, ๊ถํ ๊ด๋ฆฌ
โข ๋ฐ์ดํฐ ์ญ์ : "์์ด์ค" ๊ธฐ๋ฅ, GDPR์ '์ํ ๊ถ๋ฆฌ' ๊ตฌํ
โข ๊ฐ์ฌ ๋ก๊ทธ: ๋๊ฐ ์ธ์ ์ด๋ค ๋ฐ์ดํฐ์ ์ ๊ทผํ๋์ง ๊ธฐ๋ก
โข ์ต๋ช
ํ: ๋ฏผ๊ฐ ์ ๋ณด๋ ๋ง์คํน ๋๋ ํ ํฐํ
from cryptography.fernet import Fernet
class SecureMemory:
def __init__(self, encryption_key: bytes):
self.cipher = Fernet(encryption_key)
def encrypt_content(self, content: str) -> str:
"""๋ด์ฉ ์ํธํ"""
return self.cipher.encrypt(content.encode()).decode()
def decrypt_content(self, encrypted: str) -> str:
"""๋ด์ฉ ๋ณตํธํ"""
return self.cipher.decrypt(encrypted.encode()).decode()
def anonymize_pii(self, text: str) -> str:
"""๊ฐ์ธ์๋ณ์ ๋ณด ์ต๋ช
ํ"""
import re
# ์ด๋ฉ์ผ ๋ง์คํน
text = re.sub(r'\b[\w.-]+@[\w.-]+\.\w+\b', '[EMAIL]', text)
# ์ ํ๋ฒํธ ๋ง์คํน
text = re.sub(r'\b\d{3}-\d{3,4}-\d{4}\b', '[PHONE]', text)
# ์ฃผ๋ฏผ๋ฑ๋ก๋ฒํธ ๋ง์คํน
text = re.sub(r'\b\d{6}-\d{7}\b', '[SSN]', text)
return text
๐ฐ 2. ๋น์ฉ ์ต์ ํ
์๋ฒ ๋ฉ API ํธ์ถ, ๋ฒกํฐ DB ์ ์ฅ, GPT ํ ํฐ ์ฌ์ฉ... ๋ค ๋์ด์ผ! ๐ธ ์ต์ ํ ์ ํ๋ฉด ๋น์ฉ์ด ํญ๋ฐํ ์ ์์ด.
๋น์ฉ ์ ๊ฐ ์ ๋ต:
| ํญ๋ชฉ | ๋ฌธ์ | ํด๊ฒฐ์ฑ |
|---|---|---|
| ์๋ฒ ๋ฉ | ๋ชจ๋ ๋ฉ์์ง๋ง๋ค API ํธ์ถ | ๋ฐฐ์น ์ฒ๋ฆฌ, ๋ก์ปฌ ๋ชจ๋ธ ์ฌ์ฉ (Sentence-BERT) |
| ๋ฒกํฐ ์ ์ฅ | ๊ณ ์ฐจ์ ๋ฒกํฐ ์ ์ฅ ๋น์ฉ | ์ฐจ์ ์ถ์(PCA), ์์ํ ์ค์๋ ๋ฎ์ ๋ฉ๋ชจ๋ฆฌ ์ญ์ |
| GPT ํ ํฐ | ๊ธด ์ปจํ ์คํธ ์ ๋ฌ | ์์ฝ ์ฌ์ฉ, ๊ด๋ จ์ฑ ๋์ ๊ฒ๋ง ์ ๋ณ, ํ ํฐ ์นด์ดํ |
| DB ์ฟผ๋ฆฌ | ๋น๋ฒํ ๊ฒ์ | ์บ์ฑ(Redis), ์ธ๋ฑ์ฑ ์ฟผ๋ฆฌ ์ต์ ํ |
class CostOptimizedMemory:
def __init__(self):
self.cache = {} # ๊ฐ๋จํ ์บ์
self.batch_queue = []
self.batch_size = 10
def add_to_batch(self, text: str):
"""๋ฐฐ์น ํ์ ์ถ๊ฐ"""
self.batch_queue.append(text)
if len(self.batch_queue) >= self.batch_size:
self.process_batch()
def process_batch(self):
"""๋ฐฐ์น๋ก ํ ๋ฒ์ ์ฒ๋ฆฌ (๋น์ฉ ์ ๊ฐ)"""
if not self.batch_queue:
return
# ํ ๋ฒ์ API ํธ์ถ๋ก ์ฌ๋ฌ ํ
์คํธ ์๋ฒ ๋ฉ
embeddings = openai.Embedding.create(
model="text-embedding-ada-002",
input=self.batch_queue
)
for i, text in enumerate(self.batch_queue):
embedding = embeddings['data'][i]['embedding']
self.store_embedding(text, embedding)
self.batch_queue.clear()
def get_cached_or_search(self, query: str):
"""์บ์ ๋จผ์ ํ์ธ"""
cache_key = hash(query)
if cache_key in self.cache:
return self.cache[cache_key]
result = self.search(query)
self.cache[cache_key] = result
return result
โก 3. ์ฑ๋ฅ ์ต์ ํ
์ฌ์ฉ์๋ ๊ธฐ๋ค๋ฆฌ์ง ์์. ์๋ต ์๋๊ฐ ๋๋ฆฌ๋ฉด ๋ฐ๋ก ์ดํํด๋ฒ๋ ค. ๐โโ๏ธ๐จ
์ฑ๋ฅ ํฅ์ ๊ธฐ๋ฒ:
โข ๋น๋๊ธฐ ์ฒ๋ฆฌ: ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์ ๋ฐฑ๊ทธ๋ผ์ด๋์์
โข ๋ณ๋ ฌ ๊ฒ์: ์ฌ๋ฌ ์์ค๋ฅผ ๋์์ ์ฟผ๋ฆฌ
โข ์ธ๋ฑ์ฑ: ์์ฃผ ๊ฒ์ํ๋ ํ๋์ ์ธ๋ฑ์ค
โข ์บ์ฑ: ์ต๊ทผ ๊ฒ์ ๊ฒฐ๊ณผ ์บ์ฑ
โข ํ๋ฆฌํ์นญ: ์ฌ์ฉ์ ํจํด ๋ถ์ํด์ ๋ฏธ๋ฆฌ ๋ก๋
import asyncio
from concurrent.futures import ThreadPoolExecutor
class FastMemory:
def __init__(self):
self.executor = ThreadPoolExecutor(max_workers=5)
async def parallel_search(self, query: str):
"""์ฌ๋ฌ ์์ค๋ฅผ ๋ณ๋ ฌ๋ก ๊ฒ์"""
tasks = [
self.search_working_memory(query),
self.search_vector_db(query),
self.search_sql_db(query)
]
results = await asyncio.gather(*tasks)
return self.merge_results(results)
async def search_working_memory(self, query: str):
"""Redis์์ ๊ฒ์ (๊ฐ์ฅ ๋น ๋ฆ)"""
loop = asyncio.get_event_loop()
return await loop.run_in_executor(
self.executor,
self._sync_search_redis,
query
)
async def search_vector_db(self, query: str):
"""๋ฒกํฐ DB ๊ฒ์ (์ค๊ฐ ์๋)"""
loop = asyncio.get_event_loop()
return await loop.run_in_executor(
self.executor,
self._sync_search_vector,
query
)
def merge_results(self, results: List[List[Dict]]) -> List[Dict]:
"""๊ฒฐ๊ณผ ๋ณํฉ ๋ฐ ์ค๋ณต ์ ๊ฑฐ"""
merged = []
seen_ids = set()
for result_list in results:
for item in result_list:
if item['id'] not in seen_ids:
merged.append(item)
seen_ids.add(item['id'])
# ๊ด๋ จ์ฑ ์ ์๋ก ์ ๋ ฌ
merged.sort(key=lambda x: x.get('score', 0), reverse=True)
return merged[:10]
๐งช 4. ํ ์คํธ์ ํ๊ฐ
์ฅ๊ธฐ๊ธฐ์ต ์์คํ ์ด ์ ๋๋ก ์๋ํ๋์ง ์ด๋ป๊ฒ ์ ์ ์์๊น? ์ ๋์ ํ๊ฐ๊ฐ ํ์ํด! ๐
2. Precision (์ ๋ฐ๋): ์ฐพ์๋ธ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ ๋ก ๊ด๋ จ ์๋๊ฐ?
3. Latency (์ง์ฐ์๊ฐ): ๊ฒ์์ ๊ฑธ๋ฆฌ๋ ์๊ฐ
4. Relevance Score (๊ด๋ จ์ฑ ์ ์): ์ฌ์ฉ์๊ฐ ๋ง์กฑํ๋๊ฐ?
5. Memory Utilization (๋ฉ๋ชจ๋ฆฌ ํ์ฉ๋): ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ ๋ก ์ฌ์ฉ๋๋๊ฐ?
class MemoryEvaluator:
def evaluate_recall(self, query: str, expected_ids: List[str],
retrieved_ids: List[str]) -> float:
"""์ฌํ์จ ๊ณ์ฐ"""
relevant_retrieved = set(expected_ids) & set(retrieved_ids)
return len(relevant_retrieved) / len(expected_ids) if expected_ids else 0
def evaluate_precision(self, query: str, expected_ids: List[str],
retrieved_ids: List[str]) -> float:
"""์ ๋ฐ๋ ๊ณ์ฐ"""
relevant_retrieved = set(expected_ids) & set(retrieved_ids)
return len(relevant_retrieved) / len(retrieved_ids) if retrieved_ids else 0
def run_benchmark(self, test_cases: List[Dict]):
"""๋ฒค์น๋งํฌ ์คํ"""
results = {
'recall': [],
'precision': [],
'latency': []
}
for case in test_cases:
start_time = time.time()
retrieved = self.memory.search(case['query'])
latency = time.time() - start_time
retrieved_ids = [r['id'] for r in retrieved]
recall = self.evaluate_recall(
case['query'],
case['expected_ids'],
retrieved_ids
)
precision = self.evaluate_precision(
case['query'],
case['expected_ids'],
retrieved_ids
)
results['recall'].append(recall)
results['precision'].append(precision)
results['latency'].append(latency)
return {
'avg_recall': sum(results['recall']) / len(results['recall']),
'avg_precision': sum(results['precision']) / len(results['precision']),
'avg_latency': sum(results['latency']) / len(results['latency'])
}
๐ ์ต์ ํธ๋ ๋์ ๋ฏธ๋ ๋ฐฉํฅ
AI ์ฅ๊ธฐ๊ธฐ์ต ๋ถ์ผ๋ ์ง๊ธ๋ ๋น ๋ฅด๊ฒ ๋ฐ์ ํ๊ณ ์์ด. ์ต์ ํธ๋ ๋๋ฅผ ์์๋๋ฉด ๋ ๋์ ์์คํ ์ ๋ง๋ค ์ ์์ง! ๐
๐งฌ 1. ์ํผ์๋ ๋ฉ๋ชจ๋ฆฌ (Episodic Memory)
์ธ๊ฐ์ ์ผํ ๊ธฐ์ต์ฒ๋ผ, AI๋ ํน์ ์ฌ๊ฑด์ด๋ ๊ฒฝํ์ ์๊ฐ ์์๋๋ก ๊ธฐ์ตํ๋ ๊ฑฐ์ผ. ๋จ์ํ ์ ๋ณด๋ฅผ ์ ์ฅํ๋ ๊ฒ ์๋๋ผ, "์ธ์ , ์ด๋์, ๋ฌด์จ ์ผ์ด ์์๋์ง"๋ฅผ ๋งฅ๋ฝ๊ณผ ํจ๊ป ์ ์ฅํด.
์๋ฅผ ๋ค์ด, "์ง๋๋ฒ์ ์ฌ๋ฅ๋ท์์ ํ๋ก๊ทธ๋๋ฐ ๊ฐ์ ๋ค์๋ ๊ฑฐ ๊ธฐ์ต๋?"๋ผ๊ณ ๋ฌผ์ผ๋ฉด, ๋จ์ํ "ํ๋ก๊ทธ๋๋ฐ"์ด๋ผ๋ ํค์๋๋ง ์ฐพ๋ ๊ฒ ์๋๋ผ, ๊ทธ๋์ ์ ์ฒด ์ํฉ์ ์ฌ๊ตฌ์ฑํ ์ ์์ด. ๐ฌ
๐ 2. ์ง์์ ํ์ต (Continual Learning)
๊ธฐ์กด ์ง์์ ์์ง ์์ผ๋ฉด์ ์๋ก์ด ์ ๋ณด๋ฅผ ๊ณ์ ํ์ตํ๋ ๊ฑฐ์ผ. ์ด๊ฒ ์ง์ง ์ด๋ ค์ด ๋ฌธ์ ์ธ๋ฐ, "Catastrophic Forgetting"(ํ๊ตญ์ ๋ง๊ฐ)์ด๋ผ๋ ํ์ ๋๋ฌธ์ด์ผ.
ํด๊ฒฐ ๋ฐฉ๋ฒ:
โข Elastic Weight Consolidation (EWC): ์ค์ํ ๊ฐ์ค์น๋ ๋ ๋ณ๊ฒฝ
โข Progressive Neural Networks: ์๋ก์ด ํ์คํฌ๋ง๋ค ๋คํธ์ํฌ ํ์ฅ
โข Memory Replay: ๊ณผ๊ฑฐ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ธฐ์ ์ผ๋ก ์ฌํ์ต
๐ง 3. ๋ฉํฐ๋ชจ๋ฌ ๋ฉ๋ชจ๋ฆฌ
ํ
์คํธ๋ง์ด ์๋๋ผ ์ด๋ฏธ์ง, ์์ฑ, ๋น๋์ค๊น์ง ํตํฉํด์ ๊ธฐ์ตํ๋ ๊ฑฐ์ผ. "์ ๋ฒ์ ๋ณด์ฌ์ค ๊ทธ ์ฌ์ง ๊ธฐ์ต๋?"๋ผ๊ณ ๋ฌผ์ผ๋ฉด ์ฐพ์์ค ์ ์์ด์ผ์ง! ๐ธ
CLIP, DALL-E ๊ฐ์ ๋ฉํฐ๋ชจ๋ฌ ๋ชจ๋ธ์ ํ์ฉํ๋ฉด ๊ฐ๋ฅํด. ํ
์คํธ์ ์ด๋ฏธ์ง๋ฅผ ๊ฐ์ ์๋ฒ ๋ฉ ๊ณต๊ฐ์ ๋งคํํ๋ ๊ฑฐ์ง.
๐ค 4. ํ๋๋ ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ (Federated Memory)
์ฌ๋ฌ ์ฌ์ฉ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ๋ผ์ด๋ฒ์๋ฅผ ๋ณดํธํ๋ฉด์ ๊ณต์ ํ๋ ๊ฐ๋
์ด์ผ. ์๋ฅผ ๋ค์ด, "๋ค๋ฅธ ์ฌ๋๋ค์ ์ด ๋ฌธ์ ๋ฅผ ์ด๋ป๊ฒ ํด๊ฒฐํ์ง?"๋ผ๋ ์ง๋ฌธ์ ๋ตํ ์ ์์ด.
๊ฐ์ธ ์ ๋ณด๋ ๋ก์ปฌ์ ์ ์ฅํ๊ณ , ์ผ๋ฐํ๋ ํจํด๋ง ์ค์ ์๋ฒ์ ๊ณต์ ํ๋ ๋ฐฉ์์ด์ผ. ๐
โก 5. ์ค์๊ฐ ๋ฉ๋ชจ๋ฆฌ ์ ๋ฐ์ดํธ
๋ํ ์ค์ ์ค์๊ฐ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์
๋ฐ์ดํธํ๊ณ , ์ฆ์ ๋ฐ์ํ๋ ๊ฑฐ์ผ. ๊ธฐ์กด์๋ ๋ํ๊ฐ ๋๋ ํ์ ๋ฐฐ์น๋ก ์ฒ๋ฆฌํ๋๋ฐ, ์ด์ ๋ ์คํธ๋ฆฌ๋ฐ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌํด.
WebSocket์ด๋ Server-Sent Events๋ฅผ ์ฌ์ฉํด์ ๊ตฌํํ ์ ์์ด.
๐ ์ค์ ํ๋ก์ ํธ: ์์ ํ ๋ฉ๋ชจ๋ฆฌ ์์คํ ๊ตฌ์ถ
์, ์ด์ ๋ฐฐ์ด ๊ฑธ ๋ค ํฉ์ณ์ ์์ ํ ์์คํ ์ ๋ง๋ค์ด๋ณด์! ๐๏ธ ์ค์ ๋ก ๋ฐฐํฌ ๊ฐ๋ฅํ ์์ค์ ์ฝ๋์ผ.
๐ฆ ์ ์ฒด ์ํคํ ์ฒ
memory_system/
โโโ core/
โ โโโ __init__.py
โ โโโ memory_manager.py # ๋ฉ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์
โ โโโ embeddings.py # ์๋ฒ ๋ฉ ์ฒ๋ฆฌ
โ โโโ retrieval.py # ๊ฒ์ ๋ก์ง
โโโ storage/
โ โโโ __init__.py
โ โโโ redis_store.py # Working Memory
โ โโโ vector_store.py # Recent Memory
โ โโโ sql_store.py # Long-Term Memory
โโโ utils/
โ โโโ __init__.py
โ โโโ encryption.py # ์ํธํ
โ โโโ preprocessing.py # ์ ์ฒ๋ฆฌ
โ โโโ evaluation.py # ํ๊ฐ
โโโ api/
โ โโโ __init__.py
โ โโโ endpoints.py # FastAPI ์๋ํฌ์ธํธ
โโโ config.py # ์ค์
โโโ main.py # ์ง์
์
๐ง ํต์ฌ ๊ตฌํ: MemoryManager
from typing import List, Dict, Optional
from datetime import datetime, timedelta
import asyncio
class MemoryManager:
"""ํตํฉ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ์์คํ
"""
def __init__(self, user_id: str, config: Dict):
self.user_id = user_id
self.config = config
# 3-Tier ์ ์ฅ์ ์ด๊ธฐํ
self.working_memory = RedisStore(config['redis'])
self.vector_memory = VectorStore(config['vector_db'])
self.longterm_memory = SQLStore(config['postgres'])
# ์ ํธ๋ฆฌํฐ
self.embedder = EmbeddingService(config['embedding'])
self.encryptor = EncryptionService(config['encryption_key'])
async def add_memory(self, content: str, metadata: Dict = None) -> str:
"""์๋ก์ด ๋ฉ๋ชจ๋ฆฌ ์ถ๊ฐ (๋น๋๊ธฐ)"""
try:
# 1. ์ ์ฒ๋ฆฌ
processed = self.preprocess(content)
# 2. ๋ฏผ๊ฐ์ ๋ณด ์ต๋ช
ํ
anonymized = self.encryptor.anonymize_pii(processed)
# 3. ์๋ฒ ๋ฉ ์์ฑ
embedding = await self.embedder.get_embedding_async(anonymized)
# 4. ๋ฉํ๋ฐ์ดํฐ ๋ณด๊ฐ
enriched_metadata = self.enrich_metadata(content, metadata)
# 5. 3-Tier์ ๋ณ๋ ฌ ์ ์ฅ
memory_id = self.generate_id()
tasks = [
self.working_memory.add_async(memory_id, content),
self.vector_memory.add_async(
memory_id, embedding, anonymized, enriched_metadata
),
self.longterm_memory.add_async(
memory_id, content, enriched_metadata
)
]
await asyncio.gather(*tasks)
return memory_id
except Exception as e:
logger.error(f"Failed to add memory: {e}")
raise
async def search_memory(self, query: str,
filters: Dict = None,
top_k: int = 5) -> List[Dict]:
"""๋ฉ๋ชจ๋ฆฌ ๊ฒ์ (ํ์ด๋ธ๋ฆฌ๋)"""
# 1. ์ฟผ๋ฆฌ ์๋ฒ ๋ฉ
query_embedding = await self.embedder.get_embedding_async(query)
# 2. 3-Tier ๋ณ๋ ฌ ๊ฒ์
working_results = await self.working_memory.search_async(query)
vector_results = await self.vector_memory.search_async(
query_embedding, filters, top_k * 2
)
longterm_results = await self.longterm_memory.search_async(
query, filters
)
# 3. ๊ฒฐ๊ณผ ๋ณํฉ ๋ฐ ๋ฆฌ๋ญํน
merged = self.merge_and_rerank(
working_results,
vector_results,
longterm_results,
query
)
# 4. ์ ๊ทผ ํ์ ์
๋ฐ์ดํธ (๋น๋๊ธฐ)
asyncio.create_task(self.update_access_counts(merged))
return merged[:top_k]
def merge_and_rerank(self, *result_lists, query: str) -> List[Dict]:
"""๊ฒฐ๊ณผ ๋ณํฉ ๋ฐ ๋ฆฌ๋ญํน"""
# ์ค๋ณต ์ ๊ฑฐ
seen = set()
merged = []
for results in result_lists:
for item in results:
if item['id'] not in seen:
merged.append(item)
seen.add(item['id'])
# ๋ฆฌ๋ญํน ์ ์ ๊ณ์ฐ
for item in merged:
score = self.calculate_relevance_score(item, query)
item['final_score'] = score
# ์ ๋ ฌ
merged.sort(key=lambda x: x['final_score'], reverse=True)
return merged
def calculate_relevance_score(self, item: Dict, query: str) -> float:
"""๊ด๋ จ์ฑ ์ ์ ๊ณ์ฐ"""
# ์ฌ๋ฌ ์์๋ฅผ ๊ณ ๋ คํ ์ ์
vector_score = item.get('similarity', 0.0)
recency_score = self.calculate_recency_score(item['timestamp'])
importance_score = item.get('importance', 0.5)
access_score = min(item.get('access_count', 0) / 10, 1.0)
# ๊ฐ์ค ํ๊ท
final_score = (
vector_score * 0.4 +
recency_score * 0.3 +
importance_score * 0.2 +
access_score * 0.1
)
return final_score
def calculate_recency_score(self, timestamp: str) -> float:
"""์๊ฐ ๊ธฐ๋ฐ ์ ์ (์ต๊ทผ์ผ์๋ก ๋์)"""
dt = datetime.fromisoformat(timestamp)
age_days = (datetime.now() - dt).days
# ์ง์ ๊ฐ์
return math.exp(-age_days / 30) # 30์ผ ๋ฐ๊ฐ๊ธฐ
async def forget_memory(self, memory_id: str):
"""๋ฉ๋ชจ๋ฆฌ ์ญ์ (GDPR ์ค์)"""
tasks = [
self.working_memory.delete_async(memory_id),
self.vector_memory.delete_async(memory_id),
self.longterm_memory.delete_async(memory_id)
]
await asyncio.gather(*tasks)
# ๊ฐ์ฌ ๋ก๊ทธ
await self.log_deletion(memory_id)
async def compress_old_memories(self, days_threshold: int = 30):
"""์ค๋๋ ๋ฉ๋ชจ๋ฆฌ ์์ถ"""
cutoff_date = datetime.now() - timedelta(days=days_threshold)
# ์ค๋๋ ๋ฉ๋ชจ๋ฆฌ ์กฐํ
old_memories = await self.longterm_memory.get_before_date(cutoff_date)
for memory in old_memories:
# GPT๋ก ์์ฝ
summary = await self.summarize_memory(memory['content'])
# ์์ฝ๋ณธ์ผ๋ก ๊ต์ฒด
await self.longterm_memory.update_async(
memory['id'],
{'content': summary, 'compressed': True}
)
# ๋ฒกํฐ DB์์๋ ์ญ์ (๋น์ฉ ์ ๊ฐ)
await self.vector_memory.delete_async(memory['id'])
๐ FastAPI ์๋ํฌ์ธํธ
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
app = FastAPI(title="AI Memory System")
class MemoryInput(BaseModel):
content: str
metadata: Optional[Dict] = None
class SearchQuery(BaseModel):
query: str
filters: Optional[Dict] = None
top_k: int = 5
@app.post("/memory/add")
async def add_memory(
input: MemoryInput,
user_id: str = Depends(get_current_user)
):
"""๋ฉ๋ชจ๋ฆฌ ์ถ๊ฐ"""
manager = get_memory_manager(user_id)
try:
memory_id = await manager.add_memory(
input.content,
input.metadata
)
return {"memory_id": memory_id, "status": "success"}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.post("/memory/search")
async def search_memory(
query: SearchQuery,
user_id: str = Depends(get_current_user)
):
"""๋ฉ๋ชจ๋ฆฌ ๊ฒ์"""
manager = get_memory_manager(user_id)
results = await manager.search_memory(
query.query,
query.filters,
query.top_k
)
return {"results": results, "count": len(results)}
@app.delete("/memory/{memory_id}")
async def delete_memory(
memory_id: str,
user_id: str = Depends(get_current_user)
):
"""๋ฉ๋ชจ๋ฆฌ ์ญ์ """
manager = get_memory_manager(user_id)
await manager.forget_memory(memory_id)
return {"status": "deleted"}
@app.get("/memory/stats")
async def get_stats(user_id: str = Depends(get_current_user)):
"""๋ฉ๋ชจ๋ฆฌ ํต๊ณ"""
manager = get_memory_manager(user_id)
stats = await manager.get_statistics()
return stats
๐ฏ ๋ง๋ฌด๋ฆฌ: ํต์ฌ ์์ฝ
์, ์ฌ๊ธฐ๊น์ง ์๋ค๋ ๋๋จํด! ๐ ๊ธด ์ฌ์ ์ด์์ง? ํต์ฌ ๋ด์ฉ์ ์ ๋ฆฌํด๋ณผ๊ฒ.
2. ์๋ฒ ๋ฉ์ด ํต์ฌ: ์๋ฏธ ๊ธฐ๋ฐ ๊ฒ์์ ์ํด ํ ์คํธ๋ฅผ ๋ฒกํฐ๋ก ๋ณํ
3. ํ์ด๋ธ๋ฆฌ๋ ๊ฒ์: ๋ฒกํฐ ์ ์ฌ๋ + ๋ฉํ๋ฐ์ดํฐ ํํฐ + ์๊ฐ ๊ฐ์ค์น
4. ํ๋ผ์ด๋ฒ์ ์ต์ฐ์ : ์ํธํ, ์ต๋ช ํ, ์ ๊ทผ ์ ์ด, ์ญ์ ๊ธฐ๋ฅ
5. ๋น์ฉ ์ต์ ํ: ๋ฐฐ์น ์ฒ๋ฆฌ, ์บ์ฑ, ์์ถ, ๋ก์ปฌ ๋ชจ๋ธ ํ์ฉ
6. ์ฑ๋ฅ ์ค์: ๋น๋๊ธฐ ์ฒ๋ฆฌ, ๋ณ๋ ฌ ๊ฒ์, ์ธ๋ฑ์ฑ
7. ์ง์์ ๊ฐ์ : ํ๊ฐ ์งํ ๋ชจ๋ํฐ๋ง, A/B ํ ์คํธ, ์ฌ์ฉ์ ํผ๋๋ฐฑ
AI ์ฅ๊ธฐ๊ธฐ์ต ์์คํ
์ ๋จ์ํ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๊ฒ ์๋์ผ. ์ฌ์ฉ์๋ฅผ ์ดํดํ๊ณ , ๋งฅ๋ฝ์ ํ์
ํ๊ณ , ๊ฐ์ธํ๋ ๊ฒฝํ์ ์ ๊ณตํ๋ ํต์ฌ ๊ธฐ์ ์ด์ง. ๐ง
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์๋ ์ด๋ฐ ๊ธฐ์ ์ ํ์ฉํ AI ์๋น์ค๋ค์ด ์ ์ ๋์ด๋๊ณ ์์ด. ๊ฐ๋ฐ์๋ค์ด ์์ ์ AI ํ๋ก์ ํธ์ ์ฅ๊ธฐ๊ธฐ์ต ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ฉด์, ๋ ๋๋ํ๊ณ ์ ์ฉํ ์๋น์ค๋ค์ด ํ์ํ๊ณ ์์ง.
๋๋ ์ด์ ์ง์ ๊ตฌํํด๋ณผ ์ ์์ ๊ฑฐ์ผ! ์ฒ์์๋ ๊ฐ๋จํ ๋ฒกํฐ DB ์ฐ๋๋ถํฐ ์์ํด์, ์ ์ฐจ ๋ณต์กํ ๊ธฐ๋ฅ๋ค์ ์ถ๊ฐํด๋๊ฐ๋ฉด ๋ผ. ์คํจ๋ฅผ ๋๋ ค์ํ์ง ๋ง๊ณ , ๊ณ์ ์คํํ๊ณ ๊ฐ์ ํด๋๊ฐ๋ ๊ฒ ์ค์ํด. ๐ช
๊ธฐ์ตํด, AI์ ์ง์ง ํ์ ๋จ์ํ ๋ง์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฒ ์๋๋ผ, ์ ์ ํ ์๊ฐ์ ์ ์ ํ ์ ๋ณด๋ฅผ ๊ธฐ์ตํด๋ด๋ ๋ฅ๋ ฅ์ ์์ด. ๋ง์น ์ข์ ์น๊ตฌ์ฒ๋ผ ๋ง์ด์ผ. ๐
์, ์ด์ ๋๊ฐ์ ๋ฉ์ง AI ๋ฉ๋ชจ๋ฆฌ ์์คํ
์ ๋ง๋ค์ด๋ด! ํ์ดํ
! ๐โจ
๐ก ๋ ๊น์ด ๋ฐฐ์ฐ๊ณ ์ถ๋ค๋ฉด?
์ฌ๋ฅ๋ท์์ AI ๊ฐ๋ฐ ์ ๋ฌธ๊ฐ๋ค์ ๊ฐ์๋ฅผ ๋ค์ด๋ณด์ธ์!
์ค์ ํ๋ก์ ํธ ๊ฒฝํ์ ๊ณต์ ํ๋ ๊ฐ๋ฐ์๋ค๊ณผ ํจ๊ป ์ฑ์ฅํ ์ ์์ต๋๋ค. ๐ฑ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.