Ciao, agente in formazione! Emma qui, di nuovo su agent101.net, e oggi ci plongiamo a capofitto in qualcosa che mi frulla in testa (e nel mio ambiente di sviluppo) da settimane: come far sì che il tuo agente AI *ricordi* le cose. Non solo ricordare per un compito, ma portare quel contesto, quegli insegnamenti, quella personalità attraverso più interazioni. Perché ammettiamolo, un agente smemorato è solo uno script elegante, giusto?
La data attuale è 25 marzo 2026, e il mondo degli agenti AI si muove a velocità supersonica. Solo un anno o due fa, eravamo impressionati da un chatbot che poteva tenere una conversazione decente per cinque minuti. Adesso? Ci aspettiamo che i nostri agenti siano i nostri compagni digitali, i nostri assistenti alla ricerca, i nostri revisori di codice, e devono sembrare di conoscerci, o almeno sapere cosa stanno facendo. Non stiamo parlando di costruire un’AGI a tutto tondo (ancora!), ma di rendere i tuoi agenti AI pratici e quotidiani più utili, più intelligenti, e meno simili a Dory di Alla ricerca di Nemo.
Ho sperimentato con vari framework per agenti, da LangChain a AutoGen, e uno degli ostacoli costanti per i principianti (e, onestamente, anche per me a volte!) è gestire lo stato e la memoria in modo efficace. Spesso viene trascurato nei tutorial base, che tendono a concentrarsi su un singolo ciclo di prompt-risposta. Ma se vuoi che il tuo agente costruisca sulle sue azioni precedenti, impari dai propri errori, o persino solo ricordi il tuo nome dopo la prima interazione, hai bisogno di una strategia.
Perché il mio agente continua a dimenticare di cosa abbiamo appena parlato?
Immagina questo: stavo cercando di costruire un semplice agente per aiutarmi a brainstormingare idee per post sul blog. La mia configurazione iniziale era piuttosto basilare: gli davo un argomento e lui generava idee. Ottimo per sollecitazioni isolato. Ma poi dicevo: “Ok, ora espandi l’idea numero tre,” e mi guardava (metaforicamente parlando) con uno sguardo vuoto, chiedendo, “Quale idea numero tre?” Era frustrante! Significava che dovevo continuamente ri-providere contesto, rendendo l’interazione goffa e inefficiente.
Questa “smemoratezza” deriva dalla natura stateless della maggior parte dei modelli di linguaggio di grandi dimensioni (LLM) alla loro base. Ogni chiamata API è spesso trattata come una nuova richiesta. Non ricorda intrinsecamente la cronologia delle conversazioni o i risultati delle chiamate precedenti. I framework per agenti esistono per orchestrare queste chiamate, ma tu, sviluppatore, sei responsabile di decidere quali informazioni portare avanti. Qui entra in gioco la memoria.
Le Due Grandi Categorie della Memoria degli Agenti: Breve Termine e Lungo Termine
Quando parliamo di un agente AI che “ricorda,” di solito parliamo di due tipi principali di memoria, proprio come la nostra:
Memoria a Breve Termine: Il Buffer della Conversazione
Questo è il tipo di memoria più semplice e con cui la maggior parte dei principianti dovrebbe iniziare. La memoria a breve termine riguarda il ricordare il passato immediato – la conversazione attuale. Pensala come alla tua memoria di lavoro quando stai chiacchierando con un amico. Ricordi cosa è stato appena detto, chi ha detto cosa e il flusso generale della discussione.
Per un agente AI, questo di solito significa memorizzare lo scambio recente di messaggi (prompt e risposte) e inviarli insieme a ogni nuovo prompt all’LLM. La maggior parte dei framework per agenti offre modi semplici per implementare questo.
Esempio Pratico: La ConversationBufferMemory di LangChain
Vediamo un esempio base in Python utilizzando LangChain. Questo dimostra come mantenere una semplice cronologia delle conversazioni.
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
# Inizializza il tuo LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
# Inizializza la memoria
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Definisci un semplice template di prompt
template = """Sei un'assistente AI amichevole.
Conversazione attuale:
{chat_history}
Umano: {input}
AI:"""
prompt = PromptTemplate(input_variables=["chat_history", "input"], template=template)
# Crea la catena di conversazione
conversation_chain = LLMChain(
llm=llm,
prompt=prompt,
verbose=True, # Aiuta a vedere cosa sta succedendo
memory=memory
)
# Prima interazione
print("--- Interazione 1 ---")
response1 = conversation_chain.invoke({"input": "Ciao, mi chiamo Emma. E tu?"})
print(f"AI: {response1['text']}")
# Seconda interazione, nota come 'chat_history' viene passato automaticamente
print("\n--- Interazione 2 ---")
response2 = conversation_chain.invoke({"input": "Puoi dirmi un curioso fatto sull'AI?"})
print(f"AI: {response2['text']}")
# Terza interazione, l'agente ricorda il mio nome!
print("\n--- Interazione 3 ---")
response3 = conversation_chain.invoke({"input": "Grazie! A proposito, quanti anni ha Emma?"})
print(f"AI: {response3['text']}")
print("\n--- Stato Finale della Memoria ---")
print(memory.load_memory_variables({}))
Cosa sta succedendo qui?
- `ConversationBufferMemory` memorizza i messaggi man mano che accadono.
- Il `PromptTemplate` include una variabile `{chat_history}`.
- Quando viene chiamato `conversation_chain.invoke()`, LangChain inietta automaticamente la `chat_history` memorizzata nel prompt prima di inviarla all’LLM.
Questo è ottimo per conversazioni brevi. Ma cosa succede se la tua conversazione si protrae per molto tempo? Gli LLM hanno finestre di contesto (un limite su quanto testo possono elaborare alla volta). Se la tua cronologia delle chat diventa troppo lunga, raggiungerai quel limite e riceverai un errore, oppure le parti più vecchie della conversazione verranno troncate. Qui entrano in gioco strategie di memoria a breve termine più avanzate, come `ConversationBufferWindowMemory` (ricorda solo le ultime N interazioni) o `ConversationSummaryBufferMemory` (riassume le parti più vecchie della conversazione per risparmiare spazio).
Memoria a Lungo Termine: Base di Conoscenza e Database di Vettori
La memoria a breve termine riguarda la chat immediata. La memoria a lungo termine riguarda la conoscenza persistente, fatti, esperienze passate, o persino una “personalità” appresa che un agente dovrebbe mantenere attraverso le sessioni o anche attraverso diversi compiti. Qui le cose diventano davvero interessanti e potenti.
Il mio esempio di agente per brainstorming di post sul blog è un caso perfetto per la memoria a lungo termine. Voglio che ricordi il mio stile preferito, la mia nicchia (agenti AI per principianti) e persino argomenti di successo passati, così non suggerisce qualcosa di completamente irrilevante ogni volta. Non voglio spiegare agent101.net a lui ogni singolo giorno!
Il modo più comune per implementare la memoria a lungo termine al momento prevede due componenti chiave:
- Modelli di Embedding: Questi modelli convertono il testo (la tua conoscenza, le interazioni passate, ecc.) in vettori numerici. I testi con significati simili avranno vettori che sono numericamente “vicini” tra loro.
- Database di Vettori (o Database di Vettori): Questi sono database specializzati progettati per memorizzare e cercare efficientemente questi vettori numerici. Quando hai una nuova query o contesto, lo converti in un vettore, poi cerchi nel database di vettori i vettori esistenti più simili. Il testo associato a quei vettori simili viene quindi recuperato e può essere iniettato nel tuo prompt.
Questo processo viene spesso chiamato Retrieval Augmented Generation (RAG). Recuperi informazioni rilevanti dalla tua memoria a lungo termine e arricchisci il prompt dell’LLM con esse.
Esempio Pratico: Utilizzare un Database di Vettori per la Personalità dell’Agente
Immaginiamo di voler che il nostro agente abbia una “persona” coerente o acceda a una base di conoscenza sul nostro marchio. Possiamo memorizzare queste informazioni in un database di vettori.
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.prompts import PromptTemplate
# 1. Definisci le nostre 'conoscenze a lungo termine' (es. persona dell'agente, linee guida del marchio)
# In uno scenario reale, questo verrebbe caricato da un file, database, ecc.
brand_persona_info = """
Il nome dell'agente è Emma. Scrive per agent101.net.
Il suo stile di scrittura è amichevole, pratico e si concentra sull'aiutare i principianti a capire gli agenti AI.
Usa aneddoti e cerca di evitare gergo tecnico eccessivo quando possibile.
Il suo pubblico principale sono individui nuovi agli agenti AI o alla ricerca di suggerimenti per implementazioni pratiche.
Gli argomenti chiave includono: LangChain, AutoGen, progettazione di prompt per agenti, gestione della memoria, utilizzo degli strumenti.
Il suo obiettivo è demistificare concetti complessi dell'AI.
"""
# 2. Suddividi il testo in parti gestibili (per documenti più grandi)
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
docs = text_splitter.create_documents([brand_persona_info])
# 3. Crea gli embeddings e memorizzali in uno store vettoriale
# FAISS è una buona opzione locale per i principianti. Per la produzione, useresti Pinecone, Chroma, ecc.
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
# 4. Inizializza il LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)
# 5. Crea un recuperatore dallo store vettoriale
retriever = vectorstore.as_retriever()
# 6. Definisci un modello di prompt personalizzato per la catena RAG
# Diciamo esplicitamente al LLM di usare il contesto fornito.
custom_prompt_template = """Usa il seguente contesto per rispondere alla domanda dell'utente.
Se non conosci la risposta basata sul contesto, semplicemente dì che non lo sai, non cercare di inventare una risposta.
Contesto:
{context}
Domanda: {question}
"""
custom_prompt = PromptTemplate(
template=custom_prompt_template,
input_variables=["context", "question"]
)
# 7. Crea la catena RAG
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff", # 'stuff' significa mettere tutti i documenti recuperati nel prompt
retriever=retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": custom_prompt}
)
# Ora, interroghiamo l'agente
print("--- Query 1 ---")
query1 = "Chi sei e di cosa scrivi?"
result1 = qa_chain.invoke({"query": query1})
print(f"AI: {result1['result']}")
print("\n--- Query 2 ---")
query2 = "Qual è lo stile di scrittura preferito di Emma?"
result2 = qa_chain.invoke({"query": query2})
print(f"AI: {result2['result']}")
print("\n--- Query 3 (Conoscenza Esterna) ---")
query3 = "Qual è la capitale della Francia?" # Questa informazione non è nel nostro profilo persona
result3 = qa_chain.invoke({"query": query3})
print(f"AI: {result3['result']}") # Dovrebbe comunque rispondere perché il LLM ha conoscenze generali,
# ma se volessimo rigorosamente *solo* il contesto, dovremmo modificare il prompt.
# Nota Importante: Se desideri che l'agente aderisca rigorosamente a *solo* il contesto fornito
# e rifiuti di rispondere se il contesto non contiene la risposta, devi essere molto
# esplicito nel tuo custom_prompt_template. Ad esempio: "Basato SOLAMENTE sul seguente contesto..."
Analizziamo l’esempio RAG:
- Abbiamo preso il nostro “profilo” testo.
- Lo abbiamo suddiviso in parti (importante per documenti più grandi).
- Abbiamo usato `OpenAIEmbeddings` per trasformare queste parti in vettori numerici.
- `FAISS` (uno store vettoriale locale) ha memorizzato questi vettori.
- Quando abbiamo posto una domanda, il `retriever` ha cercato in `FAISS` i pezzi di testo più rilevanti.
- Questi pezzi rilevanti sono stati poi inseriti nel nostro `custom_prompt_template` come `{context}`.
- Infine, il LLM ha usato questo prompt arricchito per rispondere alla domanda, facendolo sembrare come se “ricordasse” la sua persona.
Questo approccio è incredibilmente flessibile. Puoi usarlo per:
- Memorizzare documenti (PDF, articoli, wiki interni).
- Ricordare le preferenze degli utenti nel tempo.
- Mantenere la “personalità” di un agente o istruzioni specifiche.
- Memorizzare azioni precedenti di successo dell’agente o strategie di pianificazione.
La Mia Opinione Personale su Come Iniziare con la Memoria
Quando ho iniziato, ho cercato di costruire tutto da zero, pensando di essere furbo. Ho imparato rapidamente che utilizzare framework consolidati come LangChain o AutoGen (che ha i suoi concetti di memoria, spesso tramite la cronologia dei messaggi dell’agente) è la strada da seguire. Gestiscono gran parte del codice di base per te.
Il mio consiglio per i principianti:
- Inizia con `ConversationBufferMemory`. È il più semplice e farà immediatamente sentire i tuoi agenti più conversazionali.
- Comprendi i limiti della finestra di contesto. Se le tue conversazioni diventano lunghe, passa a `ConversationBufferWindowMemory` o `ConversationSummaryBufferMemory` per evitare troncamenti o costi eccessivi delle API.
- Non saltare direttamente a sistemi RAG complessi. Abituati prima alla memoria di chat di base. Una volta che vedi la necessità di conoscenza persistente o richiamo di fatti specifici, allora esplora gli store vettoriali.
- Fai attenzione alla progettazione del prompt per RAG. Come istruisci il LLM a utilizzare il contesto recuperato è cruciale. Sperimenta con frasi come “Usa SOLO il seguente contesto,” o “Supplementa la tua conoscenza con il seguente contesto.”
- Separa le esigenze a breve e lungo termine. Non cercare di stipare l’intera storia di vita del tuo agente nella `chat_history`. Riserva `chat_history` per l’interazione corrente e usa RAG per tutto il resto.
Una sfida che ho affrontato è stata gestire la memoria su più *sessioni*. Se il mio agente si riavviava, la sua `ConversationBufferMemory` era sparita. Per una memoria a breve termine davvero persistente (es. se vuoi riprendere una chat da dove l’hai lasciata ieri), dovrai serializzare e memorizzare il tuo oggetto `memory` (es. come un file JSON o in un database) e caricarlo quando l’agente si avvia. Questo aggiunge un ulteriore livello di complessità, ma è assolutamente fattibile una volta che hai compreso le basi.
Obiettivi Concreti per il Tuo Prossimo Progetto con un Agente
Hai la teoria, ora vai a costruire! Ecco cosa voglio che tu faccia dopo:
- Scegli un progetto di agente semplice esistente (o inizia uno nuovo) che hai costruito e che attualmente “dimentica” le cose.
- Implementa `ConversationBufferMemory` per fornire un richiamo a breve termine di base. Vedi quanto diventa più naturale la conversazione.
- Pensa a quale conoscenza persistente potrebbe aver bisogno il tuo agente. È un insieme specifico di istruzioni? Una preferenza personale? Una base di conoscenza?
- Sperimenta con una configurazione RAG semplice. Prendi un piccolo pezzo di testo (come il desiderato profilo del tuo agente o alcuni fatti) e memorizzalo in uno store vettoriale `FAISS` locale. Vedi se il tuo agente può recuperare e utilizzare quell’informazione.
- Fai attenzione all’uso dei token! Ricorda, inviare lunghe cronologie di chat o molti documenti recuperati aumenta il tuo conteggio di token, il che impatta direttamente su costi e latenza. Ottimizza la tua strategia di memoria man mano che procedi.
Far ricordare al tuo agente AI non è solo un dettaglio tecnico; è ciò che trasforma un’interazione fredda e transazionale in qualcosa che sembra genuinamente utile e intelligente. È la differenza tra uno strumento e un vero assistente. Fai diventare i tuoi agenti più intelligenti e non dimenticare di condividere i tuoi progressi nei forum di agent101.net!
Articoli Correlati
- Il Costo di NON Usare Agenti AI nel 2026
- Strumenti Principali per lo Sviluppo di Agenti AI
- Fondamenti dell’AI: Una Guida Pratica per Iniziare nel 2026
🕒 Published: