DEV Community: tauchi Italiano

Come Memory e Knowledge Base di osFoundry conservano ciò che la tua IA ha imparato e glielo restituiscono come contesto

tauchiii — Fri, 06 Nov 2026 15:10:04 +0000

Sono le 9:40 di un lunedì e apri una nuova chat con il tuo agente di coding. Giovedì scorso ha passato un'ora a capire che il servizio di fatturazione gira su Postgres 16 e che la suite di test completa richiede quattro minuti. Oggi ti rifà entrambe le domande. Rispondi, lui annuisce, e in un angolo della testa inizi a tenere una lista di cose che dovrai ripetere venerdì.

Cosa sono le funzioni Knowledge

osFoundry ha un gruppo di funzioni pensate proprio per fermare questa ripetizione: Note, Knowledge Base, Memory con i suoi Memory Groups, Lessons, Chat History e Indexed Folders. In parole semplici, sono i posti in cui viene salvato quello che scrivi tu e quello che scoprono i tuoi agenti, più i controlli che decidono quale parte viene restituita all'IA come contesto alla prossima esecuzione. Nell'app desktop non sono un unico grande pannello ma schermate separate: Notes per i tuoi documenti, Knowledge Base per gli articoli condivisi, Memory (con il sottotitolo "What Maestro knows & reads") per tutto ciò che ricordano l'assistente e i tuoi agenti, e Indexes per le cartelle che scegli di rendere ricercabili. Se hai mai usato una wiki accanto a un assistente di chat, immagina che la wiki e il quaderno dell'assistente stiano nella stessa app, con un interruttore su ogni scaffale che dice se l'IA può leggerlo.

Un primo sguardo alla schermata Memory

Questa è Memory con Agents selezionato, con dati di esempio. Cosa si vede:

La barra a sinistra: Memory Groups, Memory Browser, Chat History, Agents, Sessions e Lessons. Sotto "Indexing" ci sono Chunking Station, Indexed Folders ed Embeddings, che aprono la schermata Indexes.
L'elenco degli agenti ("Agents with memory"): ogni agente con il numero di memorie e lezioni che porta con sé, qui @code-agent e @research-agent.
"What it knows": fatti salvati da step completati e turni di chat, riletti nelle esecuzioni successive dell'agente. Nell'esempio: la versione di Postgres, il comando dei test e il fatto che preferisci pull request piccole.
"What it learned": regole scritte solo dopo che un revisore ha respinto il lavoro o uno step è fallito.
"Move what it learned": Save to a file e Import from a file, perché memorie e lezioni restano sul dispositivo e non seguono da sole un agente su un'altra macchina. In alto, Settings e Turn off controllano la memoria degli agenti nel suo insieme.

Tre modi in cui le persone lo usano

Una sviluppatrice solitaria che continua a rispiegare il codice

Maya mantiene da sola un'API di medie dimensioni e usa un agente per la maggior parte delle modifiche. Il suo problema non è che l'agente sia scarso, ma che ogni sessione riparte da zero.

Apre Indexes, resta sulla scheda Sources e clicca Add folder per scegliere il repository. La scansione è gratuita e mostra cosa verrà indicizzato prima che venga generato qualsiasi embedding. Sceglie "Index locally", che calcola gli embedding sulla sua macchina con un modello locale, e attiva "Re-index automatically when files change" così l'indice resta al passo con le sue modifiche.

Ora, quando chiede a Maestro a parole sue dove si trova la logica di blocco degli account, l'agente può lanciare una ricerca nella cartella che combina parole chiave e significato, e torna con percorsi dei file e intervalli di righe invece che con un'ipotesi. Nel giro di qualche giorno, i fatti che l'agente raccoglie strada facendo compaiono in Memory → Agents → "What it knows", così la conversazione successiva parte già da lì.

Cosa ottiene: un agente capace di cercare nel suo codice per significato e un elenco breve e leggibile di ciò che ricorda del suo progetto, da controllare quando vuole.

Un team lead che vuole che l'agente smetta di ripetere un errore

Daniel guida un piccolo team in cui gli agenti preparano le modifiche e una fase di revisione le controlla. Due settimane fa un agente ha "sistemato" un test che falliva cancellandolo. Il revisore ha respinto quell'esecuzione e osFoundry ha scritto una lezione a partire dal rifiuto.

Apre Memory → Lessons. Le lezioni di tutti gli agenti sono elencate insieme all'esecuzione da cui provengono, formulate come "When … : …". Tiene quelle utili, come "When a test fails after your change: fix the code. Never edit, skip or delete the test to make it pass." Una riga ha il badge "from outside content": viene da una pagina di prezzi letta dall'agente di ricerca e dice di consigliare sempre un piano specifico. L'agente tratta lezioni del genere come suggerimenti, non come istruzioni, ma Daniel non la vuole proprio lì, quindi clicca Retire.

