Tutorial Mem0: livello di memoria persistente per applicazioni AI

Dici al tuo chatbot che sei vegetariano. Il giorno dopo ti propone una ricetta di bistecca. Non è un bug: è proprio così che funzionano gli LLM. Non hanno memoria tra una sessione e l'altra e trattano ogni conversazione come una pagina bianca.

Per un uso occasionale va bene. Ma se stai creando applicazioni reali con utenti reali, questa assenza di stato diventa un vero problema. Gli utenti si aspettano che l'AI si ricordi di loro.

Mem0 risolve il problema aggiungendo uno strato di memoria a qualsiasi LLM. Archivia, recupera e aggiorna le informazioni sugli utenti tra le sessioni, così la tua AI può davvero imparare e adattarsi nel tempo.

In questo tutorial creerai un assistente AI personale che ricorda le preferenze degli utenti, tiene traccia della cronologia delle conversazioni e diventa più intelligente a ogni interazione. Copriremo sia il setup cloud sia quello self-hosted, così potrai scegliere ciò che meglio si adatta al tuo progetto.

Se non lo hai mai usato, segui questo corso per imparare a lavorare con le API di OpenAI.

Che cos'è Mem0?

Mem0 è uno strato di memoria open-source che si inserisce tra la tua applicazione e l'LLM. Estrae automaticamente le informazioni rilevanti dalle conversazioni, le archivia e le recupera quando servono. Il progetto ha raccolto 24 milioni di dollari nell’ottobre 2025 e funziona con qualsiasi provider di LLM: OpenAI, Anthropic, Ollama o i tuoi modelli.

Mem0 organizza le memorie in tre ambiti:

• Memoria utente: persiste in tutte le conversazioni con una persona specifica. Se qualcuno dice che preferisce studiare al mattino, quel fatto rimane disponibile in ogni sessione futura. 

• Memoria di sessione: tiene traccia del contesto all'interno di una singola conversazione, ad esempio la ricetta di cui si sta parlando. 

• Memoria dell’agente: archivia informazioni specifiche per una particolare istanza di agente AI. 

Puoi combinare questi ambiti per creare applicazioni complesse in cui diversi agenti condividono (o isolano) ciò che sanno sugli utenti.

I tre ambiti di memoria: utente, sessione e agente, con esempi.

Sotto il cofano, Mem0 combina la ricerca vettoriale con le relazioni a grafo. Quando aggiungi una conversazione alla memoria, estrae automaticamente i punti salienti. Non devi taggare manualmente cosa ricordare. 

Quando la tua app ha bisogno di contesto, Mem0 recupera le memorie rilevanti in base alla query corrente e le inserisce nel prompt. Questo è meglio dell’alternativa di inserire l’intera cronologia della conversazione in ogni richiesta.

Puoi eseguire Mem0 in due modi:

• Piattaforma: il servizio gestito in cloud su app.mem0.ai offre un setup rapido e un’API.

• Self-hosted: ti dà il pieno controllo dell’infrastruttura, permettendoti di scegliere il database vettoriale e il modello di embedding. 

Entrambe le opzioni usano lo stesso SDK Python, quindi passare dall’una all’altra è semplice.

I guadagni prestazionali sono reali, come rivela l’articolo scientifico di Mem0. Sul benchmark LOCOMO, Mem0 ha ottenuto un punteggio superiore del 26% rispetto alla funzione di memoria integrata di OpenAI. Risponde anche il 91% più rapidamente grazie al recupero selettivo delle memorie rilevanti invece di processare l’intera cronologia. L’uso di token si riduce di circa il 90% rispetto agli approcci a pieno contesto.

Ora che sai cosa fa Mem0, configuriamolo.

Primi passi con Mem0

Installa il pacchetto insieme a python-dotenv per la gestione delle chiavi API:

pip install mem0ai python-dotenvOfferto da

