Mem0 vs Zep vs Letta: Memória IA 2026

Atualizado em: 29 de julho de 2026

Memória para agentes de IA é a camada que armazena e recupera fatos, preferências e histórico de conversas entre execuções, permitindo que um agente lembre do usuário na próxima interação em vez de tratar cada chamada como uma nova sessão em branco. Em 2026, três frameworks dominam essa categoria em produção (Mem0, Zep e Letta, este último antigo MemGPT), e cada um resolve o problema de forma diferente. Este guia compara arquitetura, custo, latência e código real dos três para você escolher com dados, não com hype.

Mem0 é o mais leve de instalar (SDK Python/JS + provedor de vetor de sua escolha) e melhor para adicionar memória rápida a chatbots existentes.
Zep foca em temporal knowledge graphs com o motor Graphiti, ideal para agentes que precisam raciocinar sobre quando um fato mudou.
Letta (ex-MemGPT) implementa o paradigma MemGPT com hierarquia de memória inspirada em sistemas operacionais, melhor para agentes autônomos de longa duração.
Mem0 custa cerca de US$ 0,003 por operação de escrita na nuvem gerenciada; Zep tem tier gratuito de 10k mensagens/mês; Letta é 100% self-hosted por padrão.
Nenhum dos três substitui um pipeline RAG completo. Eles complementam a recuperação de documentos com memória de conversa e estado do usuário.
Para a maioria dos casos em 2026, comece com Mem0 pela curva de aprendizado; migre para Zep quando precisar de grafos temporais e para Letta quando precisar de agentes que rodam por dias.

Por que agentes de IA precisam de memória?

Um LLM puro é stateless: cada chamada de API recebe uma janela de contexto e devolve uma resposta, sem lembrar de nada da chamada anterior. Se você constrói um agente de suporte que conversou com o mesmo cliente ontem, o LLM não sabe disso, a menos que você reenvie todo o histórico a cada requisição, o que explode o custo em tokens e ainda esbarra no limite da janela de contexto (mesmo com Claude Opus 5 e seus 200k tokens, uma conversa de meses simplesmente não cabe).

É aí que entra a camada de memória. Em vez de reenviar o histórico bruto, você extrai fatos ("o usuário prefere respostas curtas", "trabalha em Lisboa", "o pedido #4521 está atrasado") e os armazena em um sistema externo. Na próxima interação, o agente busca só os fatos relevantes e os injeta no prompt, um padrão que a comunidade chama de selective recall. Isso reduz o custo de tokens em 60–90% em conversas longas, segundo os benchmarks publicados pelo próprio time do Mem0 em 2025.

Honestamente, essa foi a primeira coisa que me fez economizar dinheiro real num projeto de copiloto de vendas: derrubamos a fatura da OpenAI pela metade em duas semanas só trocando "reenviar tudo" por "reenviar o que importa". Há também um ganho de qualidade: agentes com memória personalizada apresentam +26% de precisão em tarefas de acompanhamento multi-turno, conforme o paper original do Mem0 no arXiv. Se você já construiu engenharia de contexto para agentes de IA, a memória é o próximo bloco lógico. Ela transforma o contexto de "tudo que cabe agora" em "tudo que importa agora".

Tipos de memória em agentes: curto prazo, longo prazo, episódica e semântica

Antes de comparar ferramentas, precisamos concordar em vocabulário. A literatura de agentes em 2026 converge em quatro camadas, herdadas da psicologia cognitiva:

Memória de trabalho (working memory): o que está na janela de contexto agora. Some ao fim da chamada.
Memória de curto prazo: a conversa atual, tipicamente as últimas N mensagens ou um resumo rolante.
Memória de longo prazo semântica: fatos consolidados sobre o usuário ou o mundo ("Maria é vegetariana"). Independente de tempo.
Memória de longo prazo episódica: eventos com carimbo temporal ("em 12/03 a Maria reclamou do frete"). Sensível a quando.

Mem0 foca principalmente em memória semântica de longo prazo. Zep adiciona a dimensão episódica via grafos temporais. Letta tenta cobrir tudo em uma hierarquia estilo sistema operacional, com core memory, recall memory e archival memory, mais transições explícitas entre elas. Guardar essa distinção facilita entender por que cada ferramenta faz trade-offs diferentes.

Comparativo rápido: Mem0 vs Zep vs Letta

Critério	Mem0	Zep	Letta
Modelo de dados	Fatos extraídos + vetores	Grafo temporal (Graphiti)	Hierarquia MemGPT (core/recall/archival)
Licença open source	Apache 2.0	Apache 2.0	Apache 2.0
Nuvem gerenciada	Sim (mem0.ai)	Sim (getzep.com)	Sim (letta.com)
Latência típica de recall	50–150 ms	100–300 ms	200–500 ms
Melhor para	Chatbots, assistentes pessoais	Suporte CRM, agentes que raciocinam sobre tempo	Agentes autônomos de longa duração
Suporte a grafos	Opcional (Neo4j/Memgraph)	Nativo	Não
SDK oficial	Python, JS/TS	Python, TS, Go	Python, TS
Curva de aprendizado	Baixa	Média	Alta

Todos os três são open source com licença permissiva, o que remove trava vendor-lock como fator decisivo. A diferença real está no modelo mental: você quer armazenar fatos e buscá-los por similaridade? Mem0. Quer perguntar "o que a Maria pensava sobre X na semana passada"? Zep. Quer um agente que decide sozinho o que mover entre memória rápida e memória arquivada? Letta.

Mem0 em detalhe: instalação, código e casos de uso

Mem0 é a opção mais pragmática para adicionar memória a um agente existente sem reescrever nada. A instalação toma dois minutos:

pip install mem0ai openai

O SDK abstrai o fluxo de extract → store → retrieve em três métodos: add, search e get_all. Um exemplo mínimo com armazenamento local em Qdrant:

from mem0 import Memory
from openai import OpenAI

# Configuração com Qdrant local e OpenAI para embeddings
config = {
    "vector_store": {
        "provider": "qdrant",
        "config": {"host": "localhost", "port": 6333},
    },
    "llm": {
        "provider": "openai",
        "config": {"model": "gpt-5-mini", "temperature": 0.1},
    },
}
memory = Memory.from_config(config)
client = OpenAI()

def chat(user_id: str, message: str) -> str:
    # 1. Recupera fatos relevantes para esta mensagem
    hits = memory.search(query=message, user_id=user_id, limit=5)
    contexto = "\n".join(f"- {h['memory']}" for h in hits["results"])

    # 2. Constrói o prompt com a memória injetada
    prompt = [
        {"role": "system", "content": f"Fatos sobre o usuário:\n{contexto}"},
        {"role": "user", "content": message},
    ]
    resposta = client.chat.completions.create(
        model="gpt-5", messages=prompt
    ).choices[0].message.content

    # 3. Persiste a nova troca. O Mem0 extrai fatos automaticamente
    memory.add(
        messages=[
            {"role": "user", "content": message},
            {"role": "assistant", "content": resposta},
        ],
        user_id=user_id,
    )
    return resposta

print(chat("maria-123", "Sou vegetariana e moro em Lisboa"))
print(chat("maria-123", "Sugira um restaurante para hoje à noite"))

Na segunda chamada, o agente já sabe que Maria é vegetariana e mora em Lisboa, sem que você tenha reenviado a primeira mensagem. Por baixo dos panos, o add() chamou um LLM secundário para extrair fatos discretos ("usuário é vegetariano", "usuário mora em Lisboa"), embutiu cada um e salvou no Qdrant com o user_id como metadado.

O ponto forte do Mem0 é que ele funciona em produção sem cerimônia. O ponto fraco: como armazena fatos discretos, tem dificuldade com perguntas do tipo "quando a Maria mudou de preferência". Para isso, entra o Zep.

Zep e Graphiti: memória como grafo temporal

Zep, através do motor open-source Graphiti no GitHub, modela a memória como um grafo de conhecimento bitemporal. Cada aresta tem carimbo de quando o fato foi verdadeiro e quando o sistema soube dele. Isso permite consultas impossíveis num vetor puro: "quais eram as preferências da Maria em março?", "quando o pedido #4521 mudou de status?".

pip install zep-cloud

from zep_cloud.client import Zep
from zep_cloud.types import Message
import os, uuid

zep = Zep(api_key=os.environ["ZEP_API_KEY"])
user_id = "maria-123"
session_id = str(uuid.uuid4())

zep.user.add(user_id=user_id, email="[email protected]")
zep.memory.add_session(session_id=session_id, user_id=user_id)

# Ingerir mensagens. Zep extrai entidades e relações automaticamente
zep.memory.add(
    session_id=session_id,
    messages=[
        Message(role="user", role_type="user",
                content="Meu pedido 4521 chegou danificado"),
        Message(role="assistant", role_type="assistant",
                content="Vou abrir um chamado de reembolso"),
    ],
)

# Recuperar contexto relevante para a próxima interação
resultado = zep.memory.get(session_id=session_id)
print(resultado.context)  # Contexto pronto para injetar no prompt

O que o Zep devolve em result.context não é uma lista de fatos soltos. É um sumário curado que combina fatos do grafo com trechos relevantes da conversa, já formatado como um bloco de sistema. Você cola direto no prompt e segue. Em benchmarks internos do time do Zep publicados no blog oficial da Zep, essa abordagem supera Mem0 em 18% na precisão de recall em conversas com contradições e atualizações temporais.

O trade-off é operacional: o grafo cresce e exige manutenção. Se seu caso de uso é um chatbot de FAQ, é overkill. Se é um copiloto de vendas que precisa saber quando cada lead mudou de intenção, o Zep paga o próprio preço rapidamente.

Letta (MemGPT): hierarquia de memória para agentes autônomos

Letta é a evolução comercial do paper MemGPT: Towards LLMs as Operating Systems, de 2023, do laboratório Sky Computing em Berkeley. O modelo mental é radicalmente diferente: em vez de você chamar memory.add() a cada turno, o próprio agente decide, via tool calls, o que mover entre três regiões:

Core memory: sempre no contexto (persona do agente + persona do usuário, ~2k tokens).
Recall memory: histórico completo de mensagens, buscável por vector search.
Archival memory: fatos consolidados de longo prazo, também vetorial.

Instalação com o servidor local:

pip install letta
letta server  # Inicia servidor local em http://localhost:8283

from letta_client import Letta

client = Letta(base_url="http://localhost:8283")

agente = client.agents.create(
    name="assistente_maria",
    memory_blocks=[
        {"label": "human",
         "value": "Nome: Maria. Preferências: (a preencher)."},
        {"label": "persona",
         "value": "Sou um assistente pessoal que aprende com cada conversa."},
    ],
    model="openai/gpt-5",
    embedding="openai/text-embedding-3-small",
)

resposta = client.agents.messages.create(
    agent_id=agente.id,
    messages=[{"role": "user", "content": "Sou vegetariana e moro em Lisboa"}],
)

# O agente pode ter chamado core_memory_append ou archival_memory_insert
# sem intervenção do desenvolvedor
for msg in resposta.messages:
    print(msg.message_type, msg.content if hasattr(msg, "content") else msg.tool_call)

A diferença gritante: Letta é o único onde o próprio LLM decide o que vale a pena lembrar. Isso é poderoso para agentes que rodam por dias ou semanas (pense num assistente de coding que acompanha um projeto), e é frágil para casos onde você precisa de garantias sobre o que foi armazenado. Você troca previsibilidade por autonomia.

Como escolher entre Mem0, Zep e Letta?

Um framework de decisão que uso com times que estão começando:

Sua conversa dura menos de 1 hora e você só precisa lembrar o nome, preferências e histórico da sessão? Use o histórico bruto ou um resumo rolante. Não instale nada.
Você tem centenas ou milhares de usuários e quer que o agente lembre entre sessões? Mem0. É a curva mais suave e a manutenção mais leve.
Seu domínio tem entidades que mudam de estado ao longo do tempo (pedidos, tickets, contratos, deals)? Zep. O grafo temporal existe exatamente para isso.
Seu agente roda em background, sem prompt humano a cada turno, por dias? Letta. A autogestão de memória é o único caminho viável.

