Chat
Inbox e lavori
Niente in attesa.
Qui gli appunti si scrivono soltanto: li elabora il server dopo la sincronizzazione, e le note elaborate arrivano con «Sincronizza».
la tua risposta in Richieste.
Nessun lavoro ancora.
Note
Tema scritto da brain: lega le note elencate in fondo. Lo aggiorna brain run themes (pagina Pipeline) — archiviato: non è più nella ricerca.
Nota unita da: (le originali sono in archive/)
Nota archiviata: unita in . Non è più nella ricerca.
Promemoria. Promemoria
brain propone il tag . Decidi in Impostazioni → Tag.
Richieste
Domande nate elaborando le note o premendo "Approfondisci" su una nota: la risposta va nella nota, in una sezione "Chiarimenti", e la nota viene riclassificata (con più domande di "Approfondisci", dopo l'ultima risposta). "Ignora" toglie la domanda e lascia la nota com'è.
Nessuna domanda in attesa.
Quello che brain ti ha proposto in chat, o approfondendo una nota, e che non hai ancora confermato: resta qui anche se chiudi la conversazione. "Conferma" lo fa (con le tue correzioni), "Scarta" lo dimentica.
Nessuna proposta in attesa.
Gruppi di note simili su cui il modello ha già deciso (pipeline merge, «Esamina» nella sua pagina). "Unisci" crea una nota sola che conserva il testo di ognuna e archivia le originali; "Rifiuta" (o "Va bene, non unire") le lascia separate e il gruppo non torna finché il testo di una delle note non cambia; "Unisci comunque" le unisce anche se il modello ha detto di no.
Nessuna fusione in attesa.
Vale per le chat con gli strumenti (intento esplora). Acceso: quando dici a brain qualcosa di nuovo, lo salva subito, come chiarimento nella nota a cui si riferisce oppure come nota nuova in inbox/. Spento: brain lo propone e tu confermi con "Salva nella nota" o "Crea la nota".
Promemoria
Le cose da fare. Si aggiungono in chat («ricordami di…», intento esplora) o scrivendo un appunto con una scadenza: brain la riconosce. brain non manda notifiche al telefono: i promemoria li trovi qui e nel widget di GNOME.
Nessun promemoria.
Revisioni
Revisioni settimanali (brain run weekly-review) e report del banco di prova (brain bench), dalla cartella reviews/ del vault.
Modelli
| Ruolo | Provider | Modello | Stato |
|---|---|---|---|
La chat con gli strumenti (intento esplora) su un vault di prova con data fissa: controlla quali strumenti chiama, con quali date, cosa propone e cosa risponde. Senza candidato prova solo il modello attuale. Il report va in Revisioni.
| Quando | Ruolo | Modello | Durata | Token | Esito |
|---|---|---|---|---|---|
Nessuna chiamata registrata.
Pipeline
Una pipeline è una fila di passaggi che brain esegue su una nota: ogni passaggio chiede qualcosa a un ruolo con un prompt, e alla fine la pipeline scrive il risultato. Apri una pipeline per vedere come lavora e per provarla senza scrivere niente.
Nessuna pipeline in ~/.config/brain/pipelines/.
Le note su cui questa pipeline non è ancora passata, o che sono cambiate da allora. Scegli quali elaborare: partono una dopo l'altra in un solo lavoro, che puoi fermare a metà (quelle già fatte restano fatte). "Ignora" le toglie dall'elenco senza chiamare il modello; dalla scheda della nota le rimetti in attesa.
Nessuna nota in attesa.
I gruppi su cui il modello ha già deciso, in attesa della tua decisione (le trovi anche in Richieste). Una proposta sparisce da sola se cambia il testo di una delle sue note: il gruppo torna tra quelli da esaminare.
Nessuna proposta in attesa.
I passaggi
Dall'alto in basso, nell'ordine in cui girano. Ogni passaggio può usare i risultati di quelli prima ({{ classify.title }}). Se uno fallisce la nota resta com'era: si scrive solo alla fine.
## Collegamenti da proposed_tag), da altrimenti question), da questions), da ## Chiarimentidue), da repeat), da merged_into e index: false; i collegamenti delle altre note vengono fatti puntare alla nota unitatype: theme e by: brain: il testo scritto dal modello e, in fondo, i collegamenti alle note che lega (almeno ). Un tema già scritto viene aggiornato nello stesso file; le tue note non vengono toccateindex: false. Un tema che il modello non nomina resta com'ègit revert) e aggiornamento dell'indiceProva a secco
Esegue tutti i passaggi come una vera esecuzione e mostra cosa scriverebbe, senza scrivere niente: nessuna modifica, nessuno spostamento, nessun commit.
Trova i gruppi di note simili e chiede al modello cosa farne, gruppo per gruppo, come la pipeline vera: poi mostra la decisione e l'anteprima della nota unita, e i pulsanti "Unisci" (o "Unisci comunque" se il modello dice di no). Prova anche i gruppi già decisi; le decisioni della prova non vengono conservate: per quello c'è "Esamina" qui sopra.
Nessun gruppo di note simili: niente da decidere. Si abbassa la soglia (groups.min_score) nel file YAML della pipeline.
Prompt inviato al modello
In una vera esecuzione la pipeline si fermerebbe qui e la nota resterebbe com'è.
Nessun tema: il modello non ne ha trovati.
da archiviare
La pipeline non scriverebbe niente: il passaggio da cui dipende è stato saltato.
| Campo | Prima | Dopo |
|---|---|---|
|
Nessun collegamento: la sezione verrebbe tolta o non aggiunta.
Collegamenti di adesso
Nella vera esecuzione finirebbero in Richieste, da confermare.
File: →
Il file resta dov'è:
In . Qui si legge soltanto.
Impostazioni
Intenti
I profili tra cui sceglie l'instradamento automatico (interruttore "Automatico" nella Chat, brain chat --auto): a ogni messaggio il router legge descrizione ed esempi e decide quale intento risponde, con il suo ruolo, il suo prompt e se cercare nelle note. Un intento con gli strumenti (come esplora) non riceve brani: il modello cerca, legge ed elenca le note da solo, e ogni chiamata è mostrata sopra la risposta. Spento, niente di tutto questo viene usato. Ogni salvataggio va in intents.yaml, registrato con git, e vale dal messaggio successivo.
Con gli intenti salvati: scrivi un messaggio e guarda quale intento sceglierebbe e con quali punteggi.
Tag
Le etichette che le pipeline possono dare alle note: il modello sceglie solo da qui, e la descrizione lo aiuta a scegliere bene. Quando nessuna va bene, il modello può proporne una nuova: la proposta resta nella nota finché la accetti o la rifiuti qui sotto. Togliere un tag non lo cancella dalle note che lo hanno già. Le modifiche valgono dalla prossima nota elaborata.
| Tag | Descrizione | Note | |
|---|---|---|---|
|
|||
Prompt
Le istruzioni che brain dà ai modelli, in ~/.config/brain/prompts/. Ogni salvataggio viene controllato e registrato con git: le versioni precedenti restano disponibili.
- Non usato da nessuna parte.
Variabili disponibili (clic per inserirle)
Scegli una nota: esegue i passaggi precedenti della pipeline su quella nota, poi questo. Non scrive niente nel vault.
Scrivi una domanda: risponde come la Chat, usando le istruzioni qui sopra e le tue note.
Lavora sulle note del periodo, come la pipeline vera. Non scrive niente nel vault.
Prompt inviato al modello
Modelli
Quale modello fa ogni lavoro. I ruoli sono quelli che usano chat, ricerca e pipeline: qui si sceglie il modello di ciascuno e come viene caricato. Ogni salvataggio va in models.yaml, registrato con git, e vale subito, senza riavviare.
Il modello di embed è cambiato: al prossimo aggiornamento l'indice verrà ricostruito da capo (qualche minuto).
Accessi
Le chiavi dei provider remoti. Una chiave incollata qui resta solo su questa macchina, in un file leggibile solo da te (), fuori dal vault e da git, e vale dalla chiamata successiva. brain non la mostra più: si vedono solo le ultime cifre. Se la stessa chiave è anche una variabile d'ambiente, vince la variabile.
Nessun provider remoto in models.yaml.
Viene dalla variabile d'ambiente: per cambiarla modifica l'ambiente del server.
Il browser ricorda il token di accesso al server. «Esci» lo dimentica: per rientrare servirà incollarlo di nuovo.
Instradamento automatico
Con l'interruttore Automatico acceso nella Chat (o brain chat --auto, brain ask --auto) non scegli tu il ruolo: a ogni messaggio un router sceglie un intento, cioè un profilo di risposta che dice chi risponde, con quali istruzioni e se consultare le note. Spento, la chat è esattamente quella di sempre.
Il percorso di un messaggio
Il router non risponde: sceglie soltanto. Legge il messaggio (e nient'altro), dà un punteggio a ogni intento e prende il migliore. Tutto quello che segue, ruolo, istruzioni, uso delle note, ragionamento, è scritto nell'intento scelto: il router non inventa nulla.
Anatomia di un intento
Un campo in più, tools, dà all'intento gli strumenti: il modello non riceve brani in anticipo ma cerca per significato (cerca) o per testo esatto in tutte le note (cerca_testo, come grep), legge (leggi_nota), elenca per tag o periodo (elenca_note) e consulta i tag (tag) da solo, al massimo sei chiamate per risposta, ciascuna mostrata sopra la risposta e registrata in runs.jsonl. Con un ruolo remoto gli strumenti non restituiscono mai una nota privata. È così che lavora l'intento esplora.
Due famiglie di campi. Quelli a sinistra servono solo al router per riconoscere il messaggio: più esempi scrivi, più la scelta è precisa, perché il metodo embed confronta il messaggio con ciascun esempio e prende la somiglianza più alta. Quelli a destra non c'entrano con la scelta: dicono come si risponde una volta scelto. Un intento il cui ruolo non esiste, o è riservato ai lavori lunghi, viene ignorato con un avviso.
I tuoi intenti
Letti adesso da intents.yaml. Si modificano in Impostazioni → Intenti.
Una conversazione
Menu "correggi…" sopra la risposta, /intent nome, --intent nome | forza quell'intento da adesso e spegne l'automatico per la conversazione; la correzione finisce in routes.jsonl con la domanda |
/intent auto, interruttore riacceso | il prossimo messaggio torna a essere instradato |
Menu dei ruoli, /role nome | scegli il ruolo a mano: l'automatico si spegne |
| Router non raggiungibile | risponde l'intento predefinito (router.default) o quello già in corso, con un avviso |
Il router
embedTrasforma il messaggio e ogni descrizione ed esempio in vettori con il ruolo di embedding (lo stesso dell'indice, caldo su CPU) e misura quanto si somigliano. Il punteggio di un intento è la somiglianza con il suo esempio più vicino.
Costo: 0,4 s con bge-m3; 1,7 s la prima volta, quando calcola gli esempi (poi restano in memoria). Pregi: veloce, nessun modello in più da caricare. Limiti: capisce per somiglianza, non per ragionamento: vive di esempi buoni.
chatDà a un modello di testo l'elenco degli intenti (nome, descrizione, esempi) e il messaggio, con il prompt router.md, e gli chiede un JSON con l'intento e la sua sicurezza. Ragionamento spento: deve solo scegliere.
Costo: circa un secondo in più a messaggio, più il caricamento se il ruolo non è quello della chat. Pregi: coglie casi sfumati. Limiti: più lento; il punteggio degli altri intenti è zero, quindi il margine conta meno.
| Metodo | |
| Ruolo del router | |
| Margine di cambio | |
| Intento predefinito | |
Un terzo metodo, laya (un piccolo classificatore su CPU addestrabile sulle decisioni registrate), è previsto nel formato del file ma non ancora implementato.
Ultime decisioni
Da ~/.local/share/brain/routes.jsonl, dalla più recente (brain intents log nel terminale). Le righe gialle sono le tue correzioni: sono anche i casi da aggiungere a bench/router.yaml.
Nessuna decisione registrata: l'instradamento automatico non è ancora stato usato.
| Quando | Messaggio | Intento | Punteggi |
|---|---|---|---|
| → (cambiato) |
Dove vivono le cose
~/.config/brain/intents.yaml | gli intenti e la sezione router; scritto da brain (Impostazioni → Intenti, brain intents), con storia git |
~/.config/brain/prompts/*.md | le istruzioni di ogni intento (chat.md, generale.md…) e router.md per il metodo chat; si modificano e si provano in Impostazioni → Prompt |
~/.config/brain/bench/router.yaml | domande con l'intento atteso; brain intents bench o "Banco di prova" in Impostazioni → Intenti li eseguono, report in Revisioni |
~/.local/share/brain/routes.jsonl | ogni decisione e correzione, con la domanda (mai il testo delle note) |
brain intents | elenco; test "messaggio" mostra la scelta con i punteggi; bench; log |
Aggiungere uno specialista in due mosse
- Impostazioni → Modelli: un ruolo nuovo (per esempio
coder) con il modello che vuoi, locale o su OpenRouter. - Impostazioni → Intenti: un intento nuovo che usa quel ruolo, con una descrizione e qualche esempio di richiesta; scegli il prompt e se deve cercare nelle note.
Attenzione alla VRAM: in 6 GB sta un modello da 4-9 miliardi alla volta. Due intenti con modelli locali diversi costano un caricamento di qualche secondo a ogni cambio di intento; il margine di cambio limita i cambi, non li azzera. Un ruolo remoto non tocca la GPU.
Privacy
Il router vede soltanto il messaggio: mai i brani delle note, mai la cronologia. Se il ruolo del router è remoto, in rete passa solo quello che hai scritto. Un intento su un ruolo remoto segue le regole di tutti gli altri ruoli: i brani di note private: true non partono, risponde il fallback locale se c'è, altrimenti si risponde senza quei brani e l'app lo dice.
Guida
Come funziona
Ogni appunto finisce in inbox/. La pipeline inbox gli dà titolo, tag e riassunto, lo collega alle note simili (sezione ## Collegamenti) e lo sposta in notes/. Il testo che hai scritto non viene mai modificato. Le note vengono indicizzate, così chat e ricerca le trovano per parole e per significato.
I modelli lavorano per ruoli: fast per chat e pipeline, embed per l'indice, deep per i lavori lunghi, cloud su OpenRouter. Quale modello fa cosa si decide in models.yaml.
Ogni scrittura nel vault diventa un commit git: un'elaborazione sbagliata si annulla con git revert nel vault.
Uso quotidiano
- Salvare un appunto
- Il pulsante con la matita in basso a destra, da qualsiasi pagina, oppure
brain add "testo". Gli appunti lunghi scritti in Obsidian dentroinbox/si elaborano conbrain run inboxo con "Elabora l'inbox". - Fare domande alle note
- Pagina Chat,
brain chatper una conversazione,brain ask "domanda"per una domanda sola. Le risposte citano le fonti come [1], [2]. - Lavori lunghi
brain run relinkriesamina i collegamenti, anche quelli tematici (un'abitudine che ritorna, una causa e il suo effetto).brain run themeslegge tutte le note in una volta e scrive i temi: note di brain, innotes/, che spiegano cosa lega note anche lontane tra loro e le collegano; a ogni esecuzione li aggiorna, ne aggiunge e archivia quelli superati, senza toccare le tue note e senza chiedere conferma (un commit per esecuzione).brain run weekly-reviewscrive la revisione della settimana inreviews/.mergetrova gruppi di note simili e chiede adeepse unirle in una nota sola che conserva il testo di ognuna; le originali finiscono inarchive/. Non unisce mai da sola: nella sua pagina «Esamina» fa decidere il modello, e le proposte aspettano te lì e in Richieste («Unisci», «Rifiuta», «Unisci comunque»); da terminalebrain merges.brain run reclassifyrifà titolo, tag e riassunto delle note con il modello di adesso (usafast, è rapido); per una nota sola c'è il pulsante "Riclassifica" nella sua scheda. Usano il ruolodeep, sono lenti e scaldano il portatile: uno alla volta.- Provare un modello
brain bench fast nome-modellolo confronta con quello attuale; il report finisce inreviews/. Per adottarlo si cambia una riga dimodels.yaml.- Se qualcosa non va
brain modelsmostra lo stato di Ollama e dei modelli,brain logle ultime chiamate,brain logs(o "Log Ollama") i log di Ollama in diretta.
Pagine dell'app
- Nuovo appunto
- Il pulsante con la matita apre un riquadro sopra la pagina: scrivi e salva con Ctrl+Invio, chiudi con Esc. Se lo chiudi mentre l'appunto viene elaborato, il lavoro continua e resta in "Inbox e lavori"; il testo non salvato resta lì alla riapertura. "Salva soltanto" equivale a
brain add --raw: la nota resta ininbox/senza elaborazione. - Chat
- Scegli il ruolo dal menu. "Salva come nota" mette la conversazione in
inbox/, "Nuova" ricomincia. Clicca una fonte per aprire la nota. Con l'interruttore Automatico acceso non scegli tu il ruolo: a ogni messaggio il router sceglie un intento (Impostazioni → Intenti), cioè ruolo, prompt e se cercare nelle note; sopra la risposta vedi quale e puoi correggerlo. Se un dato è ambiguo brain può farti una domanda invece di indovinare; quando rispondi, propone di salvare la risposta nella nota (sezione "Chiarimenti"): con l'interruttore "Salva i chiarimenti da solo" lo fa senza chiedere. Le domande nate elaborando le note stanno in Inbox e nella scheda della nota. L'intentoesploraha gli strumenti: il modello non riceve brani, ma cerca, legge ed elenca le note da solo (al massimo 6 chiamate, ognuna mostrata sopra la risposta) e cita le note con[[nome]]; è più lento, ma sa contare, sommare e mettere insieme più note. Il router lo sceglie da solo per le domande di quel tipo, oppure lo forzi con/intent esplora. Spento l'automatico, la chat è quella di sempre. - Inbox e lavori
- Note in attesa, pipeline da lanciare, ricostruzione dell'indice. I lavori girano uno alla volta: "dettagli" apre una finestra con ogni passaggio: prompt inviato, note candidate, risposta e ragionamento del modello, valori estratti; "interrompi" li ferma senza lasciare note a metà.
- Note
- Elenco delle note elaborate e ricerca (parole o significato).
- Revisioni
- Revisioni settimanali e report del banco di prova, dal più recente. Il filtro in alto separa i due tipi; dopo un bench, il link "Report" nei lavori apre direttamente il report.
- Impostazioni
- Nel menu laterale si apre e si richiude con la freccia e mostra le sue quattro sezioni. Tag: i tag ammessi, con la descrizione che il modello legge per scegliere e il numero di note che li usano; un tag tolto resta nelle note che lo avevano. In cima, i tag che il modello ha proposto quando nessuno andava bene, con le note che li propongono: "Accetta" lo aggiunge all'elenco (segnato come tag di brain) e lo dà a quelle note, "Accetta come…" lo fa con un altro nome o dentro un tag che c'è già, "Rifiuta" toglie la proposta. Prompt: le istruzioni date ai modelli, con le variabili disponibili, il controllo prima del salvataggio, le versioni salvate e il pulsante "Prova", che esegue il prompt (anche non salvato) su una nota o con una domanda senza scrivere niente. Modelli: per ogni ruolo provider, modello (scelto tra quelli installati in Ollama), contesto, GPU, tempo di permanenza, ragionamento, fallback e una nota; il salvataggio vale subito ed è registrato con git. Intenti: i profili dell'instradamento automatico (descrizione ed esempi che il router legge, ruolo, prompt, uso delle note) e le impostazioni del router; "Prova il router" mostra la scelta per un messaggio, "Banco di prova" esegue
bench/router.yaml. - Modelli
- Ruoli, modelli e stato (caricato, installato, mancante, quota in GPU), spesa del mese, banco di prova ("rapido" =
--quick), ultime chiamate dalla più recente, 20 per pagina. - Log Ollama
- Sidebar con i log in diretta. › la comprime e continua ad ascoltare; ✕ la chiude e ferma il comando.
Comandi
Si lanciano nel terminale. Ognuno accetta --help. Elenco generato dalla CLI stessa.
|
(facoltativo) |
|
Dentro brain chat
|
Pipeline
Si lanciano con brain run <nome>. Senza nota elaborano solo ciò che non è ancora stato elaborato; --all rifà tutto.
|
Una pipeline è un file in pipelines/, con un prompt per passaggio in prompts/.
Impostazioni della pipeline
name | nome usato in brain run |
folder | cartella da cui prende le note |
mode | note: una nota alla volta (predefinito); vault: una sola volta su tante note insieme (vedi scope); groups: una volta per gruppo di note simili (trovati dagli embedding, vedi groups) |
groups | con mode: groups: min_score (somiglianza minima tra due note, predefinito 0,6), max_notes (note per gruppo, predefinito 5), min_notes (2) |
scope | con mode: vault: period (predefinito) legge le note degli ultimi since_days giorni, all tutte le note della cartella. Con all se le note non entrano nel contesto del ruolo i testi vengono accorciati, poi restano fuori le più vecchie. I temi scritti da brain non vengono mai letti |
since_days | con mode: vault e scope: period, quanti giorni indietro (predefinito 7) |
steps | i passaggi, in ordine (vedi sotto) |
write.frontmatter | campi da aggiungere al frontmatter della nota |
write.links | collegamenti da scrivere in ## Collegamenti |
write.proposed_tag | tag proposto dal modello (name, description): finisce nel frontmatter come proposed_tag, da accettare o rifiutare in Impostazioni → Tag |
write.question | una domanda per l'utente (nel frontmatter come question), in Richieste; senza domanda la vecchia viene tolta |
write.questions | fino a 3 domande per approfondire la nota (questions, un elenco che sostituisce il precedente), in Richieste |
write.propose_notes | testi di note nuove proposte dal modello: mai create dalla pipeline, finiscono in Richieste da confermare |
write.keep_links | true: i collegamenti nuovi si aggiungono a quelli della nota invece di sostituirli |
write.due, write.repeat | scadenza e ripetizione di una cosa da fare (due, repeat): la nota diventa un promemoria; mai cambiate se ci sono già |
write.unsure | condizione (come when) per cui il modello è incerto, es. classify.confidence < 0.6: allora niente domanda, niente tag proposto e la nota non diventa un promemoria, salvo che avesse già una scadenza |
on_demand | true: la pipeline lavora solo sulle note scelte (pulsante, elenco delle note in attesa nella pagina della pipeline o brain run nome nota…), mai su una cartella intera; brain skip nome nota… toglie una nota dall'elenco |
write.move_to | cartella in cui spostare la nota alla fine |
write.create | scrive una nota nuova: folder, name, body |
write.themes | con mode: vault e scope: all: scrive i temi, le note di brain che legano le tue. items è l'elenco dei temi dal modello (titolo, riassunto, testo, note legate), drop quelli da archiviare; folder, archive, min_notes. Ogni tema è una nota con type: theme e by: brain |
write.merge | con mode: groups: unisce le note del gruppo se la condizione when è vera. title, intro, frontmatter dal modello; il testo di ogni nota resta intero, una sezione per nota. Le originali vanno in archive con merged_into e index: false. Mai senza conferma: le decisioni del modello restano proposte da accettare o rifiutare (pagina della pipeline, Richieste, brain merges), oppure brain run merge che chiede, --yes per accettare tutto |
Impostazioni di ogni passaggio
id | nome del passaggio, usato nelle variabili |
role | ruolo che lo esegue |
prompt | file del prompt in prompts/ |
output | text (predefinito) o json |
schema | con output: json, la forma attesa della risposta |
attempts | tentativi se il JSON non è valido (predefinito 2) |
when | condizione per eseguirlo, es. classify.confidence < 0.6 |
context | ricerca nel vault prima del passaggio: search, top_k (8), folder, min_score (da 0 a 1) |
temperature | 0 = risposte il più possibile ripetibili |
think | accende o spegne il ragionamento solo per questo passaggio |
Variabili nei prompt e nel YAML
{{ note.body }}, {{ note.title }} | testo e titolo della nota |
{{ tags }} | i nomi dei tag ammessi (tags.yaml), da usare in enum |
{{ tag_guide }} | un tag per riga con la sua descrizione, da mettere nei prompt |
{{ context.text }}, {{ context.notes }} | risultati della ricerca del passaggio |
{{ id.output }}, {{ id.campo }} | risultato di un passaggio precedente, es. {{ classify.tags }} |
{{ notes.text }}, {{ notes.count }} | con mode: vault: le note del periodo (o tutte, con scope: all) e quante sono |
{{ notes.names }}, {{ themes.text }}, {{ themes.names }}, {{ themes.count }} | con scope: all: i nomi delle note, e i temi già scritti da brain (nome, titolo, riassunto, note legate) |
{{ period.from }}, {{ period.to }}, {{ period.week }} | con mode: vault: il periodo |
Note speciali
private: true- Nel frontmatter: la nota non viene mai mandata a un provider remoto. Si usa il ruolo di
fallbacklocale, oppure i suoi brani vengono esclusi. index: false- La nota resta nel vault ma fuori da ricerca, chat e collegamenti (così nascono i report del bench).
Configurazione
In ~/.config/brain/. Dopo una modifica: riavvia il server (dal widget nella barra di GNOME, oppure brain server stop e poi brain server start).
config.yaml
vault | cartella del vault |
budget.monthly_usd | tetto di spesa mensile sui provider remoti; superato, si passa al fallback |
search.top_k | quanti brani delle note passare al modello (predefinito 6) |
ollama_logs | comando per i log di Ollama (predefinito docker logs --follow --tail 200 ollama) |
tags.yaml
nome: descrizione | un tag per riga; il modello sceglie solo da qui e legge la descrizione. Si modifica dalla scheda Impostazioni o con brain tags, e vale subito |
nome: {description, by: brain, since} | forma estesa di un tag nato da una proposta del modello e accettato: brain lo segna come suo |
models.yaml: provider
kind | ollama (locale) o openai (OpenRouter) |
base_url | indirizzo del provider |
api_key_env | nome della variabile d'ambiente con la chiave, es. OPENROUTER_API_KEY: la chiave non va mai scritta nei file |
models.yaml: ruoli
provider, model | dove e con quale modello gira il ruolo |
fallback | ruolo locale per note private, provider irraggiungibile o tetto di spesa raggiunto |
price | { input, output } in $ per milione di token, per stimare i costi |
num_ctx | dimensione del contesto (più grande = più VRAM) |
num_gpu | 0 = tutto su CPU e RAM |
keep_alive | quanto resta caricato dopo l'uso (10m, 0) |
think | accende o spegne il ragionamento |
batch_only | solo per i lavori lunghi, mai in chat e ask |
note | promemoria sul perché delle scelte, non arriva ai modelli. Il file si modifica dall'app (Impostazioni → Modelli), che lo riscrive: i commenti si perdono, la nota resta |
Altre cartelle
prompts/ | i testi dei prompt |
pipelines/ | le pipeline |
bench/ | i casi di prova del banco, uno per ruolo |
File e cartelle
~/.config/brain/ | la configurazione: un repository git, con un commit a ogni modifica di prompt o tag fatta da brain |
vault/inbox/ | appunti in attesa (qui si può scrivere da Obsidian) |
vault/notes/ | note elaborate: non modificarle a mano |
vault/reviews/ | revisioni settimanali e report del bench |
~/.local/share/brain/index.db | indice: si può cancellare, brain reindex --full lo ricostruisce |
~/.local/share/brain/runs.jsonl | registro delle chiamate ai modelli (brain log) |
~/.local/share/brain/token | token per il telefono; cancellalo per generarne uno nuovo |
~/.local/share/brain/serve.log | log del server avviato in background (da brain server start, brain app o dal widget) |
~/.local/share/brain/serve.pid | numero del processo del server acceso, per poterlo fermare |
Dal telefono: avvia il server in LAN dal widget nella barra di GNOME ("Avvia in LAN", poi "Copia link per il telefono") oppure con brain server start --lan, che stampa il link con il token da aprire in wifi. Se il server è acceso solo su questo PC, viene fermato e riavviato in LAN. Il widget si installa con brain server widget (poi esci dalla sessione e rientra).