Iscriviti su app.mem0.ai e recupera la tua chiave API dalla dashboard. Crea un file .env nella directory del progetto:

MEM0_API_KEY=your-api-key-hereOfferto da

Ora inizializza il client usando la chiave API:

from mem0 import MemoryClient
from dotenv import load_dotenv
import os

load_dotenv()

client = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))Offerto da

Per archiviare una memoria, passa una conversazione nel formato chat di OpenAI. Il parametro user_id delimita le memorie a un utente specifico:

messages = [
	{"role": "user", "content": "I'm a vegetarian and allergic to nuts."},
	{"role": "assistant", "content": "Got it! I'll remember that."}
]
client.add(messages, user_id="user123")Offerto da

L’elaborazione della memoria avviene in background. Il metodo add() restituisce subito uno stato "in attesa" mentre Mem0 estrae e archivia i fatti rilevanti.

Per recuperare le memorie, usa search() con una query in linguaggio naturale:

results = client.search("dietary restrictions", filters={"user_id": "user123"})Offerto da

La risposta contiene le memorie estratte con punteggi di rilevanza:

{'results': [
	{'memory': 'User is allergic to nuts', 'user_id': 'user123', 'score': 0.66},
	{'memory': 'User is a vegetarian', 'user_id': 'user123', 'score': 0.65}
]}Offerto da

Nota che Mem0 ha diviso automaticamente "vegetariano" e "allergico alla frutta a guscio" in due fatti separati. Il sistema gestisce l’estrazione e, quando cerchi, restituisce le memorie più rilevanti in base alla similarità semantica.

Visti i fondamentali, costruiamo qualcosa di più pratico.

Creare un agente AI con Mem0

Il flusso base add/search è utile, ma le applicazioni reali richiedono più sofisticazione. Costruiamo un agente compagno di apprendimento che decida autonomamente quando archiviare, recuperare e aggiornare le memorie. Useremo l’OpenAI Agents SDK per dare al nostro agente strumenti di memoria che può chiamare da solo.

Se sei alle prime armi con gli agenti basati su LLM, dai un’occhiata al nostro tutorial su come costruire agenti LangChain per i concetti di base. Per approfondire specificamente l’OpenAI Agents SDK, vedi il tutorial sull’OpenAI Agents SDK.

Impostazione delle dipendenze

Installa l’OpenAI Agents SDK insieme a Mem0:

pip install openai-agents mem0ai python-dotenvOfferto da

Aggiungi la tua chiave API di OpenAI al file .env:

MEM0_API_KEY=your-mem0-key
OPENAI_API_KEY=your-openai-keyOfferto da

Ora inizializza entrambi i client e crea una classe di contesto per passare le informazioni utente agli strumenti:

import os
from dataclasses import dataclass
from agents import Agent, Runner, function_tool, RunContextWrapper
from mem0 import MemoryClient
from dotenv import load_dotenv

load_dotenv()

mem0 = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))

@dataclass
class UserContext:
	user_id: strOfferto da

La dataclass UserContext contiene i dati specifici dell’utente richiesti dagli strumenti. RunContextWrapper ci permette di passare questo contesto a qualsiasi strumento chiamato dall’agente.

Creazione degli strumenti di memoria

L’agente ha bisogno di tre strumenti: search, save e update. Usiamo il decorator @function_tool per esporli all’agente.

Per prima cosa, lo strumento di ricerca recupera le memorie rilevanti. Includiamo gli ID delle memorie nell’output così l’agente può riferirsi ad essi per gli aggiornamenti:

