Ho costruito un’IA che si ricorda: Il mio viaggio verso una memoria persistente

Ciao a tutti, futuri agenti! Emma qui, di nuovo su agent101.net, e oggi ci immergeremo in un argomento che mi preoccupa da settimane: far sì che il vostro agente IA si ricordi davvero delle cose. Non solo per un’interazione, ma attraverso le sessioni, anche quando chiudete il vostro script e tornate più tardi. Questa è la differenza tra un chatbot astuto e un vero assistente digitale, giusto?

Per un certo periodo, mi sono limitata a sperimentare con script semplici e momentanei. I miei piccoli agenti Python facevano il loro lavoro – recuperavano dati, riassumevano un articolo – e poi, puff! Tutto il loro “sapere” sulle nostre conversazioni o compiti precedenti era svanito. Sembrava di parlare con qualcuno che aveva gravi perdite di memoria a breve termine, il che, sebbene talvolta divertente, non è davvero produttivo per costruire qualcosa di utile.

Ricordo di aver cercato di creare un assistente personale per la ricerca. Il mio obiettivo era semplice: fornire articoli, fare domande e costruire una base di conoscenza su un argomento specifico. I primi tentativi sono stati… frustranti. Gli chiedevo “le ultime tendenze in informatica quantistica,” 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 di informatica quantistica. Praticamente dovevo rieducarlo ogni volta. Parliamo di inefficienza!

È allora che ho realizzato: affinché un’agente IA sia davvero 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 sistemi complessi di generazione aumentata di recupero (RAG) può sembrare un po’ schiacciante. Ma indovinate un po’? Non è necessario. Possiamo cominciare con qualcosa di meravigliosamente semplice e sorprendentemente efficace: i buoni vecchi file di testo, specificamente i file JSON.

Perché la Memoria Persistente è Importante per il Vostro Agente IA

Pensatela in questo modo: assumereste un assistente umano che dimentica tutto ciò che gli dite non appena varca la soglia? Probabilmente no. Il valore di un assistente, che sia umano o IA, deriva spesso dalla sua capacità di accumulare conoscenze su di voi, le vostre preferenze, i vostri progetti e le vostre interazioni passate. Questa conoscenza accumulata consente loro di:

• Fornire risposte contestualmente rilevanti: Non c’è più bisogno di spiegare la stessa cosa più volte.
• Effettuare compiti in più fasi: Possono ricordare le fasi precedenti e arricchirle.
• Imparare e adattarsi nel tempo: La loro “comprensione” dei vostri bisogni cresce.
• Offrire un’esperienza personalizzata: Ricordano le vostre preferenze, il nome del vostro animale domestico, il vostro caffè preferito – d’accordo, forse non ancora il caffè, ma avete capito l’idea!

Per noi che cominciamo, la memoria persistente è il ponte tra uno script carino e un vero compagno IA utile. È la differenza tra uno strumento usa e getta e qualcosa che funziona davvero *con* voi.

Il Percorso per Principianti: File di Testo e JSON

Va bene, quindi “memoria persistente” suona sofisticato, ma per il nostro primo approccio non abbiamo bisogno di configurare un server PostgreSQL o combattere con database vettoriali (non ancora!). Possiamo iniziare con qualcosa di meravigliosamente semplice e sorprendentemente efficace: i buoni vecchi file di testo, in particolare i file JSON.

Perché JSON? Perché è strutturato! Ci consente di memorizzare dati sotto forma di coppie chiave-valore, il che è perfetto per organizzare le informazioni che il nostro agente deve ricordare. È anche leggibile dall’uomo, il che è un enorme vantaggio quando si fa debug o si cerca semplicemente di capire cosa ha registrato il vostro agente.

Immaginate che il vostro agente abbia un file “cervello”. Ogni volta che impara qualcosa di importante, lo scrive in quel file. Ogni volta che deve ricordare qualcosa, legge quel file. Semplice, vero?

Esempio 1: Ricordarsi delle Preferenze dell’Utente

Supponiamo che stiate costruendo un semplice agente per riassumere contenuti. Volete che si ricordi della lunghezza del riassunto preferita dall’utente (corto, medio, lungo) e dei suoi argomenti preferiti. Senza memoria persistente, dovrete chiederglielo ogni volta. Con un file JSON, chiedete una sola volta, e il vostro agente si ricorda.

Innanzitutto, pensiamo alla struttura. Un semplice file JSON potrebbe assomigliare a questo:

