Generazioni di Memoria AI
Generazioni di Memoria AI
RAG, Agentic File Search e LLM Wiki: come i modelli linguistici imparano a ricordare
Parole chiave SEO: generazioni di memoria AI, RAG, Retrieval Augmented Generation, Agentic File Search, LLM Wiki, Karpathy, knowledge base LLM, sviluppo applicazioni LLM
Indice dei Contenuti – Generazioni di Memoria AI
- 1. Quando i modelli hanno cominciato a dimenticare (e a ricordare)
- 2. RAG – Retrieval Augmented Generation
- 3. Agentic File Search
- 4. LLM Wiki – il pattern di Karpathy
- 5. Confronto fra i tre approcci
- 6. Esempi pratici in Python
- 7. Conclusioni e formazione professionale
1. Quando i modelli hanno cominciato a dimenticare (e a ricordare)
Immagina di avere un collega straordinariamente intelligente che però, ogni mattina, si presenta in ufficio senza ricordare nulla di ciò che è successo il giorno prima. Eccellente nelle analisi, veloce nel ragionamento, ma ogni sessione parte da zero. Questo è, in sostanza, il problema fondamentale dei Large Language Model (LLM): la loro “memoria” è congelata al momento dell’addestramento.
La sfida non è da poco: come si dota un modello linguistico di memoria persistente, aggiornabile e interrogabile in tempo reale? La risposta non è arrivata in un unico colpo, ma si è evoluta in tre generazioni distinte di soluzioni architetturali — RAG, Agentic File Search e LLM Wiki — ciascuna nata da limiti della precedente e portatrice di un salto concettuale significativo.
2. RAG – Retrieval Augmented Generation
Come nasce
Era il 2020 quando Patrick Lewis e il suo team — ricercatori distribuiti fra Meta AI, University College London e NYU — pubblicarono al NeurIPS il paper “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks”. L’idea era elegante nella sua semplicità: invece di chiedere a un modello di sapere tutto a memoria (memoria parametrica), gli si consente di consultare una biblioteca esterna al momento del bisogno (memoria non-parametrica).
Come funziona
Il flusso RAG classico si articola in tre fasi. Prima, i documenti vengono convertiti in vettori numerici (embedding) e indicizzati in un vector store. Poi, quando arriva una domanda dell’utente, la stessa domanda viene trasformata in un vettore e confrontata con tutti quelli presenti nel database — cercando i “frammenti” (chunk) semanticamente più vicini. Infine, quei chunk vengono iniettati nel prompt del modello, che genera la risposta arricchita dal contesto recuperato. È come aprire un libro al capitolo giusto e poi rispondere alla domanda con quella pagina davanti.
Il limite fondamentale del RAG classico è la sua natura stateless: ogni query riparte da zero. Il modello non accumula nulla tra una conversazione e l’altra. Se hai bisogno di sintetizzare cinque documenti diversi su un tema complesso, il sistema deve ogni volta ritrovare e riassemblare le informazioni. Nessun apprendimento progressivo, nessuna sintesi cumulativa.
3. Agentic File Search – Generazioni di Memoria AI
Come nasce
Nella primavera del 2024, OpenAI introdusse il tool file_search nell’Assistants API, evoluto poi nella Responses API nel marzo 2025. Non si trattava più di un semplice retriever vettoriale: era un agente capace di orchestrare autonomamente la ricerca su grandi archivi di file, combinando ricerca semantica (embedding) e ricerca lessicale (BM25) in un approccio ibrido. Nel 2025, con la Responses API, questa capacità matura e diventa lo standard per la costruzione di agenti autonomi su piattaforma OpenAI.
Come funziona
Il modello non aspetta di ricevere i chunk già confezionati: decide da solo quando e come cercare. Può riformulare la query, effettuare ricerche multiple, filtrare per metadati, reranking i risultati. Il tutto con pochissimo codice da parte dello sviluppatore. L’intelligenza del processo di ricerca è delegata al modello stesso, che gestisce il loop decide-cerca-verifica-rispondi senza intervento umano.
Rispetto al RAG classico, l’Agentic File Search è più flessibile e potente, ma porta con sé latenze più elevate e costi maggiori per ogni query, dato il numero di operazioni coinvolte. Rimane comunque una soluzione query-time: anche qui, ogni sessione non costruisce una sintesi persistente.
4. LLM Wiki – il pattern di Karpathy – Generazioni di Memoria AI
Come nasce
Il 4 aprile 2026, Andrej Karpathy — già ricercatore di OpenAI e Tesla — pubblica un Gist su GitHub intitolato semplicemente “llm-wiki.md”. In pochi giorni raccoglie oltre 5.000 star e 5.000 fork, diventando uno dei documenti più discussi nella comunità AI del 2026. Il motivo? Karpathy propone un cambio di paradigma radicale rispetto a RAG e Agentic File Search.
Come funziona
L’idea di Karpathy è deceptivamente semplice: invece di far ri-derivare la conoscenza a ogni query, l’LLM costruisce e mantiene una wiki persistente — una collezione strutturata di file markdown interconnessi tra loro. Ogni volta che viene aggiunta una nuova fonte, il modello la legge, ne estrae le informazioni chiave e le integra nella wiki esistente: aggiornando le pagine di entità, segnalando contraddizioni, rafforzando o sfidando la sintesi in costruzione. La conoscenza viene compilata una volta sola e poi aggiornata incrementalmente.
L’architettura si articola su tre livelli: le fonti grezze (immutabili, la fonte di verità), la wiki (file markdown generati e mantenuti dall’LLM), e lo schema (un documento CLAUDE.md o AGENTS.md che definisce le convenzioni e i workflow). Il workflow prevede tre operazioni principali: Ingest (aggiunta di nuove fonti e aggiornamento della wiki), Query (ricerca nella wiki e sintesi della risposta), e Lint (controllo periodico della salute della wiki: contraddizioni, pagine orfane, claim obsoleti).
La differenza concettuale è netta: nel RAG la conoscenza è recuperata; nell’LLM Wiki è compilata. Le cross-reference sono già lì. Le contraddizioni sono già state segnalate. La sintesi riflette tutto ciò che hai letto finora. È come avere un secondo cervello che cresce con te.
5. Confronto fra i tre approcci
Prima di vedere la tabella di riepilogo, è utile chiarire la differenza concettuale fondamentale tra i tre approcci. Il RAG è reattivo: risponde alle domande recuperando frammenti su richiesta, senza mai costruire nulla di permanente. L’Agentic File Search è proattivo ma anch’esso effimero: l’agente gestisce autonomamente la ricerca, ma ogni sessione non lascia tracce strutturate. L’LLM Wiki è cumulativo: la conoscenza si accumula nel tempo, ogni nuova fonte arricchisce un artefatto persistente che diventa sempre più prezioso.
In termini pratici: se hai un chatbot aziendale su FAQ, RAG va benissimo. Se devi fare research autonoma su centinaia di documenti, Agentic File Search è più adatto. Se stai costruendo una knowledge base personale o di team che cresce nel tempo, LLM Wiki è il pattern ideale.
| Caratteristica | RAG | Agentic File Search | LLM Wiki |
| Anno di nascita | 2020 (NeurIPS) | 2024 (OpenAI Assistants) | 2026 (Karpathy Gist) |
| Come funziona | Recupera chunk da vector DB a ogni query | Agente autonomo che cerca file con ibrido BM25 + vettori | LLM costruisce e mantiene una wiki markdown persistente |
| Tipo di memoria | Non-parametrica esterna (on-demand) | Non-parametrica esterna (agentica) | Non-parametrica strutturata (compilata) |
| Accumulazione | No – ricomincia ogni query | Parziale – vettori rimangono, sintesi no | Sì – la wiki cresce con ogni sorgente |
| Infrastruttura | Vector store + embedding model | Vector store + orchestratore agente | File system markdown + schema config |
| Complessità setup | Media | Alta | Bassa (file + LLM agent) |
| Ideale per | Q&A su documenti, chatbot aziendali | Ricerca autonoma su grandi archivi | Knowledge base personale/team, ricerca approfondita |
| Limite principale | Nessuna sintesi cumulativa | Costoso, latente, dipende da tool use | Non sostituisce RAG su dati molto dinamici |
6. Esempi pratici in Python
RAG – Pipeline base con LangChain
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain.chains import RetrievalQA
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(["La Terra orbita intorno al Sole."], embeddings)
llm = ChatOpenAI(model='gpt-4o')
qa = RetrievalQA.from_chain_type(llm=llm, retriever=vectorstore.as_retriever())
print(qa.invoke({'query': 'Cosa orbita intorno al Sole?'}))
Agentic File Search – OpenAI Responses API
from openai import OpenAI
client = OpenAI()
# Crea un vector store e carica documenti
vs = client.vector_stores.create(name='KnowledgeBase')
client.vector_stores.file_batches.upload_and_poll(
vector_store_id=vs.id,
files=[open('manuale.pdf', 'rb')]
)
# L'agente cerca autonomamente nella knowledge base
response = client.responses.create(
model='gpt-4o',
tools=[{'type': 'file_search', 'vector_store_ids': [vs.id]}],
input='Qual è la procedura di onboarding?'
)
print(response.output_text)
LLM Wiki – Ingest di una fonte con Claude
import anthropic, pathlib
client = anthropic.Anthropic()
wiki_path = pathlib.Path('wiki/')
wiki_path.mkdir(exist_ok=True)
source_text = open('articolo.txt').read()
index = open('wiki/index.md').read() if (wiki_path/'index.md').exists() else ''
response = client.messages.create(
model='claude-opus-4-6',
max_tokens=2000,
messages=[{'role': 'user', 'content': f'''
Sei un wiki maintainer. Leggi la fonte e aggiorna la wiki.
INDEX ATTUALE:\n{index}
NUOVA FONTE:\n{source_text}
Rispondi solo con il contenuto del nuovo file wiki in markdown.
'''}]
)
(wiki_path / 'sintesi.md').write_text(response.content[0].text)
7. Conclusioni e formazione professionale
Le tre generazioni di memoria AI, RAG, Agentic File Search e LLM Wiki, raccontano una storia di maturazione rapida e inarrestabile. In meno di sei anni, siamo passati da semplici pipeline di retrieval a sistemi che compilano knowledge base persistenti come un esperto umano farebbe, ma senza stancarsi mai e senza dimenticarsi di aggiornare le cross-reference.
Lo sviluppo di applicazioni LLM si sta diffondendo a una velocità che supera spesso la comprensione degli strumenti stessi. Scegliere il pattern sbagliato, RAG dove serve accumulazione, o LLM Wiki dove servono dati real-time, può significare sprecare risorse, produrre risultati inaffidabili o costruire architetture difficili da scalare. L’adozione consapevole di questi paradigmi non è un lusso accademico: è un’urgenza professionale concreta per chi sviluppa software oggi.
Se lavori in ambito IT e vuoi acquisire competenze solide e aggiornate sullo sviluppo di applicazioni LLM, dall’architettura RAG agli agenti autonomi, fino ai pattern più recenti come LLM Wiki, Innovaformazione propone percorsi formativi dedicati:
- Corso Sviluppo Applicazioni LLM – percorso completo per aziende IT che vogliono portare in produzione applicazioni basate su LLM.
- Corso Claude Code per Sviluppatori – per chi vuole padroneggiare Claude Code e costruire agenti e workflow avanzati.
CONTATTI
Per richiedere un preventivo o ulteriori informazioni, scrivi a info@innovaformazione.net oppure chiama il 347 101 2275 (Dario Carrassi). I corsi sono erogati per aziende IT in modalità personalizzata.
Per altri articoli di settore consigliamo di navigare sul nostro blog QUI.
Articoli correlati
Claude Code con Arduino
Novità .Net 11
Backdoor nei modelli AI open-weight
Opportunità di lavoro Bari
Spieghiamo il Weight space programming