Uma armadilha comum é confundir memória com RAG. RAG busca em documentos que você já tem (manuais, base de conhecimento, código). Memória armazena o que emergiu das interações. Um agente maduro usa os dois: RAG para conhecimento estável, memória para estado do usuário. Se você ainda não montou o pipeline de recuperação, comece pelo nosso guia de pipelines RAG em produção antes de adicionar memória por cima.

Integração com pipelines RAG e ferramentas existentes

Na prática, memória convive com outras peças da stack: RAG, function calling, filas de tarefas, observabilidade. As três ferramentas expõem integrações prontas com LangChain, LlamaIndex e LangGraph. Se você já usa function calling e tool use, tanto Mem0 quanto Zep se encaixam como uma ferramenta a mais no tool set do agente.

Um padrão eficaz em 2026 é o hybrid recall: cada turno dispara duas buscas em paralelo (uma na base de documentos via RAG, outra na memória do usuário via Mem0 ou Zep), e um reranker (Cohere Rerank 3.5 ou BGE-Reranker-v2) escolhe os melhores N chunks para o prompt final. Isso evita colisões onde documentos genéricos afogam fatos específicos do usuário.

# Padrão de hybrid recall com Mem0 + Qdrant + Cohere Rerank
import cohere
co = cohere.ClientV2(api_key=os.environ["COHERE_API_KEY"])

def hybrid_recall(user_id: str, query: str) -> list[str]:
    docs = qdrant.search("docs", query, limit=10)              # RAG
    mem = memory.search(query, user_id=user_id, limit=10)      # Mem0
    todos = [d.payload["text"] for d in docs] + \
            [m["memory"] for m in mem["results"]]
    ranked = co.rerank(model="rerank-english-v3.5",
                       query=query, documents=todos, top_n=5)
    return [todos[r.index] for r in ranked.results]

Para observar tudo isso em produção (quantas memórias foram recuperadas, quais foram usadas, qual latência), plugue Langfuse ou Arize. A telemetria de memória é sinal precoce de degradação: se a taxa de hits úteis cai abaixo de 40%, provavelmente há drift nos embeddings ou fatos desatualizados no store, e é hora de rodar uma purga. Já vi esse cenário num sistema em produção depois de três meses sem manutenção, e o sintoma na frente do usuário é o agente "esquecendo" coisas que jurou lembrar.

Perguntas frequentes

Qual é a diferença entre Mem0 e Zep?

Mem0 armazena fatos discretos com busca vetorial e é ótimo para chatbots. Zep usa um grafo temporal (Graphiti) que também rastreia quando cada fato foi verdadeiro, melhor para agentes que precisam raciocinar sobre mudanças ao longo do tempo, como pedidos, tickets e deals de CRM.

Letta é o mesmo que MemGPT?

Sim. Letta é a evolução comercial e o novo nome oficial do projeto MemGPT, mantido pelo mesmo time do laboratório Sky Computing de Berkeley. O SDK e o servidor foram renomeados em 2024; o paradigma de memória hierárquica é idêntico.

Preciso de um banco de dados vetorial separado para usar Mem0 ou Zep?

Não obrigatoriamente. Mem0 suporta Qdrant, pgvector, Chroma, Pinecone e outros como provedores; ele traz um Qdrant embutido em modo local para prototipagem. Zep gerencia o próprio armazenamento no plano cloud e usa Neo4j/FalkorDB quando self-hosted.

Memória de agente substitui um pipeline RAG?

Não. RAG recupera informação de documentos estáticos (manuais, código, artigos), enquanto memória armazena o que emergiu das conversas com cada usuário. Agentes maduros usam os dois em paralelo e passam ambos por um reranker antes de montar o prompt final.

Como controlo o custo de LLM ao adicionar memória a um agente?

Use um modelo pequeno (gpt-5-mini, Claude Haiku 4.5) para o passo de extração de fatos, que roda a cada mensagem. Limite o número de memórias recuperadas por turno (5 a 10 costuma bastar) e monitore com uma ferramenta de observabilidade para detectar consultas que retornam ruído em vez de sinal.