{
 "user_preferences": {
 "summary_length": "medio",
 "favorite_topics": ["etica dell'IA", "biotecnologie", "esplorazione spaziale"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": []
}

Ora, come 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": "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 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("Ben tornato dal tuo agente!")

 # Caricare la memoria esistente o inizializzare una 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')}")

 # Simulare un utente che definisce 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"D'accordo, mi ricorderò che preferisci riassunti {user_input}.")
 else:
 print("Preferenza attuale mantenuta.")

 # Simulare 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("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 succede qui?

• `load_memory()` verifica se `agent_memory.json` esiste. Se sì, lo legge. Altrimenti, 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 ausiliari per facilitare l’interazione con parti specifiche della memoria.
• La parte principale dello script (`if __name__ == “__main__”:`) simula un utente che interagisce con l’agente, definendo preferenze, e poi l’agente utilizza queste preferenze.

Provate a eseguire questo script più volte. Vedrete che le vostre preferenze persistono anche dopo aver chiuso e riaperto lo script! Questa è la magia della memoria persistente, anche nella sua forma più semplice.

Esempio 2: Ricordarsi della Storia della Conversazione

Oltre alle preferenze, un aspetto cruciale della memoria di un agente è ricordarsi ciò che è stato appena detto. Questo è particolarmente importante per conversazioni o compiti a più turni. Mentre i LLM hanno una “finestra di contesto,” questo contesto viene generalmente cancellato dopo ogni chiamata API o sessione. Vogliamo estendere ciò.

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

Struttura aggiornata di `agent_memory.json`:

{
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": ["etica dell'IA", "biotecnologia", "esplorazione spaziale"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": [
 {"role": "user", "message": "Ciao, cosa c'è di nuovo?"},
 {"role": "agent", "message": "Non molto, sto solo aspettando le tue istruzioni!"}
 ]
}

Ora, aggiungiamo delle funzioni per gestire questa storia:

import json
import os
from datetime import datetime

MEMORY_FILE = "agent_memory.json"

# (Includere 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": "medium",
 "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()})
 # Facoltativo: mantenere la cronologia a una dimensione gestibile, diciamo 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 e cronologia ---

if __name__ == "__main__":
 print("Felice di rivederti! Ecco la nostra discussione 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 vero agente, questo comporterebbe una chiamata LLM)
 agent_response = f"D'accordo, hai detto '{user_message}'. Me ne ricorderò."
 add_to_history("agent", agent_response)
 print(f"Agente: {agent_response}")

 print("\nDiscussione terminata. La tua cronologia di conversazione è 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 si avvia, carica questa cronologia, offrendo all’agente una sorta di « memoria » delle interazioni precedenti. Ho aggiunto una piccola linea per troncare la cronologia alle ultime 10 voci – è un modo semplice per evitare che il tuo file di memoria cresca indefinitamente, il che può diventare un problema con conversazioni molto lunghe.

Considerazioni e prossimi passi

Sebbene i file JSON siano fantastici per iniziare, presentano delle limitazioni:

• Scalabilità: Per quantità molto grandi di dati, leggere e scrivere l’intero file più volte può diventare lento.
• Concorrenza: Se più parti del tuo agente (o più agenti) cercano di scrivere nello stesso file contemporaneamente, potresti incontrare problemi.
• Richieste complesse: È difficile porre domande come « trova tutte le conversazioni in cui l’utente ha menzionato ‘informatica quantistica’ 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. Comprendi il concetto fondamentale di memoria persistente senza la complessità aggiunta di un database.

Una volta che ti senti a tuo agio con i file JSON, ecco alcuni passi naturali successivi:

1. SQLite: Si tratta di un database relazionale basato su file, molto facile da integrare con Python. Risolve i problemi di scalabilità e di query dei file JSON senza richiedere un server separato. È spesso il passo logico successivo per molti progetti.
2. Database vettoriali (ad esempio, Chroma, FAISS): Qui le cose diventano davvero interessanti per gli agenti IA! I database vettoriali memorizzano informazioni sotto forma di embedding numerici, consentendo al tuo agente di eseguire ricerche semantiche (ad esempio, « trova informazioni correlate a questo concetto, » anche se le parole chiave esatte non sono presenti). È la base di molti sistemi avanzati di RAG.
3. Strutture di memoria più sofisticate: Invece di mantenere semplicemente conversazioni grezze, potresti provare a prendere appunti sui punti chiave, estrarre entità, o addirittura 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 IA che sembrano realmente utili e intelligenti. Iniziare con semplici file JSON è un modo incredibilmente pratico per afferrare il concetto fondamentale senza sentirsi sopraffatti dalla complessità.

Ecco cosa voglio che tu ricordi oggi:

• Inizia semplice: Non sentirti obbligato a utilizzare la tecnologia più avanzata fin da subito. I file JSON sono tuoi amici per una memoria persistente per principianti.
• La struttura è essenziale: Anche in un file JSON, pensa a come desideri organizzare la memoria del tuo agente (preferenze, cronologia, fatti appresi, ecc.).
• Pratica il caricamento e il salvataggio: Il ciclo principale di `load_memory()`, modifica `memory`, `save_memory()` è quello che utilizzerai costantemente.
• Ripeti ed espandi: Una volta che ti senti a tuo agio con JSON, sfida te stesso a passare a SQLite, poi esplora magari i database vettoriali. Ogni passo si basa su quello precedente.

Ricordo che una volta che sono riuscito a fare in modo che il mio agente semplice « si ricordasse » della mia lunghezza di riassunto preferita da una sessione all’altra, è sembrato un piccolo progresso. Non era solo eseguire codice; iniziava a dare l’impressione di avere un piccolo cervello digitale tutto suo. Prova – rimarrai sorpreso di quanto i tuoi agenti diventino più capaci!

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

🕒 Published: April 4, 2026