Search and read locally-recorded meeting transcripts over stdio. Read-only, no network.
Call Copilot is an MCP server that provides local search and reading of meeting transcripts over stdio. It is read-only and does not use any network access. The server’s scope centers on working with locally recorded audio and speech-to-text transcription.
🛠️ Key Features
Local-first: search and read locally-recorded meeting transcripts via stdio
Read-only behavior
No network access
Topics include audio, cli, faster-whisper, offline, macos, and whisper
🚀 Use Cases
Transcribe meetings recorded locally
Search and review meeting transcripts from a terminal workflow
Use offline speech-to-text on stored audio recordings
⚡ Developer Benefits
stdio-based integration for terminal and tooling
Deterministic, local processing with no network dependency
Alignment with common local transcription tooling (e.g., faster-whisper, whisper)
⚠️ Limitations
Read-only access (no modifications implied)
Only supports locally available transcripts and recordings (offline/local-first only)
One thing. Done really well. Record meetings. Save transcripts. Don't break audio.
Call Copilot is a terminal command (rec) that records your meeting audio and, when you
stop it, transcribes locally and saves a clean markdown transcript. Everything runs on
your machine — no cloud, no API keys, no account. Audio and transcripts never leave the
computer.
Call Copilot demo
code
$ rec setup # one-time: verify macOS + grant capture permission
$ rec start # starts recording, you keep working
$ rec stop # stops, transcribes, saves markdown
$ rec list # shows past recordings
How it captures audio (no BlackHole, no Multi-Output Device)
By default, rec captures both the microphone (your voice) AND system audio (other
participants / anything apps play) — so a real meeting where you speak gets recorded,
not just the audio coming out of your speakers. Both sources are tapped directly via
Apple's Core Audio taps API (macOS 14.2+) using the audiotap
library. There is:
no virtual audio driver to install (no BlackHole),
no Multi-Output Device to create in Audio MIDI Setup,
no system output device to switch and restore,
and therefore no silent-recording failure that the old driver-based approaches
produce when routing breaks.
The mic and system streams are recorded as two separate WAVs (each at its own true
rate), transcribed separately, and merged into one transcript with [Mic] / [System]
labels so you can tell who said what. Want just one source? rec start --mic-only or
--system-only.
Grant capture permission (one-time, per terminal app)
macOS ties capture permission to the app you run rec from (Terminal, iTerm, Warp,
VS Code, …). You need two grants:
Microphone (your voice): System Settings → Privacy & Security → Microphone →
enable your terminal app.
System audio (grouped under Screen Recording on macOS 14.2+): System Settings →
Privacy & Security → Screen Recording → enable your terminal app, then quit and
reopen it (required for the change to take effect).
Until mic is granted, rec start records system audio only and skips the mic (it tells
you so). rec setup checks the current mic-permission status.
After rec stop (or Ctrl+C from rec start), the recording(s) are transcribed locally
with faster-whisper (CPU, int8 — no API, no
data leaves your machine) and written to a markdown transcript.
macOS 14.2 or later (Sonoma — the Core Audio process taps API rec records through
landed in 14.2). Apple Silicon recommended. Intel works.
Python 3.11+ only needed for the pipx install; the Homebrew formula brings its own.
No virtual audio driver (no BlackHole), no Multi-Output Device, no manual Audio MIDI Setup.
The tap reads system output directly. rec checks the macOS version itself and refuses to
run below 14.2 with a one-line message — you don't have to guess.
Install
Homebrew (recommended — no Python to manage):
bash
brew install AnisurRahmann/tap/call-copilot
pipx (if you prefer a plain Python install, no Homebrew):
bash
pipx install call-copilot
Either way you get a rec command on your PATH. Then jump to
One-time setup.
Using rec on a machine below macOS 14.2 prints Error: rec requires macOS 14.2 or later ... and exits — no traceback, no mystery. See
docs/HOMEBREW.md if you're setting up the tap yourself.
Recording consent & privacy
Call Copilot records audio from your meetings, which may include other participants.
Recording laws vary by jurisdiction and many require the consent of everyone being
recorded (one-party vs. all-party consent). Obtaining that consent is your
responsibility — check your local laws and your organization's policy before recording.
On the technical side, your data stays put:
Transcription runs 100% locally with faster-whisper (CPU, int8) — no API, no cloud.
Audio and transcripts never leave your machine. The only network access is the
first run of a given Whisper model, which downloads its weights from Hugging Face;
after that it's fully offline.
Recordings live under ~/.local/share/rec/sessions/ (XDG data home), outside any repo.
One-time setup
bash
rec setup
Verifies your macOS version, that the audiotap library + its bundled dylib load, saves
your config, and tells you about the one-time capture permission prompt.
Recording a meeting
bash
rec start # mic + system (default); Ctrl+C to stop & transcribe
rec start --system-only # just what apps play (not your voice)
rec start --mic-only # just your voice (not system audio)
rec list # browse past sessions
rec transcribe 2026-07-27_14-30-00 --model medium # re-transcribe at higher quality
rec diagnose 2026-07-27_14-30-00 # bundle debug info for an AI agent
By default rec start records both your microphone and system audio; the transcript
labels each line [Mic] or [System]. Use --system-only / --mic-only to narrow.
Press Ctrl+C when your meeting ends — it stops the recording and transcribes in the
same command, then prints the transcript path. One command, start to finish.
Want the old background behavior instead? rec start --detach spawns the recorder and
exits immediately; stop it later from another terminal with rec stop (or check progress
with rec status).
Tip: if a transcript comes back empty, the recording was silent — nothing was
playing, or the capture permission was revoked. rec start (and rec stop) warn you
about this immediately, and rec diagnose <session> bundles the audio levels + logs.
Use your meetings from Claude Code
rec ships an MCP server (the open protocol Claude Code, Cursor, Zed, Cline, and
other AI tools speak). Point any MCP client at your locally-recorded transcripts and ask
questions about them — answers come back with the session id cited, so you can check
the exact moment. Nothing leaves your machine: the server is strictly read-only and makes
no network calls.
bash
rec mcp install # writes the server entry into Claude Code's config
Then restart Claude Code and ask, for example:
"What did the client actually ask for on Tuesday's call?" — it searches the transcripts,
finds the line, and cites the session id (e.g. 2026-07-28_12-25-20) with a timestamp.
"List my meetings from last week with their durations." — it lists sessions, narrowing
by date.
"Show me the full transcript of the standup where we discussed the API migration." — it
finds the session, then reads the whole transcript.
Three tools are exposed: list_sessions (find a meeting by date), get_session (read a
whole transcript), and search_transcripts (find specific lines across long transcripts —
pass it keywords like pricing discount, not a full sentence). The search index lives
at ~/.local/share/rec/index.db; it builds lazily on first search and is a disposable cache
— rec index refreshes it, rec index --rebuild recreates it from scratch.
Other MCP clients (Cursor, Zed, Cline, …)
rec mcp install prints a config block that works in any MCP client. For Cursor, paste it
into .cursor/mcp.json; for Zed, into settings.json under mcp_servers. It looks like:
You can also run the server directly with rec mcp (stdio transport) if a client prefers a
raw command.
Official MCP Registry
Call Copilot is listed on the official MCP Registry
under io.github.AnisurRahmann/call-copilot. Any MCP client that speaks the registry can
discover and add it from there. The registry entry runs the server with:
bash
uvx --from call-copilot rec mcp
(The PyPI package is call-copilot; the command it installs is rec, so the server is
launched as rec mcp.)
Browser UI
rec web opens a local browser tab — a read-mostly viewer for sessions you've
already recorded, plus Start/Stop controls. It's modelled on the qBittorrent /
Transmission web UI: a loopback HTTP server serves a single-page app that drives
the same session store the CLI uses. The terminal can't show a live capture
meter, a seekable audio player beside its transcript, or a session list you can
skim in one glance — the browser can, so the UI exists for exactly those three
things.
bash
rec setup # one-time, in a terminal (the UI can't grant capture permission)
rec web # opens a browser tab at http://127.0.0.1:7717
From the tab you can browse sessions, play and seek the audio next to its
transcript, search across every transcript, and Start/Stop a recording. Start
calls the same recorder the CLI does; Stop queues transcription and the page
polls until the transcript is ready. If no config is found, the Start button
tells you to run rec setup in a terminal first.
The server binds to 127.0.0.1 only — the host is not configurable, by design
(a local tool must not become an open transcript server). --port overrides the
default port; --no-open skips the automatic browser tab.
What this is not. The UI is still not a real-time transcription
surface — the transcript arrives after Stop, exactly as in the CLI, and there
is still no cloud, no sync, and no account. Every action in the browser maps
to a command that already exists; if a feature has no CLI equivalent, it is
not in the UI.
Configuration
Stored at ~/.config/rec/config.json (XDG). Recordings live under
~/.local/share/rec/sessions/{id}/. Override the XDG roots with XDG_CONFIG_HOME /
XDG_DATA_HOME if needed.
16 kHz mono float32 is Whisper's native input format — no resampling, smallest files
(~7.5 MB/min), best transcription accuracy.
A note on sample rate (why your recordings play at the right speed)
audiotap's sample_rate parameter is not honored — the tap always delivers
audio at your output device's native rate (typically 48 kHz), regardless of what
we request. rec handles this transparently: the recorder measures the true
capture rate when the tap starts and writes the WAV at that rate (so playback
is the correct speed), and the transcriber resamples to 16 kHz before
feeding Whisper (so transcription is accurate). You don't need to do anything;
this section exists to explain the capture_sample_rate field in session.json
(which may differ from the sample_rate in your config).
A note on VAD (voice activity detection)
Transcription runs without faster-whisper's Silero VAD pre-filter by default.
The VAD is tuned for close-mic speech and aggressively rejects system-audio
capture (speakers/headphones via a tap, which has a different character) — we've
seen it discard 100% of a clearly-audible recording and return an empty
transcript. Whisper's own no_speech_threshold handles silence adequately
without that risk.
If you have clean close-mic input and want long silences skipped (faster,
cleaner output), enable it per run:
bash
rec stop --vad # VAD on for this transcription
rec transcribe <id> --vad # re-transcribe with VAD
Everything is free and open-source. Transcription runs 100% locally — no API cost, no
data leaves the machine. (The first run of a given whisper model downloads its weights
from Hugging Face; after that it's offline.)
Logging & debugging
Every activity — the audio tap lifecycle, chunk writes, transcription, formatting, each
CLI decision — is logged. Logs flow to three destinations:
Every command failure is logged at ERROR with the reason + exit code; unexpected
crashes include the full traceback.
Hand a session to an AI agent to debug
bash
rec list # find the session id
rec diagnose 2026-07-27_14-30-00 # → writes sessions/<id>/diagnose.md
rec diagnose 2026-07-27_14-30-00 --stdout | <your-ai-tool> # pipe straight to an agent
The bundle contains the session metadata, the daemon's recorder.log, the global-log
lines tagged with that session, the transcript if it exists, and the config — followed
by a debugging checklist. (rec diagnose accepts a unique prefix too, e.g. 2026-07-27.)
Note on the recording loop: the audio callback runs on Core Audio's real-time
thread and deliberately logs nothing — it copies each chunk to a queue and a writer
thread does the disk I/O. The daemon logs only at tap start/stop and on signals.
Development
You only need this if you're hacking on rec itself. End users should use the
Install commands above.
bash
git clone https://github.com/AnisurRahmann/call-copilot.git && cd call-copilot
make install # creates .venv and installs `rec` in editable mode + dev deps
make test# unit tests (offline — no audio device or model download needed)
make run # rec start, using the dev venv's rec
make install requires Python 3.11+ on your PATH (it pins python3.11 for the
venv). For everything else — releasing, the Homebrew tap, code style — see
CONTRIBUTING.md and docs/HOMEBREW.md.