@function_tool
def search_memory(ctx: RunContextWrapper[UserContext], query: str) -> str:
	"""Search through past learning history and memories."""
	memories = mem0.search(
    	query,
    	filters={"user_id": ctx.context.user_id},
    	limit=5
	)
	if memories and memories.get("results"):
    	return "\n".join([
         	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
 	return "No relevant memories found."Offerto da

Poi, lo strumento di salvataggio archivia nuove informazioni:

@function_tool
def save_memory(ctx: RunContextWrapper[UserContext], content: str) -> str:
 	"""Save new information about the user's learning journey."""
 	mem0.add(
     	[{"role": "user", "content": content}],
     	user_id=ctx.context.user_id
 	)
 	return "Memory saved successfully."Offerto da

Infine, lo strumento di aggiornamento modifica memorie esistenti quando le informazioni cambiano:

@function_tool
def update_memory(ctx: RunContextWrapper[UserContext], memory_id: str, new_text: str) -> str:
 	"""Update an existing memory with new information."""
 	mem0.update(memory_id=memory_id, text=new_text)
 	return f"Memory {memory_id} updated."Offerto da

Definizione dell’agente

Ora creiamo l’agente con le istruzioni su quando usare ciascuno strumento:

agent = Agent(
 	name="Learning Companion",
 	instructions="""You are a helpful learning companion with memory. 
            Use search_memory to recall what the user is learning and their level.
            Search results include memory IDs in format [ID: xxx].
            Use save_memory to store new topics, preferences, or progress.
            Use update_memory when information changes. First search to find the memory ID, then call update_memory with that ID and the new text.
            Always check memory before responding to personalize your answers.""",
 	tools=[search_memory, save_memory, update_memory],
 	model="gpt-4o"
)Offerto da

Qui usiamo gpt-4o, ma per un ragionamento migliore nell’uso degli strumenti consiglio di usare GPT-5. Dai un’occhiata al nostro tutorial sull’API di GPT-5 per vedere in azione le nuove funzionalità.

Esecuzione dell’agente

La funzione chat passa il contesto utente all’agente:

def chat(user_input: str, user_id: str) -> str:
	result = Runner.run_sync(
     	agent,
     	user_input,
         context=UserContext(user_id=user_id)
	)
	return result.final_outputOfferto da

Ogni chiamata a Runner.run_sync() è completamente indipendente dalle altre. L’OpenAI Agents SDK non mantiene la cronologia della conversazione tra le chiamate per impostazione predefinita. 

Per il nostro demo è intenzionale: quando l’agente ricorda informazioni dell’utente tra le chiamate, quella memoria deve provenire da Mem0, non da uno stato nascosto dell’agente.

Testare la persistenza della memoria

Testiamo con query che richiedono un vero recupero di memoria. L’agente non può indovinare correttamente le risposte senza accedere alle informazioni salvate.

Per prima cosa, salva alcune informazioni sull’utente:

response = chat(
	"My name is Alex. I am learning data visualization with matplotlib. "
	"I am at intermediate level.",
	"student_01"
)
print(response)Offerto da

Got it, Alex! You're learning data visualization with Matplotlib at an intermediate level. How can I assist you today?Offerto da

Dopo aver atteso qualche secondo per l’elaborazione asincrona, testa il richiamo:

response = chat("What is my name and what library am I learning?", "student_01")
print(response)Offerto da

Your name is Alex, and you're learning data visualization using Matplotlib at an intermediate level.Offerto da

Ora testa la funzionalità di aggiornamento:

response = chat(
	"I switched from matplotlib to seaborn. Please update your memory.",
	"student_01"
)
print(response)Offerto da

Got it! I've updated your learning preference to Seaborn for data visualization at an intermediate level. If you need help with anything specific, just let me know!Offerto da

Verifica che l’aggiornamento sia avvenuto:

response = chat("What visualization library am I using now?", "student_01")
print(response)Offerto da

You are currently using Seaborn for data visualization at an intermediate level.Offerto da

Infine, testa la persistenza tra conversazioni diverse:

response = chat("Give me a summary of everything you know about me.", "student_01")
print(response)Offerto da

Here's what I know about you:

- Your name is Alex.
- You are learning data visualization with Seaborn at an intermediate level.

Is there anything else you'd like to update or add?Offerto da

Come funziona il nostro agente Mem0

L’agente sceglie quale strumento chiamare in base alla conversazione. 

Quando l’utente chiede del proprio profilo, chiama search_memory. Quando condivide nuove informazioni, chiama save_memory. Quando dice che le informazioni sono cambiate, prima cerca per ottenere l’ID della memoria, poi chiama update_memory. 

Non gli diciamo mai esplicitamente quale strumento usare per ciascun messaggio.

Questo differisce dal flusso manuale add/search della Sezione 3. Lì chiamavamo esplicitamente i metodi. Qui l’agente prende quelle decisioni. Questo schema scala meglio per applicazioni complesse in cui non puoi prevedere ogni tipo di interazione.

Confronto tra flussi manuali e guidati dall’agente per la scalabilità

Una nota importante: l’elaborazione della memoria è asincrona. Dopo la chiamata a save_memory, c’è un breve ritardo prima che la nuova memoria diventi ricercabile. In produzione, tienilo presente nell’interfaccia utente.

Ottimizzare il comportamento di Mem0

L’agente base gestisce le operazioni di memoria, ma le applicazioni in produzione richiedono un controllo più fine su cosa viene archiviato e come viene recuperato. Mem0 offre impostazioni a livello di progetto che migliorano la qualità della memoria, tra cui categorie personalizzate per l’organizzazione, istruzioni definite dall’utente per il filtraggio, ricerche mirate e operazioni di pulizia.

Categorie personalizzate per domini di apprendimento

Per impostazione predefinita, Mem0 usa categorie generiche come cibo, viaggi e hobby. Per applicazioni specifiche come il nostro compagno di apprendimento, non aiutano molto. Puoi definire le tue categorie che corrispondano al tuo dominio:

client.project.update(custom_categories=[
	{"name": "topics", "description": "Programming languages, frameworks, or subjects"},
	{"name": "skill_levels", "description": "Proficiency: beginner, intermediate, advanced"},
	{"name": "goals", "description": "Learning objectives and targets"},
	{"name": "progress", "description": "Completed courses, chapters, or milestones"},
	{"name": "preferences", "description": "Learning style, schedule, or format preferences"}
])Offerto da

Una volta impostate, il classificatore di Mem0 tagga automaticamente le memorie in arrivo con le tue categorie. Quando Alex dice: "Sto imparando Python a livello principiante", il sistema lo tagga con topics e skill_levels. Non devi cambiare il codice del tuo agente. La categorizzazione avviene durante l’estrazione della memoria.

Istruzioni personalizzate per una memoria selettiva

Le istruzioni personalizzate ti consentono di controllare esattamente cosa estrarre dalle conversazioni. Scrivi linee guida in linguaggio naturale e Mem0 le segue quando elabora nuove memorie:

client.project.update(custom_instructions="""
Extract and remember:
- Programming topics and technologies mentioned
- Current skill level for each topic
- Learning goals and deadlines
- Progress updates and completions
- Preferred learning resources (videos, docs, exercises)

Do not store:
- Personal identifiers beyond the user_id
- Payment or financial information
- Off-topic conversation that isn't about learning
""")Offerto da

Questo è importante in produzione. Senza istruzioni, Mem0 potrebbe archiviare dettagli irrilevanti o informazioni sensibili. Le istruzioni personalizzate agiscono da filtro, mantenendo le memorie focalizzate su ciò che serve davvero alla tua applicazione. Per scenari di conformità come il GDPR, puoi escludere esplicitamente categorie di dati personali.

Ricerche filtrate per categoria

Con memorie categorizzate, il tuo strumento di ricerca può essere più preciso. Invece di cercare in tutte le memorie, filtra per categoria per ottenere esattamente ciò che ti serve:

@function_tool
def search_memory(
	ctx: RunContextWrapper[UserContext],
	query: str,
	category: str = None
) -> str:
	"""Search learning history. Optionally filter by category."""
	filters = {"user_id": ctx.context.user_id}
	if category:
    	filters["categories"] = {"contains": category}

	memories = mem0.search(query, filters=filters, limit=5)
	if memories and memories.get("results"):
    	return "\n".join([
        	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
	return "No relevant memories found."Offerto da

Quando l’agente deve rispondere a "Quali argomenti ho imparato?", può cercare con category="topics" e saltare memorie non pertinenti su preferenze o obiettivi. Le istruzioni dell’agente dovrebbero menzionare queste categorie, così sa quando usare ricerche filtrate.

Pulizia e cancellazione delle memorie

Gli utenti potrebbero voler rimuovere memorie obsolete o errate. Aggiungi uno strumento di cancellazione per dare questa possibilità all’agente:

@function_tool
def delete_memory(ctx: RunContextWrapper[UserContext], memory_id: str) -> str:
	"""Delete a specific memory by ID."""
	mem0.delete(memory_id=memory_id)
	return f"Memory {memory_id} deleted."Offerto da

Per operazioni in blocco, puoi cancellare tutte le memorie di un utente direttamente:

mem0.delete_all(user_id="student_01")Offerto da

La cancellazione è utile quando le informazioni cambiano completamente anziché essere aggiornate. Se un utente dice: "dimentica tutto sul mio apprendimento di Python", l’agente può cercare le memorie rilevanti e cancellarle una per una, oppure puoi offrire un’opzione di reset che azzeri completamente il profilo.

Queste quattro opzioni di configurazione portano l’agente da un demo a qualcosa che puoi distribuire. Le categorie organizzano automaticamente le memorie, le istruzioni assicurano che venga archiviato solo ciò che è rilevante, le ricerche filtrate recuperano con precisione ciò che serve e la cancellazione gestisce la pulizia. Le modifiche al codice dell’agente sono minime, perché la maggior parte avviene a livello di configurazione del progetto.

Per maggiori dettagli su queste funzionalità, vedi la documentazione ufficiale di Mem0.

Tracciare le relazioni con la memoria a grafo

La memoria standard archivia fatti isolati, come "Alex sta imparando Seaborn" e "Alex conosce matplotlib". Ma non cattura che Alex ha imparato prima matplotlib e poi è passato a Seaborn. La memoria a grafo aggiunge questo livello di relazioni. Quando contano l’ordine, la progressione o le connessioni tra entità, la memoria a grafo dà al tuo agente un contesto più ricco.

Nota: la memoria a grafo è disponibile solo con un piano Pro (249 $/mese) o superiore.

Attivare la memoria a grafo

Puoi attivare la memoria a grafo a livello di progetto:

client.project.update(enable_graph=True)Offerto da

Un’altra opzione è passare enable_graph=True nelle singole richieste:

client.add(messages, user_id="student_01", enable_graph=True)Offerto da

Una volta attiva, Mem0 estrae automaticamente entità (persone, argomenti, strumenti, date) e le relazioni tra di esse dal linguaggio naturale.

Come funziona la ricerca su grafo

Quando cerchi con la memoria a grafo, Mem0 restituisce sia le memorie sia un array relations che mostra come sono connesse le entità:

results = client.search(
	"What has Alex learned?",
	filters={"user_id": "student_01"},
	enable_graph=True
)

# Results include both memories and relations
print(results.get("relations"))Offerto da

Le relazioni mostrano connessioni come "Alex → ha imparato → matplotlib" e "Alex → è passato a → seaborn". Ora il tuo agente può rispondere a domande sulla progressione senza che tu debba memorizzare esplicitamente quelle relazioni.

Quando usare la memoria a grafo

La memoria a grafo aggiunge overhead di elaborazione, quindi usala quando le relazioni contano:

• Piattaforme di apprendimento che tracciano la progressione delle competenze

• Supporto clienti che analizza la cronologia delle interazioni

• Project management che mappa le dipendenze tra task

• Sanità, collegando sintomi e trattamenti nel tempo

Per il semplice richiamo di fatti, la memoria standard è più veloce. Attiva la memoria a grafo quando l’agente deve ragionare su sequenze o connessioni tra informazioni archiviate.

Mem0: Piattaforma vs Open source

Mem0 è disponibile in due versioni: Piattaforma e open source. 

In tutto il tutorial abbiamo usato la versione Piattaforma, cioè il servizio cloud gestito a cui si accede tramite MemoryClient e una chiave API da app.mem0.ai. Entrambe le versioni condividono le operazioni principali di memoria (add(), search(), update(), delete()), ma differiscono per setup, prezzi e controllo.

Piattaforma

La Piattaforma è il servizio ospitato di Mem0. Ti iscrivi, ottieni una chiave API e inizi ad aggiungere memorie in pochi minuti. Mem0 gestisce infrastruttura, scalabilità e certificazioni di sicurezza (come SOC 2 Type II o GDPR).

Ci sono quattro livelli di prezzo:

• Free: 10.000 memorie, adatto al prototyping.

• Starter: 19 $/mese, con limiti più alti.

• Pro: 249 $/mese, per carichi di lavoro in produzione.

• Enterprise: Prezzi personalizzati con supporto dedicato.

La Piattaforma include funzionalità non disponibili nell’open source: memoria a grafo per il tracciamento delle relazioni, webhook per notifiche in tempo reale, chat di gruppo con attribuzione degli speaker e analytics integrate. 

Paghi in base all’uso ma risparmi su infrastruttura e tempo DevOps.

Open source

La versione open source gira sui tuoi server. Installi il pacchetto mem0ai, configuri il tuo database vettoriale e gestisci tu stesso il deployment. Richiede più setup ma ti dà il pieno controllo.

Sono disponibili diverse opzioni per l’infrastruttura:

• Database vettoriali: oltre 24 opzioni tra cui Qdrant, Chroma, Pinecone, PostgreSQL (pgvector) e MongoDB

• Provider LLM: oltre 16 opzioni tra cui OpenAI, Anthropic, Ollama, Groq e modelli locali

• Modelli di embedding: OpenAI, HuggingFace o embedder personalizzati

L’open source usa la classe Memory invece di MemoryClient. 

I costi dipendono da ciò che paghi per l’infrastruttura (VM cloud, hosting del database, chiamate API ai provider LLM). Su larga scala può essere più economico della Piattaforma, ma sei responsabile di manutenzione, backup e conformità.

Quando scegliere Piattaforma vs open source

Consulta la seguente tabella per un confronto tra la versione hosted e quella open source di Mem0:

Il mio consiglio è scegliere la Piattaforma per prototipi rapidi, app in produzione senza oneri DevOps o quando ti servono conformità integrate. 

Se il tuo focus è la sovranità dei dati, configurazioni di modelli personalizzate o ottimizzazione dei costi ad alto volume, l’open source è la scelta giusta.

Per guide di setup dettagliate, consulta la quickstart della Piattaforma o la panoramica open source.

Conclusione

Questo tutorial ha illustrato come aggiungere memoria persistente alle applicazioni LLM con Mem0. Sei partito dalle operazioni di memoria di base, poi hai creato un agente compagno di apprendimento che gestisce autonomamente la propria memoria usando l’OpenAI Agents SDK. Da lì, hai configurato il comportamento della memoria con categorie personalizzate, istruzioni e ricerche filtrate. Infine, hai confrontato le opzioni di deployment Piattaforma e open source.

Per l’uso in produzione, aggiungi gestione degli errori attorno alle operazioni di memoria e considera i brevi ritardi dopo il salvataggio di nuove memorie. Tieni conto dei rate limit se sei sul tier gratuito della Piattaforma.

Pronto ad andare oltre i singoli componenti e padroneggiare l’intero stack dello sviluppo di applicazioni AI? Iscriviti al percorso di carriera AI Engineer for Developers track.