Paměť pro AI agenty v Pythonu: Průvodce frameworky Mem0, Letta a LangMem

Jazykové modely nemají paměť. Zní to jednoduše, ale důsledky jsou obrovské. Každý dotaz zpracovávají od nuly, bez jakéhokoliv povědomí o tom, co jste jim řekli před pěti minutami, natož před týdnem. Pro jednorázové dotazy to nevadí — ale jakmile stavíte AI agenta, který má dlouhodobě asistovat konkrétnímu uživateli, narazíte na zeď. Agent bez paměti se chová jako kolega s amnézií: pokaždé se znovu ptá na vaše jméno, zapomíná na vaše preference a opakuje stejné chyby.

Upřímně řečeno, je to frustrující.

V roce 2026 se paměť pro AI agenty stala jedním z nejžhavějších témat v oblasti LLM aplikací. Vznikl celý nový segment nástrojů — takzvané memory-native frameworky — navržených specificky pro to, aby agenti mohli ukládat, vyhledávat a aktualizovat znalosti napříč konverzacemi. V tomhle článku si projdeme tři nejdůležitější: Mem0, Letta a LangMem. U každého si ukážeme reálný kód v Pythonu, vysvětlíme architekturu a porovnáme, kdy se který hodí.

Proč bezstavové LLM nestačí

Kontextové okno moderních modelů roste — Claude 4 zvládne 200 tisíc tokenů, Gemini 2.5 milion. Jenže větší kontextové okno problém paměti neřeší, jen ho odkládá. S každým tokenem v kontextu roste latence, cena i riziko, že se model v záplavě informací prostě ztratí.

Představte si zákaznického chatbota pro e-shop. Uživatel se před týdnem ptal na podmínky vrácení zboží a zmínil, že preferuje komunikaci e-mailem. Dnes se vrací s dotazem na stav objednávky. Bez paměťové vrstvy agent o předchozí konverzaci neví vůbec nic — a uživatel musí všechno opakovat. S paměťovou vrstvou agent ví, kdo uživatel je, jaké má preference, a může rovnou nabídnout relevantní odpověď.

Tady je důležité rozlišovat: RAG přináší externí znalosti (dokumenty, manuály, znalostní báze), zatímco paměť agenta uchovává kontext interakcí (preference uživatele, historii konverzací, naučené vzory). Jsou to komplementární mechanismy — produkční agent obvykle potřebuje obojí.

Typy paměti AI agentů

Paměťové systémy pro AI agenty se (možná nepřekvapivě) inspirují lidskou kognitivní psychologií. Výzkumný článek Cognitive Architectures for Language Agents (CoALA) z Princetonské univerzity definuje základní taxonomii, která se v praxi ujala jako standard.

Krátkodobá paměť (Short-Term Memory)

Uchovává kontext aktuální konverzace — historii zpráv v rámci jednoho vlákna. V praxi jde o obsah kontextového okna. Každý framework ji implementuje automaticky, ale klíčová je efektivní správa: jakmile konverzace překročí limit kontextu, je třeba historii sumarizovat nebo starší zprávy přesunout do archivu.

Dlouhodobá paměť (Long-Term Memory)

Perzistuje napříč sezeními a konverzačními vlákny. Uchovává fakta, preference a naučené vzory, které agent potřebuje i za týden nebo za měsíc.

Dělí se na dva podtypy:

• Sémantická paměť — fakta a znalosti: „Uživatel je vegetarián", „Preferuje Python před JavaScriptem", „Pracuje ve společnosti XYZ"
• Epizodická paměť — konkrétní události a interakce: „Minulý týden jsme řešili problém s API klíčem", „Uživatel si stěžoval na pomalou odezvu"

Grafová paměť (Graph Memory)

Novější přístup, který uchovává vztahy mezi entitami jako znalostní graf. Díky tomu umí odpovídat na dotazy typu „Kdo z mého týmu pracuje na projektu Alpha?" nebo „Jaké frameworky používáme na backendu?" — tedy na otázky, kde potřebujete propojit více faktů dohromady. Osobně si myslím, že grafová paměť bude v příštích měsících hrát čím dál větší roli.