Con "Show retired" attivo, la riga ritirata resta visibile in grigio con un pulsante Restore, quindi non si perde nulla se cambia idea. Cosa ottiene: agenti che leggono le lezioni attive più recenti prima di ogni esecuzione e un registro consultabile di ogni regola che hanno imparato e della sua provenienza.

Una consulente che vuole che l'IA usi il materiale del cliente giusto

Aiko è una consulente freelance, non un'ingegnera. I file dei suoi clienti sono qualche centinaio di documenti Word e PDF in cartelle sul suo portatile, e vuole che l'assistente risponda basandosi su di essi senza confondere i clienti.

In Notes clicca Import… e sceglie "Import folder…" (il menu lo descrive come pensato per un vault di Obsidian o un export estratto; "Import .zip archive…" copre un export di Notion o un backup di Bear). L'app desktop converte i file in note offline e mantiene la struttura delle cartelle nel File Tree.

Per le pagine che riutilizza con tutti i clienti, come la checklist di onboarding e le condizioni standard, crea una Knowledge Base: New Knowledge Base, poi New article, oppure Import content da PDF, DOCX, Markdown, un export di Notion o Confluence, o il crawl di un sito web. Dopo aver modificato un articolo preme Generate chunks, così l'IA recupera l'ultima versione; la sola modifica non lo reindicizza.

Poi va in Memory → Memory Groups e crea un gruppo per ogni cliente. Nell'impostazione "When can this be recalled?" di ciascun gruppo lascia il cliente attuale su Normal (cercato quando il progetto lo consente) e imposta un incarico concluso su Never, che lo toglie del tutto dalla ricerca pur mantenendolo salvato. Una memoria che deve comparire in ogni risposta, il suo listino tariffe, riceve "Pin (always in context)". Cosa ottiene: risposte tratte dal materiale del cliente giusto e un interruttore esplicito per spegnere tutto il resto.

Come si collega al resto dell'app

Le funzioni Knowledge servono soprattutto ad alimentare altre parti di osFoundry, più che a vivere da sole. Maestro, l'assistente integrato nell'app, è il lettore principale: cerca nei memory groups quando una domanda lo richiede e usa gli Indexed Folders tramite la sua ricerca nelle cartelle. Gli agenti delle schermate Agent team e Single agent portano la propria memoria e le proprie lezioni in ogni conversazione a cui partecipano. La scheda Health della schermata Indexes contiene Chunking Station ed Embeddings, dove vedi quali note, articoli e file sono cambiati, falliti o mai suddivisi in chunk. Chat History conserva le trascrizioni scritte quando le conversazioni lunghe vengono compattate, così puoi tornare alle parole originali dietro un riassunto. E per le conversazioni avvenute in altre app di IA sul tuo computer, External agents elenca quelle sessioni accanto a quelle di osFoundry. Le pagine dedicate agli agent memory groups e alle knowledge bases approfondiscono ciascuna funzione.

Domande che fa chi inizia

L'assistente legge automaticamente tutte le mie note?
No. L'assistente non legge le memorie automaticamente: le cerca quando una domanda ne ha bisogno, e l'impostazione di ogni memory group (Always on, Normal o Never) decide fin dove può arrivare quella ricerca. Le cartelle vengono indicizzate solo dopo averle aggiunte nella schermata Indexes.

Dove viene salvato tutto questo?
Memorie e lezioni degli agenti restano sul tuo dispositivo, e le lezioni non vengono mai caricate online. I memory groups possono essere personali o di tutto il workspace, e stare su questo dispositivo o nel cloud; la schermata Memory mostra i conteggi per entrambi.

Che differenza c'è tra Chat History, Sessions e Lessons?
Chat History è la trascrizione di ciò che è stato detto, Sessions mostra cosa hanno tenuto gli agenti da ogni step e Lessons sono le regole che gli agenti seguiranno la volta successiva. Le prime due sono prove che puoi verificare; le Lessons sono indicazioni che puoi ritirare o ripristinare.

Mi serve l'app desktop?
Per le parti che leggono il tuo computer, sì: indicizzazione delle cartelle, importazione di file in Notes, Chat History e le viste della memoria degli agenti funzionano nell'app desktop, che puoi scaricare dalla pagina di download.

Cosa fa Local Model di osFoundry, dalla scelta di un modello open alla sua messa a punto sul tuo computer

tauchiii — Fri, 06 Nov 2026 14:48:21 +0000

