Cosa fa

Appunto registra l'audio di qualsiasi call (Google Meet, Zoom, Teams, …) direttamente dal tuo computer, lo trascrive in locale con whisper.cpp e lo trasforma in una memoria in cui puoi cercare:

• Elenco delle riunioni con le decisioni, le azioni, i ticket Jira, le issue e le pull request di ognuna; filtra per mese e anno, elimina una riunione o tutte insieme.
• Da fare: ogni azione sentita in riunione diventa una cosa da fare, una volta sola, con il link al momento in cui è stata detta. Spuntale, aggiungi le tue, scegli chi e quando, e guarda l'avanzamento della settimana.
• Chiedi alle tue riunioni: «Cosa abbiamo deciso su PROJ-142?». Le risposte citano il momento esatto, con il link alla trascrizione.
• MCP (la scheda per collegare un'AI; facoltativo, spento all'inizio): Claude Desktop, Claude Code, Codex o qualsiasi client MCP possono cercare nelle riunioni, leggere le trascrizioni e gestire le cose da fare. Scegli tu cosa vede; vedi Collegare un assistente AI.
• Strumenti collegati (facoltativo): Jira / Confluence (Atlassian), GitHub, GitLab e Azure DevOps tramite i loro server MCP ufficiali, con l'accesso dal browser. Nessun token da copiare.
• Chi c'era in call (facoltativo): accedi con Google una volta e ogni registrazione prende il titolo dell'evento del Calendario e i nomi delle persone invitate e, per le call di Google Meet, di chi è entrato davvero, senza bot in riunione. I nomi si possono anche aggiungere a mano.
• Voci con il nome giusto (macOS, facoltativo): mentre registri, l'app legge la scheda di Google Meet aperta in Chrome, Edge, Brave o Safari (Arc: sperimentale), cioè l'elenco dei partecipanti e, se i sottotitoli (CC) di Meet sono attivi, chi sta parlando, e mette il nome giusto su «Voce 1», «Voce 2», … Senza estensioni, senza bot, senza accesso a Google; serve un'impostazione del browser da attivare una volta (vedi Primo avvio).
• L'AI che preferisci: Google Gemini con una chiave API gratuita (l'app sceglie il modello per te e cambia da sola quando uno raggiunge il limite giornaliero), il tuo piano ChatGPT Plus/Pro (accedi, nessuna chiave API), OpenAI, Anthropic o OpenRouter.
• Missione configurazione: la Home ti dice cosa manca (microfono, audio della chiamata, modello vocale, nomi da Meet), con un pulsante Risolvi e una guida passo passo; ogni passo diventa verde da solo appena funziona.
• Si aggiorna da sola: quando esce una nuova versione l'app propone Aggiorna e riavvia; riunioni, impostazioni e permessi di macOS restano.
• Interfaccia in italiano e inglese; trascrizione in 12 lingue.

Privacy

• L'audio non lascia mai il tuo computer. Le registrazioni sono trascritte in locale e salvate in un database SQLite locale.
• Quando fai una domanda, solo i pochi pezzi di trascrizione utili vengono inviati al fornitore AI che hai scelto.
• Gli strumenti collegati ricevono solo codici (per esempio PROJ-142, owner/repo#12), mai il testo delle trascrizioni. Google riceve solo l'intervallo di tempo di una registrazione e il codice della riunione; i nomi dei partecipanti restano nel database locale.
• La lettura della scheda di Google Meet (macOS) avviene sul tuo computer e solo mentre registri: l'app legge i nomi dei partecipanti e chi parlava quando; il testo dei sottotitoli non viene mai letto né salvato, e niente viene inviato. Con il riconoscimento delle voci attivo, una voce a cui hai dato un nome viene salvata come impronta vocale, così le riunioni successive riconoscono la persona; le voci si possono cancellare in qualsiasi momento nelle Impostazioni.
• L'impostazione del browser Consenti JavaScript dagli Apple Events permette a ogni app autorizzata in Privacy e sicurezza → Automazione di eseguire script nelle schede del browser, non solo ad Appunto. Autorizza solo app di cui ti fidi, e disattiva l'impostazione se smetti di usare la funzione.
• Le chiavi API e i token di accesso sono salvati sul tuo computer in secrets.json, nella cartella dei dati dell'app, leggibile solo dal tuo account utente. Non sono cifrati, quindi chiunque (o qualsiasi programma) usi il tuo account può leggerli.
• MCP è spento finché non lo accendi. Appunto non apre nessuna porta di rete: è l'assistente sul tuo computer ad avviare Appunto e a leggere attraverso di lui. Quello che l'assistente legge esce dal tuo computer e va al suo fornitore (Anthropic, OpenAI, …), quindi condividi solo ciò che ti va di condividere. Impronte vocali e audio non vengono mai condivisi.
• Registrare altre persone può richiedere il loro consenso dove vivi: avvisa chi partecipa quando registri.

Gemini gratuito: Google può usare le richieste e le risposte del piano gratuito per migliorare i suoi prodotti. Per le riunioni riservate attiva la fatturazione sulla tua chiave o scegli un altro fornitore.

L'informativa completa è nella pagina Privacy.

Installazione

Niente terminale, niente configurazione: scarichi un file, lo installi come ogni altra app e lo apri. Il file per il tuo computer e i passi per installarlo sono nella pagina Scarica.

Primo avvio

• L'app scarica una volta il modello vocale (circa 874 MB). Tienila aperta finché la barra di avanzamento non finisce. Il file viene verificato con un checksum e resta sul tuo computer.
• Alle domande sulle riunioni risponde un modello integrato nell'app («Locale / privato»): premi Scarica sulla sua scheda (circa 2,7 GB, una volta sola) e niente esce dal tuo computer. Oppure scegli un fornitore cloud nelle Impostazioni.
• macOS: la Missione configurazione in Home elenca cosa manca. Consenti fa comparire la richiesta di macOS per Microfono e Registrazione schermo e audio di sistema; Risolvi apre una guida passo passo con un pulsante che porta alla pagina giusta delle Impostazioni di Sistema. Dopo la registrazione dello schermo macOS può chiederti di chiudere e riaprire l'app. Lo stesso elenco è sempre nelle Impostazioni.
• macOS, nomi delle voci da Google Meet (facoltativo):
  1. Nel browser che usi per Meet, attiva Consenti JavaScript dagli Apple Events: Chrome, Edge, Brave: Visualizza → Sviluppatore; Safari: menu Sviluppo (lo mostri con Safari → Impostazioni → Avanzate → Mostra funzionalità per sviluppatori web).
  2. Alla prima registrazione con il browser aperto, macOS chiede se Appunto può controllarlo: premi Consenti (in seguito: Impostazioni di Sistema → Privacy e sicurezza → Automazione).
  3. Nella call di Meet attiva i sottotitoli (CC) così le voci possono avere un nome; l'elenco dei partecipanti si legge anche senza.
  Nella Missione configurazione, Sapere chi parla → Risolvi → Verifica ora prova subito il tuo browser (macOS chiede lì il permesso di Automazione) e ti dice quale passo manca. L'estensione per il browser di Meet resta un'alternativa solo per l'elenco dei partecipanti (qualsiasi sistema con Chrome).
• Windows: niente da configurare. Se il microfono non si sente, controlla Impostazioni → Privacy e sicurezza → Microfono e consenti l'accesso alle app desktop.
• Linux: serve PulseAudio o PipeWire, che la maggior parte dei desktop ha già.

Per iniziare

1. Impostazioni → Collegamenti: ogni servizio è una scheda con un pulsante Collega che apre l'accesso nel browser; non ci sono chiavi API o token da cercare. In Assistente AI scegli Continua con ChatGPT (piano ChatGPT Plus/Pro) o l'accesso con OpenRouter, oppure il modello integrato Locale / privato (gratis, niente esce dal computer: si scarica una volta). Un'altra scelta gratuita è Google Gemini, in Avanzate → Usa una tua chiave: crea una chiave gratuita su aistudio.google.com/apikey e incollala. L'app usa Gemini 3.5 Flash-Lite, poi Gemini 3.1 Flash-Lite, poi Gemma 4 quando un modello non risponde o raggiunge il limite giornaliero gratuito (circa 1.000 domande al giorno prima di Gemma). Anche OpenAI e Anthropic accettano una chiave lì. Un abbonamento Claude non si può usare: Anthropic consente solo chiavi API nelle app di terze parti.
2. Impostazioni → Lingua: scegli la lingua dell'app e quella parlata nelle tue riunioni.
3. Facoltativo, Impostazioni → Collegamenti → I tuoi strumenti: collega Jira, GitHub, GitLab o Azure DevOps con lo stesso accesso dal browser.
4. Premi il pulsante di registrazione quando inizia una riunione e fermalo alla fine. Gli appunti compaiono nella riunione, in Riunioni; fai domande in Chiedi alle tue riunioni.

Collegare un assistente AI

Appunto può fare da server MCP locale, così un assistente AI può usare le tue riunioni e le tue cose da fare. Apri MCP nella barra laterale e accendi il server, poi:

• Claude Desktop: premi Collega e riavvia Claude Desktop. Appunto si aggiunge a claude_desktop_config.json e tiene una copia del file precedente.
• Claude Code: copia il comando mostrato nella pagina ed eseguilo in un terminale. È simile a claude mcp add --transport stdio --scope user appunto -- /percorso/di/Appunto --mcp.
• Codex: copia il blocco mostrato nella pagina in ~/.codex/config.toml:

  [mcp_servers.appunto]
  command = "/percorso/di/Appunto"
  args = ["--mcp"]

• Un altro assistente: usa il JSON mostrato in Un’altra AI (mcpServers.appunto con command e args: ["--mcp"]).

La pagina mostra sempre il percorso reale della tua app Appunto. In Cosa può vedere scegli cosa condividere: riunioni e decisioni, trascrizioni complete, cose da fare, nomi dei partecipanti. In Cosa può fare scegli se può solo leggere o anche aggiungere e spuntare cose da fare. Le modifiche valgono subito, senza riavviare l'assistente. La pagina elenca le richieste recenti dell'assistente. Esporta tutto salva ogni riunione in Markdown più un file JSON in Documenti/Appunto.

Compilare dal codice

Serve solo se vuoi modificare il codice. Per usare l'app e basta, vai su Scarica.

Requisiti: Node.js 24, Rust (stable, 1.88+), CMake, Git e un compilatore C/C++.

• Pacchetti in più per Linux: libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev libasound2-dev libssl-dev pkg-config (+ patchelf per AppImage).
• Windows: Visual Studio 2022 Build Tools con il carico di lavoro C++.

npm install

# Compila una volta i motori inclusi per la tua piattaforma (voce, AI locale)
scripts/build-whisper.sh          # macOS / Linux
pwsh scripts/build-whisper.ps1    # Windows
scripts/build-llama.sh            # macOS / Linux
pwsh scripts/build-llama.ps1      # Windows

npm run tauri dev                 # avvia in sviluppo
npm run tauri build               # crea gli installer in src-tauri/target/release/bundle

build-whisper compila una versione fissata di whisper.cpp (whisper-server, che resta acceso mentre registri così il modello vocale si carica una volta sola) e build-llama una versione fissata di llama.cpp (llama-server), entrambi con Metal su macOS e CPU altrove, in src-tauri/binaries/ (ignorata da git). Senza di loro l'app si compila lo stesso, ma la registrazione (whisper) o il modello AI locale (llama-server) sono disattivati.

Variabili per sviluppatori: APPUNTO_WHISPER_SERVER_BIN=/percorso/di/whisper-server, APPUNTO_WHISPER_MODEL=/percorso/di/model.bin, APPUNTO_LLAMA_BIN=/percorso/di/llama-server e APPUNTO_LLAMA_MODEL=/percorso/di/model.gguf (qualsiasi modello chat GGUF).

Test

npx ng test --watch=false
cd src-tauri && cargo test --lib

I test Rust coprono i flussi OAuth e MCP di ogni connettore contro server finti locali, il download del modello (ripresa, checksum, annullamento), il ciclo di vita del modello locale (avvio, stato, arresto quando inattivo) contro un server finto, e la gestione di crash, timeout e riavvio del server whisper, il filtro delle allucinazioni e la rimozione dell'eco contro un server finto. Non servono rete né account.

Configurazione facoltativa in compilazione

Senza di loro quei connettori risultano non disponibili. I passi per configurarli sono in architecture.md, sezione 9.

Release

Fai il push di un tag vX.Y.Z. Il workflow Release compila il motore vocale e gli installer per macOS (arm64, x64), Windows (x64) e Linux (x64, arm64) e crea una bozza di GitHub Release. I secret per la firma del codice sono facoltativi e sono elencati in .github/workflows/release.yml.

Documentazione e licenza

architecture.md nel codice sorgente descrive i processi, i comandi e gli eventi IPC, lo schema del database, i connettori e il modello di sicurezza. Appunto è distribuito con licenza MIT.

What it does

Appunto records the audio of any call (Google Meet, Zoom, Teams, …) straight from your computer, transcribes it locally with whisper.cpp, and turns it into a searchable memory:

• Meeting list with the decisions, action items, Jira tickets, issues and pull requests of each meeting; filter by month and year, delete one or all at once.
• To-dos (“Da fare”): every action item heard in a meeting becomes a to-do once, with a link back to the moment it was said. Tick them off, add your own, set who and when, and see the week's progress.
• Ask about your meetings: “What did we decide about PROJ-142?” — answers quote the exact moment, with a link to the transcript.
• MCP (the tab to connect an AI; optional, off by default): Claude Desktop, Claude Code, Codex or any MCP client can search your meetings, read transcripts and manage your to-dos. You choose what it sees; see Connect an AI assistant.
• Connected tools (optional): Jira / Confluence (Atlassian), GitHub, GitLab and Azure DevOps through their official MCP servers, with a browser sign-in — no tokens to copy.
• Who was in the call (optional): sign in with Google once and each recording gets the title of its Calendar event and the names of the people invited and, for Google Meet calls, of those who actually joined — without any bot in the meeting. Names can also be added by hand.
• Speakers named automatically (macOS, optional): while recording, the app reads the open Google Meet tab in Chrome, Edge, Brave or Safari (Arc: experimental) — the participant list and, when Meet's captions (CC) are on, who is talking — and puts the right name on “Speaker 1”, “Speaker 2”, … No extension, no bot, no Google sign-in; it needs a one-time browser setting (see First start).
• Your choice of AI: Google Gemini with a free API key (the app picks the model for you and switches automatically when one hits its daily limit), your ChatGPT Plus/Pro plan (sign in, no API key), OpenAI, Anthropic or OpenRouter.
• Setup mission: Home lists what is still missing (microphone, call audio, speech model, Meet names) with a Fix button and a step-by-step guide; each step turns green by itself once it works.
• Updates itself: when a new version is out, the app offers Update and restart; your meetings, settings and macOS permissions stay.
• English and Italian interface; transcription in 12 languages.

Privacy

• Audio never leaves your computer. Recordings are transcribed locally and stored in a local SQLite database.
• When you ask a question, only the few transcript snippets relevant to it are sent to the AI provider you chose.
• Connected tools receive only identifiers (e.g. PROJ-142, owner/repo#12), never transcript text. Google receives only the time window of a recording and the meeting code; participant names stay in the local database.
• Reading the Google Meet tab (macOS) happens on your computer and only while recording: the app reads participant names and who was talking when; caption text is never read or stored, and nothing is sent anywhere. With Recognize voices on, a voice named this way is saved as a voice print so later meetings recognize the person; voices can be deleted any time in Settings.
• The browser setting Allow JavaScript from Apple Events lets every app you allow under Privacy & Security → Automation run scripts in your browser tabs, not just Appunto. Allow only apps you trust, and turn the setting off again if you stop using the feature.
• API keys and sign-in tokens are stored on your computer in secrets.json inside the app data folder, readable only by your user account. They are not encrypted, so anyone (or any program) running as your user can read them.
• MCP is off until you turn it on. Appunto opens no network port for it: the assistant on your computer starts Appunto and reads through it. Whatever the assistant reads leaves your computer and goes to that assistant's provider (Anthropic, OpenAI, …), so share only what you are comfortable with. Voice prints and audio are never shared.
• Recording other people may require their consent where you live — tell participants when you record.

Gemini free tier: Google may use free-tier prompts and responses to improve its products. For confidential meetings, enable billing on your key or pick another provider.

The full policy is on the Privacy page.

Install

No terminal, no setup: download one file, install it like any other app, open it. Get the file for your computer and the install steps on the Download page.

First start

• The app downloads its speech model once (about 874 MB). Keep it open until the progress bar finishes. The file is checked against a checksum and stays on your computer.
• Questions about your meetings are answered by a model built into the app (“Local (private)”): press Download on its card (about 2.7 GB, once) and nothing leaves your computer. Or pick a cloud provider in Settings instead.
• macOS: the Setup mission on Home lists what is still missing. Allow shows the macOS prompt for the Microphone and Screen & System Audio Recording; Fix opens a step-by-step guide with a button to the right System Settings page. After Screen & System Audio Recording macOS may ask you to quit and reopen the app. The same list is always in Settings.
• macOS, speaker names from Google Meet (optional):
  1. In the browser you use for Meet, turn on Allow JavaScript from Apple Events: Chrome, Edge, Brave — View → Developer; Safari — Develop menu (show it with Safari → Settings → Advanced → Show features for web developers).
  2. At the first recording with the browser open, macOS asks whether Appunto may control it: click Allow (later: System Settings → Privacy & Security → Automation).
  3. In the Meet call, turn on captions (CC) so the voices can be named; the participant list is read without them.
  In the Setup mission, Know who is speaking → Fix → Check now tests your browser right away (macOS asks for the Automation permission then) and tells you which step is missing. The Meet browser extension remains an alternative for the participant list only (any OS with Chrome).
• Windows: nothing to set up. If no microphone is heard, check Settings → Privacy & security → Microphone and allow desktop apps.
• Linux: needs PulseAudio or PipeWire, which most desktops already have.

Getting started

1. Settings → Connections: every service is one card with a Connect button that opens a sign-in in your browser; there are no API keys or tokens to find. Under AI assistant, choose Continue with ChatGPT (ChatGPT Plus/Pro plan) or Sign in with OpenRouter, or the built-in Local (private) model (free, nothing leaves your computer: download it once). Another free choice is Google Gemini, under Advanced → Use your own key: create a free key at aistudio.google.com/apikey and paste it. The app uses Gemini 3.5 Flash-Lite, then Gemini 3.1 Flash-Lite, then Gemma 4 when a model fails or reaches its free daily limit (about 1,000 questions a day before Gemma). OpenAI and Anthropic also take a key there. A Claude subscription cannot be used: Anthropic only allows API keys in third-party apps.
2. Settings → Language: choose the app's language and the language spoken in your meetings.
3. Optional — Settings → Connections → Your tools: connect Jira, GitHub, GitLab or Azure DevOps with the same browser sign-in.
4. Press the record button when a meeting starts and stop it at the end. Notes appear on the meeting, under Meetings; ask questions in Ask about your meetings.

Connect an AI assistant

Appunto can act as a local MCP server, so an AI assistant can use your meetings and to-dos. Open MCP in the sidebar and switch the server on, then:

• Claude Desktop: press Connect and restart Claude Desktop. Appunto adds itself to claude_desktop_config.json and keeps a backup of the previous file.
• Claude Code: copy the command shown on the page and run it in a terminal. It looks like claude mcp add --transport stdio --scope user appunto -- /path/to/Appunto --mcp.
• Codex: copy the block shown on the page into ~/.codex/config.toml:

  [mcp_servers.appunto]
  command = "/path/to/Appunto"
  args = ["--mcp"]

• Another assistant: use the JSON shown under Another AI (mcpServers.appunto with command and args: ["--mcp"]).

The page always shows the real path of your Appunto app. Under What it can see choose what to share: meetings and decisions, full transcripts, to-dos, participant names. Under What it can do, choose between read only or also adding and ticking off to-dos. Changes apply right away, with no need to restart the assistant. The page lists the assistant's recent requests. Export everything saves every meeting as Markdown plus a JSON file in Documents/Appunto.

Build from source

Only needed if you want to change the code. To just use the app, follow Download.

Requirements: Node.js 24, Rust (stable, 1.88+), CMake, Git and a C/C++ compiler.

• Linux extra packages: libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev libasound2-dev libssl-dev pkg-config (+ patchelf for AppImage).
• Windows: Visual Studio 2022 Build Tools with the C++ workload.

npm install

# Build the bundled engines once for your platform (speech, local AI)
scripts/build-whisper.sh          # macOS / Linux
pwsh scripts/build-whisper.ps1    # Windows
scripts/build-llama.sh            # macOS / Linux
pwsh scripts/build-llama.ps1      # Windows

npm run tauri dev                 # run in development
npm run tauri build               # create installers in src-tauri/target/release/bundle

build-whisper compiles a pinned whisper.cpp release (whisper-server, kept running while you record so the speech model is loaded once) and build-llama a pinned llama.cpp release (llama-server), both with Metal on macOS and CPU elsewhere, into src-tauri/binaries/ (git-ignored). Without them the app still builds, but recording (whisper) or the local AI model (llama-server) is disabled.

Developer overrides: APPUNTO_WHISPER_SERVER_BIN=/path/to/whisper-server, APPUNTO_WHISPER_MODEL=/path/to/model.bin, APPUNTO_LLAMA_BIN=/path/to/llama-server and APPUNTO_LLAMA_MODEL=/path/to/model.gguf (any GGUF chat model).

Tests

npx ng test --watch=false
cd src-tauri && cargo test --lib

The Rust tests include the OAuth and MCP flows of every connector against local fake servers, the model download (resume, checksum, cancel), the local model's sidecar lifecycle (start, health, idle stop) against a fake server, and the whisper server's crash/timeout/restart handling, hallucination filter and echo dedupe against a fake server — no network or accounts needed.

Optional build-time configuration

Without them those connectors are shown as unavailable. The setup steps are in architecture.md, section 9.

Releases

Push a tag vX.Y.Z. The Release workflow builds the speech engine and the installers for macOS (arm64, x64), Windows (x64) and Linux (x64, arm64) and creates a draft GitHub Release. Code-signing secrets are optional and listed in .github/workflows/release.yml.

Documentation and license

architecture.md in the source code describes the processes, IPC commands and events, database schema, connectors and security model. Appunto is released under the MIT License.