Mem0 — univerzální paměťová vrstva

Mem0 (vyslovujte „mem-zero") je v roce 2026 nejpoužívanější paměťový framework s více než 45 tisíci hvězdičkami na GitHubu. A hlavní důvod je prostý — jednoduchost. Paměť přidáte do existující aplikace doslova na pár řádků kódu.

Architektura Mem0

Mem0 kombinuje vektorové vyhledávání se systémem automatické extrakce. Když přidáte konverzaci do paměti, Mem0 interně použije LLM k extrakci klíčových informací — nemusíte ručně tagovat, co se má zapamatovat. Při vyhledávání pak provádí sémantický search přes embeddingy a vrací relevantní vzpomínky.

Na vyšší úrovni nabízí i grafovou paměť (Mem0^g), která vytváří vztahy mezi entitami. Na benchmarku LOCOMO dosáhl Mem0 o 26 % vyšší přesnosti než vestavěná paměť OpenAI, s 91% nižší latencí a 90% úsporou tokenů. To jsou čísla, která stojí za pozornost.

Instalace a základní použití

# Instalace open-source verze
pip install mem0ai

# Nebo s konkrétním poskytovatelem
pip install "mem0ai[anthropic]"

Tak, pojďme rovnou ke kódu. Nejjednodušší scénář — přidání a vyhledání paměti přes platformu (managed služba):

from mem0 import MemoryClient

# Inicializace s API klíčem z app.mem0.ai
client = MemoryClient(api_key="m0-xxx")

# Přidání konverzace do paměti
zpravy = [
    {"role": "user", "content": "Ahoj, jmenuju se Tomáš. Pracuji jako "
     "datový inženýr a preferuji Python a SQL."},
    {"role": "assistant", "content": "Rád tě poznávám, Tomáši! "
     "Zapamatuji si tvé preference."}
]
client.add(zpravy, user_id="tomas", version="v2")

# Později — vyhledání relevantních vzpomínek
vysledky = client.search(
    "Jaké programovací jazyky používá Tomáš?",
    user_id="tomas"
)
for vysledek in vysledky["results"]:
    print(vysledek["memory"])
# → "Datový inženýr. Preferuje Python a SQL."

Self-hosted varianta s vlastním LLM

Pokud nechcete posílat data na externí službu (a spousta týmů nechce, hlavně kvůli compliance), můžete Mem0 provozovat lokálně s vlastní konfigurací vektorové databáze a LLM:

from mem0 import Memory

config = {
    "llm": {
        "provider": "anthropic",
        "config": {
            "model": "claude-sonnet-4-20250514",
            "api_key": "sk-ant-xxx",
        }
    },
    "embedder": {
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small",
            "api_key": "sk-xxx",
        }
    },
    "vector_store": {
        "provider": "qdrant",
        "config": {
            "host": "localhost",
            "port": 6333,
        }
    }
}

memory = Memory.from_config(config)

# Přidání a vyhledání funguje stejně
memory.add(
    "Preferuji tmavý režim a klávesové zkratky ve stylu Vim.",
    user_id="tomas"
)

vysledky = memory.search("Jaké má Tomáš UI preference?", user_id="tomas")
for v in vysledky["results"]:
    print(v["memory"])

Chatbot s pamětí — kompletní příklad

Tohle je vzor, který v praxi používám nejčastěji. Jednoduchý chatbot, který si pamatuje kontext mezi konverzacemi:

from openai import OpenAI
from mem0 import Memory

openai_client = OpenAI()
memory = Memory()

def chat_s_pameti(zprava: str, user_id: str = "vychozi") -> str:
    # 1. Načtení relevantních vzpomínek
    vzpominky = memory.search(query=zprava, user_id=user_id, limit=5)
    kontext_pameti = "\n".join(
        f"- {v['memory']}" for v in vzpominky["results"]
    )

    # 2. Sestavení promptu s kontextem
    systemovy_prompt = f"""Jsi osobní AI asistent. Využij tyto vzpomínky
z předchozích konverzací k personalizaci odpovědi:

{kontext_pameti if kontext_pameti else 'Žádné relevantní vzpomínky.'}"""

    # 3. Generování odpovědi
    odpoved = openai_client.chat.completions.create(
        model="gpt-4.1",
        messages=[
            {"role": "system", "content": systemovy_prompt},
            {"role": "user", "content": zprava}
        ]
    )
    asistent_zprava = odpoved.choices[0].message.content

    # 4. Uložení celé konverzace do paměti
    memory.add(
        [
            {"role": "user", "content": zprava},
            {"role": "assistant", "content": asistent_zprava}
        ],
        user_id=user_id
    )

    return asistent_zprava

Letta — agentní runtime s OS architekturou

Letta (dříve MemGPT) přistupuje k paměti zásadně jinak než Mem0. Zatímco Mem0 je paměťová vrstva, kterou přidáte do existující aplikace, Letta je kompletní agentní runtime — celé prostředí, ve kterém agenti běží a sami si aktivně spravují svou paměť. Je to jako porovnávat knihovnu s operačním systémem.

OS analogie

A tahle analogie s operačním systémem není náhodná — autoři Letty se jí přímo inspirovali. Kontextové okno LLM odpovídá RAM — je rychlé, ale omezené. Externí úložiště (databáze) odpovídá disku — je pomalé, ale prakticky neomezené. Agent v Lettě funguje jako proces, který aktivně rozhoduje, co si ponechá v kontextu a co přesune do archivu. K tomu používá speciální nástroje (funkce), které může volat přímo z kontextového okna.

Tři vrstvy paměti v Lettě

• Core Memory — vždy přítomná v kontextu. Obsahuje bloky human (informace o uživateli) a persona (identita agenta). Agent je může přímo editovat.
• Recall Memory — prohledávatelný archiv všech předchozích konverzací. Když agent potřebuje detail z dřívější interakce, provede vyhledávání.
• Archival Memory — dlouhodobé úložiště libovolných znalostí. Agent sem ukládá fakta, dokumenty a informace, které se nevejdou do core memory.

Praktický příklad s Letta

# Instalace klienta
pip install letta-client

from letta_client import Letta

# Připojení k Letta serveru (lokálně nebo cloud)
client = Letta(api_key="your-api-key")

# Vytvoření agenta s paměťovými bloky
agent = client.agents.create(
    model="anthropic/claude-sonnet-4-20250514",
    memory_blocks=[
        {
            "label": "human",
            "value": "Uživatel je Tomáš, datový inženýr. "
                     "Preferuje Python a SQL.",
            "limit": 5000
        },
        {
            "label": "persona",
            "value": "Jsem asistent pro datové inženýrství. "
                     "Komunikuji česky a dávám praktické rady.",
            "limit": 5000
        }
    ]
)

print(f"Agent vytvořen: {agent.id}")

# Odeslání zprávy — agent si sám spravuje paměť
odpoved = client.agents.messages.create(
    agent_id=agent.id,
    input="Právě jsem migroval náš ETL pipeline z Airflow "
          "na Dagster. Zapamatuj si to."
)

for msg in odpoved.messages:
    print(msg)

Klíčový rozdíl: v Lettě neřídíte paměť vy (vývojář) — řídí ji agent sám. Když mu řeknete „Zapamatuj si to", sám rozhodne, kam informaci uloží (core memory, archival memory) a jak ji zformuluje. Je to zároveň síla i slabina — dáváte LLM kontrolu nad perzistentním stavem, a to vyžaduje důvěru v kvalitu modelu.

LangMem — paměť pro LangGraph agenty

LangMem je paměťová knihovna od LangChain, navržená pro nativní integraci s LangGraph. Na rozdíl od Mem0 a Letty je to spíše sada stavebních bloků než hotové řešení — dává vám maximální kontrolu, ale taky od vás víc očekává.

Dva režimy práce s pamětí