Sono le 16:40 di un giovedì e in una finestra c'è aperta la bozza di un contratto. Vorresti che un'IA sistemasse la formulazione, ma il documento non può uscire dal tuo portatile, e non sai quale dei cento modelli open su Hugging Face riuscirebbe anche solo a caricarsi con 16 GB di memoria. E non hai voglia di passare la serata in un terminale per scoprirlo.

Un unico gruppo nella sidebar per tutto quello che fai con i modelli open

Local Model è la parte di osFoundry che si occupa dei modelli open-weight in esecuzione su hardware che controlli tu. Nella sidebar dell'app desktop è una categoria a sé, divisa in tre sottosezioni: Run (Explore, Providers, Servers, Playground, Deployments, Cloud GPU, GPU Endpoints), Build (My Models, Datasets, Training, Quantize, Notebooks) e Measure (Eval, Benchmarks, Safety). Se hai usato Ollama o LM Studio, la parte Run ti sembrerà familiare: trovi un modello, lo scarichi, ci parli. La differenza è che lo stesso gruppo ti permette anche di ridurre un modello, fare fine-tuning sui tuoi esempi e testarlo con le tue domande, così l'intera vita di un modello resta in un'unica app. L'inferenza sul dispositivo usa un server llama.cpp incluso, quindi non serve installare nient'altro. Questa guida copre le nove schermate più usate: Explore, Servers, Playground, My Models, Datasets, Training, Quantize, Eval e Benchmarks.

Un primo sguardo a Explore

Quasi tutti iniziano da Explore, e il suo layout mostra come ragiona l'intera categoria: prima la tua macchina, poi i modelli.

Il pannello Filters a sinistra raggruppa i task di Hugging Face (Text Generation, Summarization, Translation, Embeddings, più i gruppi Multimodal, Vision e Audio) e ha una casella di ricerca.
Il banner in alto legge la tua macchina prima di mostrare qualsiasi cosa. Nell'esempio sopra indica 16 GB di memoria unificata, circa 12 GB utilizzabili per un modello, circa 9 GB liberi in quel momento, e che le stime presuppongono Q4_K_M e un contesto di 4K.
Ogni scheda ha un badge di compatibilità: verde Fits, ambra Tight, rosso Too big, ciascuno con una stima della memoria. Non viene nascosto nulla; i modelli che ci stanno sono semplicemente elencati per primi.
I pulsanti Providers e My Registry in alto a destra portano ai fornitori di API cloud e ai modelli che hai già.
Cliccando su una scheda si apre il dettaglio, dove Install Locally scarica una versione del modello, di solito un GGUF quantizzato che corrisponde al badge.

Tre persone, tre modi di usarlo

Una sviluppatrice indipendente con un solo portatile

Maya sviluppa progetti personali su un MacBook da 16 GB. Vuole un modello locale per scrivere messaggi di commit e brevi note, soprattutto per lavorare offline in treno.

Apre Explore, filtra per Text Generation e salta tutto ciò che ha il badge rosso. Due candidati sono verdi, quindi li installa entrambi con Install Locally. Poi apre Playground, scrive un prompt e aggiunge i due modelli come pannelli. Playground invia lo stesso prompt a due-quattro modelli contemporaneamente e mostra le risposte affiancate, con il tempo al primo token e il numero di parole sotto ogni pannello.

Più tardi trova un modello che le piace, ma che esiste solo come file F16 a piena precisione. Sono circa 15 GB, troppi per il suo portatile. In Quantize lo seleziona sotto "The model to shrink", sceglie Q4_K_M, il livello che l'app consiglia alla maggior parte delle persone, e avvia. Il llama-quantize incluso riscrive il file sulla sua macchina; non viene caricato niente.

Nell'esempio sopra il risultato è di 4.58 GiB, 3.3 volte più piccolo dell'originale. Prima di fidarsi, clicca Measure quality, che confronta il nuovo file con l'originale e compila le colonne "same top token" e KLD medio nella tabella Compare, poi Measure speed per i token al secondo. Un clic su Try it in Playground lo rimette accanto agli altri due. Chiude la serata con un modello che ci sta, numeri che mostrano quanto è costata la riduzione e nessuna cronologia del terminale.

Un piccolo team con un desktop potente

Un'agenzia di quattro persone ha in ufficio un desktop con molta memoria e diversi portatili leggeri. I modelli grandi stanno solo sul desktop, ma tutti vogliono usarli.

Sul desktop qualcuno apre Servers, seleziona This Mac e va nella scheda Access. Spunta "Allow access from other devices on the local network (LAN)" e attiva Remote Access. Il pannello elenca allora tutti i modelli locali che la macchina servirà. Sotto Device keys clicca New key, le dà il nome del portatile di un collega e clicca Create key; ogni chiave si può revocare singolarmente, e una chiave solo per l'inferenza può eseguire modelli ma non accedere alle sessioni degli agenti.

Su ogni portatile il collega apre Servers, clicca Add Server, inserisce l'indirizzo del desktop, incolla la chiave e usa Test Connection. Appena si collega, i modelli del desktop compaiono nel selettore dei modelli del portatile come qualsiasi altro modello. L'app stessa avverte che questo traffico è HTTP in chiaro, quindi è pensato per reti di cui ti fidi, come la LAN dell'ufficio.

Poi qualcuno apre Benchmarks, clicca New Benchmark, sceglie il modello e lascia la suite Quick. L'esecuzione registra token al secondo, tempo al primo token e latenza, così il team capisce se il modello condiviso è abbastanza veloce da usare durante le chiamate o solo per i batch notturni. Se sembra lento, Servers ha anche una scheda Config dove si può impostare un piccolo modello bozza sotto Speculative Decoding, poi Restart now, e rilanciare il benchmark per confrontare.

Il team si ritrova con una macchina che fa il lavoro pesante, una chiave per portatile che si può ritirare senza disturbare gli altri e una risposta misurata a "è abbastanza veloce?".

Un responsabile operativo che non scrive codice

Ken gestisce l'assistenza clienti di un piccolo negozio online. Ha due domande: quale modello legge correttamente i totali delle fatture, e un modello può imparare a rispondere con il tono del negozio?

Per la prima va in Eval e clicca Custom Benchmark. Gli dà un nome, incolla dieci fatture con il totale che si aspetta per ciascuna, lascia Exact Match e clicca Create Benchmark. Poi New Eval Run: spunta due modelli sul suo computer, spunta il suo benchmark e clicca Start Evaluation. Le domande vanno a ciascun modello sulla sua macchina.

In questo esempio un modello ottiene 90 e l'altro 70, e la colonna Diff mostra il distacco di 20 punti. È un risultato sui suoi documenti, non la classifica di qualcun altro.

Per la questione del tono raccoglie qualche centinaio di vecchi messaggi dei clienti con le risposte che il team ha davvero inviato, una coppia per riga. In Datasets può importare quel file, oppure cercare dati pubblici nella scheda Hub, e usare "Use for Training" per passarlo. In Training clicca New Job e segue i quattro passaggi: Base Model, Dataset, Config e Review. Sotto Training Target sceglie Local (This Device), che la schermata descrive come esecuzione sulla GPU del dispositivo e gratuita, con LoRA come metodo.

Dopo Start Training, il job mostra la loss mentre gira. Quando finisce, l'adapter addestrato compare in My Models accanto al modello base da cui deriva, e "Chat with your model" sull'esecuzione completata lo prepara per il runtime sul dispositivo, così può fargli una domanda in Playground. Alla fine ha un modello piccolo e privato e un benchmark da rilanciare ogni volta che valuta un nuovo modello.

Dove Local Model passa il testimone

La categoria non vive da sola. I modelli che installi o colleghi compaiono nella stessa lista di modelli usata dalla chat, quindi un modello locale può rispondere a una normale conversazione o essere confrontato in Playground con un modello cloud che hai aggiunto in Providers. Da Explore, "Use in Notebook" apre un notebook JupyterLab già configurato per quel modello, in locale o su un'istanza ospitata. Quando un modello ha bisogno di una vera GPU invece del tuo portatile, Deployments e Cloud GPU subentrano e lo mettono su un endpoint gestito. Prima che un modello arrivi ai clienti, Safety esegue suite di test red team su un modello deployato. La pagina sull'inferenza locale approfondisce il motore sul dispositivo, e la pagina sul fine-tuning LoRA copre la parte di addestramento.

Le prime domande che si fanno

Mi serve una GPU o un PC da gaming?
No. Un portatile recente basta per modelli piccoli e medi; i badge di Explore ti dicono cosa può reggere la tua macchina prima di scaricare. Un desktop più potente o un server remoto allargano semplicemente l'elenco.

Viene inviato qualcosa al cloud?
L'inferenza locale, Quantize e l'addestramento locale girano sulla tua macchina. L'addestramento su Cloud GPU, gli endpoint Cloud GPU e Providers sono le parti che usano servizi esterni, e le schermate lo indicano, per esempio con "Managed cloud GPU · needs credits" nella finestra di addestramento.

Che differenza c'è tra Eval e Benchmarks?
Eval valuta la qualità delle risposte rispetto a domande definite da te. Benchmarks misura velocità e memoria: token al secondo, tempo al primo token e latenza.

Dove trovo l'app?
Local Model funziona nell'app desktop, che puoi scaricare da osfoundry.io/it/download.