Cos'è
Letta è un framework open-source per costruire agenti artificiali stateful, cioè capaci di ricordare, apprendere e adattarsi nel tempo. Nato nel 2023 come progetto di ricerca MemGPT al Berkeley Artificial Intelligence Research (BAIR) Lab e nello Sky Computing Lab di UC Berkeley, è stato rilanciato con il nome Letta nel settembre 2024, insieme all'annuncio dell'omonima società commerciale. Il nucleo del progetto rimane disponibile su GitHub con licenza Apache 2.0.
L'ambizione di Letta è fornire l'infrastruttura di memoria che i modelli di linguaggio non hanno nativamente: trasformare i LLM — per costruzione stateless — in agenti che mantengono identità, preferenze, fatti e cronologie attraverso conversazioni e sessioni diverse. A differenza di una semplice libreria di orchestrazione, Letta progetta la memoria come primitive architetturale centrale, non come accessorio aggiunto a un chatbot esistente.
Il progetto offre più interfacce: un server RESTful auto-ospitabile (letta/letta su Docker), SDK ufficiali per Python e TypeScript, una CLI chiamata Letta Code per eseguire agenti localmente nel terminale, e l'Agent Development Environment (ADE), un'interfaccia visiva per costruire e monitorare gli agenti.
Il problema che risolve
I modelli di linguaggio elaborano ogni richiesta a partire dal contesto fornito in quel momento. Quando la conversazione termina, il modello non conserva nulla: ogni nuova sessione riparte da zero. Questo limite rende difficile costruire applicazioni che richiedono relazioni durature con l'utente — assistenti personali, agenti di supporto, companion terapeutici, strumenti di coding a lungo termine — perché obbligano gli sviluppatori a reinventare a ogni turno meccanismi di memoria, contesto e personalizzazione.
Inoltre, anche all'interno di una singola conversazione, la context window ha dimensioni finite. Caricare interi storici o documenti esterni in ogni richiesta aumenta i costi, introduce rumore e degrada le prestazioni. La retrieval-augmented generation (RAG) mitiga il problema recuperando documenti rilevanti, ma resta un approccio esterno al modello: l'agente non "possiede" la memoria, non la aggiorna autonomamente e non la struttura in forma di conoscenza appresa. Letta si propone come soluzione a questo vuoto, fornendo un sistema di memoria gerarchica che l'agente stesso legge, scrive e modifica.
Come funziona
Letta implementa un'architettura di memoria ispirata alla gerarchia di un sistema operativo, ereditata dal paper MemGPT. La memoria è organizzata in livelli:
- Core memory: memoria a breve termine contenuta nel contesto attivo del modello, strutturata in memory blocks (blocchi etichettati come
human,persona,task, ecc.). È il punto di lavoro immediato dell'agente. - Archival memory: memoria a lungo termine vettoriale, in cui l'agente memorizza fatti, preferenze ed esperienze passate, recuperabili tramite similarity search.
- Recall memory: storico delle conversazioni e delle interazioni, utilizzato per riportare in core memory informazioni rilevanti quando necessario.
L'agente opera attraverso un ciclo in cui il modello può invocare strumenti interni per leggere, scrivere, modificare o consolidare blocchi di memoria. Questo meccanismo è definito self-editing memory: è il modello stesso a decidere cosa ricordare, cosa dimenticare e come riorganizzare la propria conoscenza. Il runtime di Letta gestisce il passaggio dei dati tra i livelli di memoria, la persistenza su database (tipicamente PostgreSQL con pgvector) e l'esecuzione dei tool.
Il sistema è model-agnostic: supporta modelli closed-source (OpenAI, Anthropic, Google Gemini, Azure OpenAI, AWS Bedrock, Groq, Together, xAI) e modelli locali (Ollama, LM Studio, vLLM). Gli sviluppatori interagiscono con l'agente via API REST o SDK, definendo blocchi di memoria iniziali, tool disponibili e regole di comportamento.
Caratteristiche principali
- Memory blocks: astrazione fondamentale per strutturare il contesto in unità discrete, leggibili e modificabili dall'agente.
- Tiered memory: gerarchia core/archival/recall che separa memoria attiva, a lungo termine e storica.
- Tool calling: possibilità di collegare tool predefiniti o personalizzati, inclusi integrazioni con ecosistemi come LangChain, CrewAI e Composio.
- Multi-agent e multi-utente: supporto nativo per sistemi in cui più agenti collaborano o condividono memoria tra più conversazioni parallele.
- Agent Development Environment (ADE): interfaccia grafica per prototipare, ispezionare e debuggare lo stato di un agente.
- Letta Code: agente di coding memory-first che gira in locale nel terminale, con supporto a skill, subagenti e memoria versionata su git.
- Agent File (.af): formato aperto per serializzare, condividere e versionare un agente stateful in un unico file.
- Sleep-time compute: ricerca sull'uso del tempo di inattività dell'agente per consolidare memorie e apprendere in background.
- Letta Evals / Context-Bench: strumenti e benchmark open-source per valutare agenti che apprendono nel tempo.
Casi d'uso concreti
- Assistenti personali longevi: agenti che ricordano preferenze, abitudini e obiettivi dell'utente attraverso mesi di interazione, migliorando progressivamente la qualità delle risposte.
- Supporto clienti avanzato: sistemi che mantengono il profilo del cliente, la cronologia dei problemi e le soluzioni già tentate, evitando di ripetere domande inutili.
- Agenti di coding: Letta Code può seguire progetti complessi nel tempo, memorizzare convenzioni del codebase e adattare il proprio comportamento in base all'esperienza passata.
- Healthcare e benessere: applicazioni che tracciano sintomi, trattamenti e obiettivi terapeutici nel tempo, con memoria persistente e trasparente.
- Ricerca e knowledge work: agenti che raccolgono note, relazioni tra entità e timeline di eventi, fornendo un archivio personale consultabile e auto-aggiornante.
Punti di forza e limiti
Punti di forza. Letta nasce da una solida base accademica (MemGPT è uno dei paper più citati nel campo della memoria per LLM) e offre un'architettura concettualmente coerente. La trasparenza della memoria — leggibile come testo, ispezionabile e modificabile dallo sviluppatore — è un vantaggio rispetto alle scatole nere. La natura model-agnostic e open-source riduce il vendor lock-in e consente l'auto-hosting. Gli SDK, la CLI e l'ADE offrono una superficie di sviluppo ampia.
Limiti. La gestione gerarchica della memoria introduce complessità architetturale, latenza e costi aggiuntivi dovuti alle chiamate interne di lettura/scrittura. Non tutti i modelli gestiscono altrettanto bene il self-editing memory: la qualità può variare significativamente tra modelli frontier e modelli locali più piccoli. La curva di apprendimento è più ripida rispetto a soluzioni "plug-and-play" come un semplice layer di memoria. Inoltre, la transizione da progetto di ricerca a piattaforma commerciale espande il campo di competizione e richiede attenzione alla stabilità delle API nel tempo.
Alternative e contesto
Letta si colloca in un ecosistema affollato di strumenti per la memoria e l'orchestrazione degli agenti. Le principali alternative includono:
- Mem0: memory layer standalone pensato per essere integrato in agenti esistenti, con architettura ibrida vector/graph/key-value.
- LangGraph + LangMem: stack nativo per chi usa LangChain, con gestione dello stato tramite checkpoint e tool di memoria per LangGraph.
- Zep / Graphiti: memory store a lungo termine con enfasi su knowledge graph temporali.
- CrewAI: framework orientato al multi-agent e al lavoro di squadra, con memoria più basilare.
- RAG tradizionale: rimane valido per recuperare documenti esterni, ma non offre apprendimento autonomo dell'agente.
La scelta dipende dal livello di integrazione desiderato: Letta è più adatto a chi vuole costruire agenti memory-centric fin dalle fondamenta, mentre Mem0 o LangMem sono più immediati per aggiungere memoria a un'applicazione già esistente.
In sintesi
Letta è un framework open-source di livello produzione per costruire agenti AI con memoria persistente e trasparente. Nato dalla ricerca MemGPT di UC Berkeley e rilanciato come azienda nel 2024, unisce una solida base teorica a strumenti concreti: server REST, SDK Python/TypeScript, CLI Letta Code e l'interfaccia ADE. La sua architettura a blocchi di memoria e livelli gerarchici permette agli agenti di ricordare, adattarsi e migliorare nel tempo, superando il paradigma stateless dei LLM. Non è la soluzione più semplice per ogni progetto, ma rappresenta una scelta robusta per chi vuole costruire agenti a lungo termine, interpretabili e indipendenti dal provider di modello.
Risorse
- Repository GitHub ufficiale: https://github.com/letta-ai/letta
- Documentazione: https://docs.letta.com
- Sito aziendale: https://letta.com
- Paper di ricerca MemGPT: https://memgpt.ai
- SDK Python: https://github.com/letta-ai/letta-python
- SDK TypeScript/Node: https://github.com/letta-ai/letta-node
- Letta Code: https://github.com/letta-ai/letta-code