• Hot-path nástroje — agent má k dispozici nástroje manage_memory a search_memory, které aktivně volá během konverzace
• Background processing — paměť se extrahuje a konsoliduje asynchronně po skončení konverzace pomocí ReflectionExecutor

Implementace s LangGraph

pip install langmem langgraph

from langgraph.prebuilt import create_react_agent
from langgraph.store.memory import InMemoryStore
from langmem import create_manage_memory_tool, create_search_memory_tool

# Inicializace úložiště s embedding indexem
store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)

# Vytvoření agenta s paměťovými nástroji
agent = create_react_agent(
    "anthropic:claude-sonnet-4-20250514",
    tools=[
        create_manage_memory_tool(namespace=("memories",)),
        create_search_memory_tool(namespace=("memories",)),
    ],
    store=store,
)

# Konverzace s agentem
config = {"configurable": {"thread_id": "vlakno-1"}}

odpoved = agent.invoke(
    {"messages": [
        {"role": "user",
         "content": "Zapamatuj si, že preferuji tmavý režim."}
    ]},
    config=config,
)
print(odpoved["messages"][-1].content)

# Později — agent si vzpomene
odpoved = agent.invoke(
    {"messages": [
        {"role": "user",
         "content": "Jaké mám nastavení UI?"}
    ]},
    config=config,
)
print(odpoved["messages"][-1].content)
# → "Preferujete tmavý režim."

Perzistentní úložiště s PostgreSQL

Pro produkční nasazení vyměňte InMemoryStore za PostgreSQL backend. Mimochodem, tohle je přesně ten krok, na který se často zapomíná při přechodu z prototypu do produkce:

from langgraph.store.postgres import AsyncPostgresStore

store = await AsyncPostgresStore.from_conn_string(
    "postgresql://user:password@localhost:5432/agent_memory"
)
await store.setup()  # vytvoření tabulek

# Zbytek kódu zůstává identický — stačí předat nový store

Srovnání frameworků

Každý z těchto frameworků řeší paměť jiným způsobem a hodí se pro jiný scénář. Tady je přehledné srovnání, které (doufám) pomůže při rozhodování:

Vlastnost	Mem0	Letta	LangMem
Přístup	Paměťová vrstva (knihovna)	Kompletní agentní runtime	Stavební bloky pro LangGraph
Správa paměti	Automatická extrakce LLM	Agent si řídí sám	Vývojář definuje logiku
Grafová paměť	Ano (Mem0g, Pro tier)	Ne	Ne (vyžaduje vlastní implementaci)
Integrace	CrewAI, LangGraph, LlamaIndex, AutoGen	Vlastní ekosystém	LangGraph / LangChain
Self-hosting	Ano (open-source)	Ano (open-source server)	Ano (plně open-source)
Nasazení do produkce	Managed platforma nebo self-hosted	Letta Cloud nebo self-hosted	Závisí na LangGraph infrastruktuře
Křivka učení	Nízká	Střední až vysoká	Střední
Benchmark (LongMemEval)	49 %	83 %	Závisí na konfiguraci

Jak vybrat správný framework

Výběr závisí na tom, co přesně stavíte. Tady není jedna správná odpověď — každý nástroj má své místo.

Použijte Mem0, pokud:

• Potřebujete rychle přidat paměť do existující aplikace
• Stavíte personalizovaného chatbota nebo zákaznický support
• Chcete minimální konfiguraci a rychlý start
• Pracujete s různými agentními frameworky (CrewAI, LlamaIndex, AutoGen)

Použijte Letta, pokud:

• Stavíte sofistikovaného agenta od základů
• Potřebujete, aby agent aktivně řídil svou paměť
• Vyžadujete stavovost a perzistenci celého agentního runtime
• Chcete nejlepší výkon na memory benchmarcích (a těch 83 % na LongMemEval je zatím těžko překonatelných)

Použijte LangMem, pokud:

• Už používáte LangGraph / LangChain ekosystém
• Potřebujete plnou kontrolu nad paměťovou logikou
• Chcete kombinovat hot-path a background zpracování paměti
• Preferujete modulární přístup se stavebními bloky

