Memory pro AI agenty
Memory neboli paměť je klíčovou komponentou moderních AI agentů a LLM modelů. Umožňuje jim uchovávat kontext z předchozích interakcí a využívat získané informace pro lepší rozhodování.
Memory pro AI agenty: Klíč k inteligentnímu chování
AI agenti dosáhnou skutečné užitečnosti až ve chvíli, kdy si dokáží pamatovat kontext předchozích interakcí a postupně budovat znalosti. Bez memory mechanismu je každá konverzace izolovaná a agent začíná vždy od nuly. V tomto článku si ukážeme, jak implementovat různé typy paměti pro AI agenty a jaké výzvy to přináší.
Typy memory pro AI agenty
Memory systémy pro AI agenty můžeme rozdělit do několika kategorií podle časového horizontu a způsobu ukládání informací:
Short-term Memory (Krátkodobá paměť)
Nejjednodušší forma memory je udržování kontextu během jedné konverzace. Moderní LLM mají omezenou velikost context window, takže musíme implementovat strategie pro efektivní správu tokenu:
class ShortTermMemory:
def __init__(self, max_tokens: int = 4000):
self.messages: List[Dict] = []
self.max_tokens = max_tokens
def add_message(self, role: str, content: str):
message = {"role": role, "content": content}
self.messages.append(message)
self._trim_if_needed()
def _trim_if_needed(self):
# Jednoduchá strategie - odstraň nejstarší zprávy
current_tokens = self._count_tokens()
while current_tokens > self.max_tokens and len(self.messages) > 2:
self.messages.pop(1) # Zachovej system message
current_tokens = self._count_tokens()
def get_context(self) -> List[Dict]:
return self.messages.copy()
Long-term Memory (Dlouhodobá paměť)
Pro skutečně inteligentní chování potřebujeme ukládat informace napříč sezeními. Zde se využívá kombinace vektorových databází a strukturovaného ukládání:
import chromadb
from sentence_transformers import SentenceTransformer
class LongTermMemory:
def __init__(self, collection_name: str = "agent_memory"):
self.client = chromadb.Client()
self.collection = self.client.create_collection(collection_name)
self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
def store_memory(self, content: str, metadata: Dict = None):
# Vytvoř embedding
embedding = self.encoder.encode([content])[0].tolist()
# Ulož do vektorové DB
self.collection.add(
embeddings=[embedding],
documents=[content],
metadatas=[metadata or {}],
ids=[str(hash(content))]
)
def retrieve_relevant_memories(self, query: str, n_results: int = 3):
query_embedding = self.encoder.encode([query])[0].tolist()
results = self.collection.query(
query_embeddings=[query_embedding],
n_results=n_results
)
return results['documents'][0] if results['documents'] else []
RAG (Retrieval-Augmented Generation) integrace
Memory systém se nejčastěji implementuje pomocí RAG pattern, kde agent před generováním odpovědi vyhledá relevantní informace ze své paměti:
class MemoryEnhancedAgent:
def __init__(self, llm_client, memory_system):
self.llm = llm_client
self.memory = memory_system
async def process_query(self, user_input: str) -> str:
# 1. Vyhledej relevantní vzpomínky
relevant_memories = self.memory.retrieve_relevant_memories(
user_input, n_results=5
)
# 2. Sestav kontext s memory
context = self._build_context_with_memory(
user_input,
relevant_memories
)
# 3. Generuj odpověď
response = await self.llm.generate(context)
# 4. Ulož interakci do memory
self.memory.store_memory(
f"User: {user_input}\nAssistant: {response}",
metadata={
"timestamp": datetime.now().isoformat(),
"type": "conversation"
}
)
return response
def _build_context_with_memory(self, query: str, memories: List[str]) -> str:
memory_context = "\n".join([f"Memory: {mem}" for mem in memories])
return f"""
Relevant memories from previous interactions:
{memory_context}
Current user query: {query}
Please respond based on the context and memories above.
"""
Hierarchická memory struktura
Pro komplexnější aplikace můžeme implementovat hierarchickou strukturu memory, kde různé typy informací mají různé priority a způsoby ukládání:
class HierarchicalMemory:
def __init__(self):
self.episodic_memory = LongTermMemory("episodic") # Konkrétní události
self.semantic_memory = LongTermMemory("semantic") # Obecné znalosti
self.procedural_memory = {} # Naučené postupy
def store_interaction(self, interaction_data: Dict):
# Episodic memory - konkrétní interakce
self.episodic_memory.store_memory(
interaction_data['content'],
{**interaction_data['metadata'], 'type': 'episodic'}
)
# Extrahuj a ulož obecné znalosti
facts = self._extract_facts(interaction_data['content'])
for fact in facts:
self.semantic_memory.store_memory(
fact,
{'type': 'semantic', 'confidence': 0.8}
)
def retrieve_context(self, query: str) -> Dict:
episodic = self.episodic_memory.retrieve_relevant_memories(query, 3)
semantic = self.semantic_memory.retrieve_relevant_memories(query, 2)
return {
'episodic_memories': episodic,
'semantic_knowledge': semantic,
'procedures': self._find_relevant_procedures(query)
}
def _extract_facts(self, content: str) -> List[str]:
# Zde by byla implementace extrakce faktů pomocí NLP
# Pro jednoduchost vrátíme placeholder
return []
def _find_relevant_procedures(self, query: str) -> List[str]:
# Vyhledávání v procedural memory
return []
Optimalizace a výzvy
Implementace memory pro AI agenty přináší několik technických výzev:
Správa velikosti paměti
Memory může rychle narůst do nezvladatelných rozměrů. Potřebujeme implementovat strategie pro čištění a archivaci:
class MemoryManager:
def __init__(self, memory_system, max_memories: int = 10000):
self.memory = memory_system
self.max_memories = max_memories
def cleanup_old_memories(self, retention_days: int = 30):
cutoff_date = datetime.now() - timedelta(days=retention_days)
# Implementace závisí na konkrétní databázi
# Příklad pro Chroma DB s metadata filtrem
old_memories = self.memory.collection.get(
where={"timestamp": {"<": cutoff_date.isoformat()}}
)
if len(old_memories['ids']) > 0:
self.memory.collection.delete(ids=old_memories['ids'])
def compress_memories(self):
# Sumarizace starých vzpomínek pomocí LLM
# Zachování pouze klíčových informací
pass
Konzistence a aktualizace
Memory může obsahovat zastaralé nebo konfliktní informace. Potřebujeme mechanismy pro aktualizaci a řešení konfliktů:
class ConsistentMemory(LongTermMemory):
def update_memory(self, old_content: str, new_content: str):
# Najdi podobné vzpomínky
similar = self.retrieve_relevant_memories(old_content, n_results=10)
# Označ jako zastaralé a přidej novou verzi
for memory in similar:
if self._is_conflicting(memory, new_content):
self._mark_as_outdated(memory)
self.store_memory(
new_content,
{"type": "updated", "timestamp": datetime.now().isoformat()}
)
def _is_conflicting(self, memory1: str, memory2: str) -> bool:
# Implementace detekce konfliktu
# Může využívat embedding similarity nebo LLM
return False
def _mark_as_outdated(self, memory: str):
# Označení vzpomínky jako zastaralé
pass
Shrnutí
Memory systémy jsou kritickou komponentou moderních AI agentů. Kombinace krátkodobé a dlouhodobé paměti s RAG patternem umožňuje vytváření skutečně inteligentních asistentů schopných učení a adaptace. Při implementaci je klíčové zvážit optimalizaci výkonu, správu velikosti dat a konzistenci informací. S rostoucími možnostmi LLM a vektorových databází se memory systémy stanou ještě důležitějšími pro vytváření sofistikovaných AI aplikací.