Ho creato un’AI che ricorda: Il mio viaggio verso la memoria persistente

Ciao a tutti, futuri gestori di agenti! Emma qui, di nuovo su agent101.net, e oggi ci immergiamo a capofitto in qualcosa che mi ha frullato nella testa per settimane: far sì che il tuo agente AI possa realmente ricordare le cose. Non solo per un’interazione singola, ma attraverso le sessioni, anche quando spegni il tuo script e ci torni più tardi. È la differenza tra un chatbot intelligente e un vero assistente digitale, giusto?

Per un po’ ho solo giocato con script semplici e unici. I miei piccoli agenti Python facevano il loro lavoro – recuperare dei dati, riassumere un articolo – e poi puff! Tutta la loro “conoscenza” sulle nostre chat o compiti precedenti era sparita. Sembrava di parlare con qualcuno affetto da grave perdita di memoria a breve termine, il che, sebbene talvolta divertente, non è esattamente produttivo per costruire qualcosa di utile.

Ricordo di aver provato a costruire un assistente per la ricerca personale. Il mio obiettivo era semplice: fornirgli articoli, fargli domande e fargli costruire una base di conoscenze su un argomento specifico. I primi tentativi furono… frustranti. Gli chiedevo delle “ultime tendenze nel computing quantistico,” e lui mi dava un ottimo riassunto. Poi, cinque minuti dopo, chiedevo “e le implicazioni etiche?” e si comportava come se non avessimo mai discusso del computing quantistico. Fondamentalmente lo stavo ri-educando ogni singola volta. Parliamo di inefficienza!

È allora che ho realizzato: affinché un agente AI possa davvero essere un agente, ha bisogno di una memoria. Non solo un taccuino temporaneo, ma un modo persistente per memorizzare e recuperare informazioni. E per noi principianti, il mondo dei database e dei complessi sistemi di generazione aumentata da recupero (RAG) può sembrare un po’ opprimente. Ma indovina un po’? Non deve esserlo. Possiamo iniziare in modo semplice, e questo è esattamente ciò che faremo oggi.

Perché la Memoria Persistente è Importante per il Tuo Agente AI

Pensaci in questo modo: assumeresti un assistente umano che dimentica tutto ciò che gli hai detto nel momento in cui varca la porta? Probabilmente no. Il valore di un assistente, umano o AI, spesso deriva dalla sua capacità di accumulare conoscenze su di te, le tue preferenze, i tuoi progetti e le tue interazioni passate. Questa conoscenza accumulata consente loro di:

• Fornire risposte contestualmente rilevanti: Niente più spiegare la stessa cosa più volte.
• Completare compiti a più fasi: Possono ricordare i passaggi precedenti e costruire su di essi.
• Imparare e adattarsi nel tempo: La loro “comprensione” delle tue esigenze cresce.
• Offrire un’esperienza personalizzata: Ricordano le tue preferenze, il nome del tuo animale domestico, il tuo caffè preferito – ok, forse non il caffè ancora, ma hai capito l’idea!

Per noi che stiamo iniziando, la memoria persistente è il ponte tra uno script interessante e un vero compagno AI utile. È la differenza tra uno strumento usa e getta e qualcosa che sembra realmente *lavorare* *con* te.

Il Percorso Amichevole per Principianti: File di Testo e JSON

Ok, quindi “memoria persistente” suona sofisticato, ma per il nostro primo approccio, non dobbiamo alzare un server PostgreSQL o lottare con database vettoriali (ancora!). Possiamo partire con qualcosa di meravigliosamente semplice e sorprendentemente efficace: buoni vecchi file di testo, specificamente file JSON.

Perché JSON? Perché è strutturato! Ci consente di memorizzare i dati in un formato chiave-valore, che è perfetto per organizzare le informazioni che il nostro agente deve ricordare. È anche leggibile dall’uomo, il che è un grande vantaggio quando stai facendo debugging o semplicemente cercando di capire cosa ha memorizzato il tuo agente.

Immagina che il tuo agente abbia un file “cervello”. Ogni volta che apprende qualcosa di importante, lo annota in questo file. Ogni volta che deve ricordare qualcosa, legge da questo file. Semplice, giusto?

Esempio 1: Ricordare le Preferenze dell’Utente

Diciamo che stai costruendo un semplice agente per riassumere contenuti. Vuoi che ricordi la lunghezza di riassunto preferita dall’utente (corta, media, lunga) e i loro argomenti preferiti. Senza memoria persistente, dovresti chiederglielo ogni singola volta. Con un file JSON, chiedi una volta, e il tuo agente ricorda.

Per prima cosa, pensiamo alla struttura. Un semplice file JSON potrebbe avere questo aspetto:

{
 "user_preferences": {
 "summary_length": "media",
 "favorite_topics": ["etica AI", "biotecnologia", "esplorazione spaziale"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": []
}

Ora, come facciamo a far interagire il nostro agente Python con questo?

Avremo bisogno di funzioni per caricare la memoria e salvare la memoria. Ecco una configurazione di base:

import json
import os
from datetime import datetime

MEMORY_FILE = "agent_memory.json"

def load_memory():
 if os.path.exists(MEMORY_FILE):
 with open(MEMORY_FILE, 'r') as f:
 return json.load(f)
 return {
 "user_preferences": {
 "summary_length": "media",
 "favorite_topics": [],
 "last_seen": None
 },
 "conversation_history": []
 }

def save_memory(memory):
 with open(MEMORY_FILE, 'w') as f:
 json.dump(memory, f, indent=4)

def update_user_preference(key, value):
 memory = load_memory()
 memory["user_preferences"][key] = value
 memory["user_preferences"]["last_seen"] = datetime.now().isoformat()
 save_memory(memory)
 print(f"Preferenza aggiornata: {key} a {value}")

def get_user_preference(key):
 memory = load_memory()
 return memory["user_preferences"].get(key)

# --- Esempio di Interazione con l'Agente ---

if __name__ == "__main__":
 print("Bentornato al tuo agente!")

 # Carica la memoria esistente o inizializza nuova
 current_memory = load_memory()
 print(f"La tua lunghezza di riassunto preferita è: {get_user_preference('summary_length')}")
 print(f"I tuoi argomenti preferiti sono: {get_user_preference('favorite_topics')}")

 # Simula l'utente che imposta una preferenza
 user_input = input("Vuoi riassunti 'corti', 'medi' o 'lunghi'? (Scrivi per cambiare o premi Invio per mantenere): ").strip().lower()
 if user_input in ["corto", "medio", "lungo"]:
 update_user_preference("summary_length", user_input)
 print(f"Ok, ricorderò che preferisci riassunti {user_input}.")
 else:
 print("Mantenendo la preferenza attuale.")

 # Simula l'agente che utilizza la memoria
 preferred_length = get_user_preference("summary_length")
 print(f"Generazione di un riassunto {preferred_length} per il tuo prossimo compito...")

 # Aggiungiamo un nuovo argomento preferito
 new_topic = input("Ci sono nuovi argomenti preferiti da aggiungere? ").strip()
 if new_topic:
 topics = get_user_preference('favorite_topics')
 if new_topic not in topics:
 topics.append(new_topic)
 update_user_preference('favorite_topics', topics)
 print(f"Aggiunto '{new_topic}' ai tuoi argomenti preferiti.")
 else:
 print(f"'{new_topic}' è già nei tuoi preferiti.")

 print(f"\nDopo questa sessione, la tua memoria appare così:")
 print(json.dumps(load_memory(), indent=4))

Cosa sta succedendo qui?

• `load_memory()` controlla se `agent_memory.json` esiste. Se sì, lo legge. Se no, crea una struttura di base.
• `save_memory()` prende il nostro dizionario Python e lo scrive nel file JSON.
• `update_user_preference()` e `get_user_preference()` sono funzioni di aiuto per rendere più facile l’interazione con parti specifiche della memoria.
• La parte principale dello script (`if __name__ == “__main__”:`) simula un utente che interagisce con l’agente, impostando preferenze e poi l’agente che utilizza quelle preferenze.

Prova a eseguire questo script un paio di volte. Vedrai che le tue preferenze persistono anche dopo aver chiuso e riaperto lo script! Questa è la magia della memoria persistente, anche nella sua forma più semplice.

Esempio 2: Ricordare la Cronologia delle Conversazioni

Oltre alle preferenze, una parte cruciale della memoria di un agente è ricordare ciò che è appena stato detto. Questo è particolarmente importante per conversazioni o compiti a più turni. Mentre i LLM hanno una “finestra di contesto,” quel contesto di solito viene cancellato dopo ciascuna chiamata API o sessione. Vogliamo estenderlo.

Modifichiamo il nostro `agent_memory.json` per includere una lista `conversation_history`. Ogni voce in questa lista potrebbe essere un dizionario contenente il parlatore (utente/agente) e il messaggio.

Struttura aggiornata di `agent_memory.json`:

{
 "user_preferences": {
 "summary_length": "media",
 "favorite_topics": ["etica AI", "biotecnologia", "esplorazione spaziale"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": [
 {"role": "user", "message": "Ciao, come va?"},
 {"role": "agent", "message": "Niente di che, sto solo aspettando i tuoi comandi!"}
 ]
}

Ora, aggiungiamo funzioni per gestire questa cronologia:

import json
import os
from datetime import datetime

MEMORY_FILE = "agent_memory.json"

# (Includi le funzioni load_memory e save_memory dall'esempio precedente)

def load_memory():
 if os.path.exists(MEMORY_FILE):
 with open(MEMORY_FILE, 'r') as f:
 return json.load(f)
 return {
 "user_preferences": {
 "summary_length": "medio",
 "favorite_topics": [],
 "last_seen": None
 },
 "conversation_history": []
 }

def save_memory(memory):
 with open(MEMORY_FILE, 'w') as f:
 json.dump(memory, f, indent=4)

def add_to_history(role, message):
 memory = load_memory()
 memory["conversation_history"].append({"role": role, "message": message, "timestamp": datetime.now().isoformat()})
 # Opzionale: Mantieni la cronologia a una dimensione gestibile, ad esempio, le ultime 10 interazioni
 if len(memory["conversation_history"]) > 10:
 memory["conversation_history"] = memory["conversation_history"][-10:]
 save_memory(memory)

def get_conversation_history():
 memory = load_memory()
 return memory["conversation_history"]

# --- Esempio di Interazione con l'Agente con Cronologia ---

if __name__ == "__main__":
 print("Bentornato! Ecco la nostra chat recente:")
 for entry in get_conversation_history():
 print(f"{entry['role'].capitalize()}: {entry['message']}")

 while True:
 user_message = input("Tu: ")
 if user_message.lower() == "exit":
 break
 
 add_to_history("user", user_message)
 print(f"Agente: (Pensando a: '{user_message}' e alla cronologia precedente...)")
 
 # Simula la risposta dell'agente (in un agente reale, questo comporterebbe una chiamata LLM)
 agent_response = f"Capito, hai detto '{user_message}'. Ricorderò questo."
 add_to_history("agent", agent_response)
 print(f"Agente: {agent_response}")

 print("\nChat terminata. La tua cronologia delle conversazioni è stata salvata.")
 print(json.dumps(load_memory(), indent=4))

In questo esempio, ogni messaggio dell’utente e ogni risposta simulata dell’agente vengono aggiunti alla lista `conversation_history` nel nostro file JSON. Quando lo script inizia, carica questa cronologia, dando all’agente una sorta di “memoria” delle interazioni precedenti. Ho aggiunto una piccola riga per troncare la cronologia agli ultimi 10 elementi – questo è un modo semplice per evitare che il file di memoria cresca indefinitamente, il che può essere un problema con conversazioni molto lunghe.

Considerazioni e Prossimi Passi

Anche se i file JSON sono fantastici per iniziare, presentano delle limitazioni:

• Scalabilità: Per grandi quantità di dati, leggere e scrivere ripetutamente l’intero file può diventare lento.
• Concorrenza: Se più parti del tuo agente (o più agenti) cercano di scrivere nello stesso file contemporaneamente, potresti incorrere in problemi.
• Query Complesse: È difficile fare domande come “trova tutte le conversazioni in cui l’utente ha menzionato ‘calcolo quantistico’ E ‘implicazioni etiche’.” Dovresti caricare l’intero file e cercare manualmente.

Ma per un principiante, e per molti progetti personali, queste limitazioni sono perfettamente accettabili. Stai acquisendo il concetto fondamentale di memoria persistente senza la complessità aggiuntiva di un database.

Una volta che hai familiarità con i file JSON, ecco alcuni passi naturali da seguire:

1. SQLite: Questo è un database relazionale basato su file che è super facile da integrare con Python. Risolve i problemi di scalabilità e query dei file JSON senza richiedere un server separato. È spesso il prossimo passo logico per molti progetti.
2. Database Vettoriali (es. Chroma, FAISS): Qui le cose diventano veramente interessanti per gli agenti AI! I database vettoriali memorizzano le informazioni come embedding numerici, consentendo al tuo agente di eseguire ricerche semantiche (es. “trova informazioni correlate a questo concetto,” anche se le parole chiave esatte non sono presenti). Questa è la base di molti sistemi RAG avanzati.
3. Strutture di Memoria Più Sofisticate: Invece di semplici conversazioni, potresti provare punti chiave, estrarre entità o persino costruire un “grafo della conoscenza” nella tua memoria.

I Miei Consigli per Te

La memoria persistente non è solo una funzionalità avanzata; è un requisito fondamentale per costruire agenti AI che sembrano veramente utili e intelligenti. Iniziare con semplici file JSON è un modo incredibilmente pratico per comprendere il concetto centrale senza essere sopraffatti dalla complessità.

Ecco cosa voglio che tu ricordi oggi:

• Inizia in modo semplice: Non sentirti sotto pressione per utilizzare subito la tecnologia più avanzata. I file JSON sono i tuoi amici per la memoria persistente per principianti.
• La struttura è fondamentale: Anche in un file JSON, pensa a come vuoi organizzare la memoria del tuo agente (preferenze, storia, fatti appresi, ecc.).
• Esercitati a caricare e salvare: Il ciclo centrale di `load_memory()`, modifica `memory`, `save_memory()` è quello che utilizzerai costantemente.
• Itera e espandi: Una volta che ti senti a tuo agio con i JSON, sfida te stesso a passare a SQLite, poi forse esplora i database vettoriali. Ogni passo si costruisce sul precedente.

So che quando ho fatto sì che il mio agente semplice “ricordasse” la mia lunghezza di sintesi preferita tra le sessioni, è sembrato un piccolo progresso. Non stava solo eseguendo codice; stava iniziando a sembrare di avere un piccolissimo cervello digitale tutto suo. Provalo – rimarrai stupito da quanto siano più capaci i tuoi agenti!

Buona programmazione, e continuiamo a costruire agenti più intelligenti!

🕒 Published: April 4, 2026