Architektonické vzory pro produkční nasazení

Bez ohledu na zvolený framework existuje pár osvědčených vzorů. Jsou to věci, na které narazíte, až budete nasazovat do produkce — a lepší je vědět o nich dopředu.

Selektivní ukládání

Ne všechno stojí za zapamatování. Věta „Hmm, nech mě přemýšlet" do dlouhodobé paměti rozhodně nepatří, ale „Jsem vegetarián" ano. Implementujte filtraci — buď na úrovni promptu (instruujte LLM, co má extrahovat), nebo pomocí klasifikátoru, který rozhodne o relevanci.

Deduplikace a konsolidace

Uživatel může ve třech různých konverzacích říct: „Programuji v Pythonu", „Používám Python" a „Python je můj hlavní jazyk". Paměťový systém by měl tyto informace sloučit do jednoho záznamu, ne ukládat tři duplicitní vzpomínky.

Mem0 to řeší automaticky na úrovni extrakce. U LangMem si konsolidační logiku musíte napsat sami — ale na druhou stranu máte plnou kontrolu nad tím, jak sloučení probíhá.

TTL a zapomínání

Některé informace zastarávají. Preference „Právě se učím React" je relevantní měsíc, ne rok. Zvažte implementaci TTL (Time-to-Live) pro různé typy vzpomínek nebo periodický review, kde LLM vyhodnotí, jestli jsou uložené vzpomínky stále aktuální. Tohle je oblast, kde se podle mě dá hodně inovovat.

Oddělení uživatelských a systémových vzpomínek

Používejte namespaces nebo samostatná úložiště pro různé typy paměti. Uživatelské preference, historie konverzací a systémové znalosti mají různé životní cykly a přístupové vzory — míchat je dohromady je recept na problémy.

FAQ

Jaký je rozdíl mezi pamětí AI agenta a RAG?

RAG (Retrieval-Augmented Generation) vyhledává informace v externích dokumentech a znalostních bázích — jde o statické znalosti. Paměť agenta uchovává dynamický kontext z interakcí: preference uživatele, historii konverzací a naučené vzory. V produkčních aplikacích se typicky kombinují oba přístupy — RAG pro doménové znalosti a paměťový framework pro personalizaci.

Kolik stojí provoz paměťového frameworku v produkci?

Hlavní nákladovou položkou jsou volání LLM pro extrakci vzpomínek a generování embeddingů. Mem0 platforma stojí od 0 do 249 USD měsíčně podle tieru. Self-hosted varianta vyžaduje vlastní vektorovou databázi (Qdrant, pgvector) a LLM API. Při průměrném zatížení — řekněme tisíce konverzací denně — počítejte s jednotkami dolarů za den na API volání a infrastrukturu.

Může AI agent zapomenout citlivé informace na požádání?

Ano, všechny tři frameworky podporují mazání vzpomínek. Mem0 nabízí client.delete(memory_id) i hromadné mazání podle user_id. Letta umožňuje editaci a mazání přes API i přímo agentem. LangMem deleguje mazání na store backend. Pro GDPR compliance je klíčové implementovat endpoint pro smazání všech dat uživatele — a tohle prosím nepodceňujte.

Jak řešit paměť při multi-agentních systémech?

Ve scénářích s více agenty rozlišujte sdílenou paměť (přístupnou všem agentům) a soukromou paměť (specifickou pro jednoho agenta). Mem0 podporuje hierarchii user → session → agent. V LangMem můžete definovat různé namespaces pro různé agenty a jeden sdílený namespace pro společné znalosti.

Je lepší použít managed službu, nebo self-hosting?

Pro prototypy a menší aplikace je managed služba (Mem0 Platform, Letta Cloud) výrazně rychlejší na nasazení. Pro produkční aplikace s citlivými daty, požadavky na GDPR nebo nízkou latenci doporučuji self-hosting. Všechny tři frameworky jsou open-source a podporují self-hosted nasazení s vlastní vektorovou databází a LLM poskytovatelem.