Integrations

MimicScribe connects to AI agents through an MCP server — agents can search your meeting history, pull action items, set up context for upcoming meetings, and more. Configured in Settings > Integrations.

Quick setup: If you’re already using an AI agent like Claude Code, Gemini CLI, or Codex, you can ask it to set this up for you. Try: “Set up the MimicScribe MCP server. Read the docs at mimicscribe.app/llms-full.txt for instructions.” Your agent will read this page and configure everything automatically.

MCP Server

The Model Context Protocol (MCP) server lets AI agents interact with your meeting data directly. Agents can search past meetings, pull action items, prepare context for upcoming meetings, and more — all without you copying and pasting.

What can agents do with it?

After meetings — ask your agent to work with what was discussed:

“What did we decide about pricing in yesterday’s meeting?”
“List all my action items from this week”
“Write a follow-up email based on the client call from Monday”
“Create Jira tickets for the action items from the planning meeting”
“Draft a project status update from my meetings this past week”

Import recordings — have your agent transcribe files from disk:

“Transcribe the recording from yesterday’s client call — it’s in ~/Downloads/client-call.m4a”
“Import all the audio files in ~/Meetings/ and summarize what was discussed”
“Get word-level timestamps for this podcast episode so I can cut the filler words”

Before meetings — have your agent prepare context:

“Prep my next meeting — look up the attendees in our CRM, set the context, and pick the right summary template”
“I have a meeting with jane@acme.com in 30 minutes. Look up our past meetings with anyone from Acme, check their website, and set the context in MimicScribe.”
“Add our product pricing page as a reference source so the assistant has it during sales calls”
“Add our company’s org chart and key terminology as reference context for all my meetings”

Available tools

Tool	Purpose
`search_meetings`	Search by keyword or list recent meetings. Returns summaries and metadata.
`get_meeting_data`	Get detailed data for a specific meeting — summary, transcript, action items, or all of them.
`get_action_items`	Pull action items across multiple meetings, filtered by date or assignee.
`get_meeting_context`	Read the current meeting prep state — context text and the selected summary template, from any source (user input or prior agent writes). Agents must check this before setting context to avoid overwriting the user’s notes.
`set_meeting_context`	Set context for an upcoming meeting — attendee roles, goals, background, deal info. Overwrites all existing context, including user-typed notes. Always call `get_meeting_context` first and preserve existing content. Expires after a configurable TTL (default: 3 hours). Optional `template_id` also selects the summary template governing the post-meeting output.
`list_templates`	List every summary template — built-in (Sales, Discovery, Standup, Interview, Customer, Presenting) and user-custom — with full section-by-section summary instructions. Call this first if you want to pick a `template_id` to pass to `set_meeting_context`.
`transcribe_with_speakers`	Queue an audio or video file for ASR + on-device diarization. Returns anonymous speaker IDs (“Speaker 1”, “Speaker 2”) with word-level timestamps and preserved filler words. No Gemini calls, no AI cap. Use when you need raw timestamped words and speaker separation without real names.
`transcribe_attributed`	Queue an audio or video file for AI speaker attribution. Returns a compact transcript with real speaker names (from voice profiles or transcript context) and an `attributionSource` field per speaker. No summary, no action items, not saved to the library. Use when you want a polished script without polluting the user’s meeting history.
`import_meeting`	Queue an audio or video file for full meeting import. Runs the complete pipeline (diarization + attribution + summary + action items) and persists the result to the user’s library. Optional `offline: true` skips Gemini and saves as offline mode — the user can backfill via “Generate Summary Now”. Use when the user wants this saved as a meeting.
`get_import_status`	Check the status of recent file imports. Returns a unified `recentResults` array with `type` discriminator (`transcription` / `attributed_transcript` / `meeting`), plus `recentFailures` and `recentRejections`. Call after a notification to see what happened.
`get_transcription`	Retrieve a completed `transcribe_with_speakers` result by id — diarized segments with anonymous speaker IDs and per-word timestamps.
`get_attributed_transcript`	Retrieve a completed `transcribe_attributed` result by id — segment-level transcript with real speaker names and `attributionSource` provenance.
`set_context_source`	Manage persistent reference documents — add, replace, or remove sources (URLs, files, or raw text) that are semantically retrieved during meetings. Sources are chunked, embedded, and matched to what’s being discussed.

Resources

The server also exposes meetings as MCP resources. Calling resources/list returns the 20 most recent meetings as meeting://{id} URIs. Calling resources/read with a URI returns the meeting content:

meeting://{id} — full transcript as markdown
meeting://{id}/summary — AI-generated summary
meeting://{id}/action-items — structured action items as JSON

Resources are read-only. Most agents will find the tools (search_meetings, get_meeting_data) more convenient, but resources provide an alternative access pattern for MCP clients that prefer it.

Notifications

The MCP server sends notifications/resources/list_changed when meetings change — new meetings ready, imports completed or failed, meetings deleted or merged. After receiving a notification, agents should determine what changed:

For imports: call get_import_status to see outcomes (success with meeting ID, rejected, or failed with reason)
For everything else: call search_meetings to see the current meeting list, or resources/list to re-fetch resources

The notification includes structured details in its params for MCP clients that support reading them. Not all clients do — the tool-based approach above works universally.

When notifications fire:

Event	When	How to check
Live meeting ready	User closes the summary view (after any speaker corrections)	`search_meetings` to find new meeting
Meeting import succeeded	`import_meeting` enrichment completes	`get_import_status` → `recentResults` (type==“meeting”) → `get_meeting_data`
Diarized transcript ready	`transcribe_with_speakers` finishes	`get_import_status` → `recentResults` (type==“transcription”) → `get_transcription`
Attributed transcript ready	`transcribe_attributed` finishes	`get_import_status` → `recentResults` (type==“attributed_transcript”) → `get_attributed_transcript`
Import rejected	Billing cap reached before processing	`get_import_status` → `recentRejections` for reason
Import failed	Transcription or enrichment errored	`get_import_status` → `recentFailures` for reason
Meeting deleted	User deletes a meeting	`search_meetings` to see updated list
Meetings merged	User merges multiple meetings	`search_meetings` to see updated list

Notification params (for custom MCP clients): The list_changed notification carries optional params with arrays describing what changed. Presence of each key indicates the event type:

meetings[] — {id, title, sourceFilename?} — meeting ready (live recording or import_meeting completion)
transcriptions[] — {filename, resultId} — transcribe_with_speakers completed (use get_transcription with resultId)
attributedTranscripts[] — {filename, resultId} — transcribe_attributed completed (use get_attributed_transcript with resultId)
rejections[] — {filename, reason} — import blocked before processing
failures[] — {filename, reason} — import errored during processing
deleted[] — {id, title} — meeting removed
merged[] — {id, title, replacedIds[]} — meetings combined into one

Standard MCP clients that ignore notification params can use the tool-based fallback above. These params are an optimization for clients that can parse them.

File import

Agents can import audio and video files for processing. The MimicScribe app must be running — the MCP server queues the request, and the app picks it up. Three tools cover three distinct use cases:

Tool	Pipeline	Library	Gemini	Use for
`transcribe_with_speakers`	ASR + on-device diarization (anonymous IDs, fillers preserved)	No	No	Raw timestamped words with speaker separation (subtitle gen, alignment, agent QA)
`transcribe_attributed`	ASR + diarization + AI speaker attribution (no summary)	No	Yes	Polished named-speaker transcript without saving to the library
`import_meeting`	Full pipeline + persisted to library (or `offline: true` to defer)	Yes	Yes*	Anything the user wants saved as a meeting in their MimicScribe library

* import_meeting with offline: true skips Gemini and saves the meeting in offline mode — the user can backfill the summary later via “Generate Summary Now”. Use this for the cap-exhaustion recovery path.

Each write tool returns immediately with { status: "queued", requestId, filename } (plus offline echo for import_meeting). The app processes the file asynchronously, sends a notifications/resources/list_changed when complete, and exposes the result through get_import_status. Match queued requests to results by filename + createdAt ordering.

Workflow: `transcribe_with_speakers`

Call transcribe_with_speakers with the path
On notification (or polling), call get_import_status — look in recentResults for type=="transcription"
Call get_transcription with the resultId to retrieve the diarized transcript

Result shape:

{
	"filename": "interview.m4a",
	"durationSeconds": 1823.5,
	"createdAt": "2026-03-29T10:00:00Z",
	"text": "hello um welcome to the show today...",
	"speakers": [
		{ "id": "Speaker 1", "totalDurationSeconds": 1102.3 },
		{ "id": "Speaker 2", "totalDurationSeconds": 721.2 }
	],
	"segments": [
		{
			"speakerId": "Speaker 1",
			"start": 0.24,
			"end": 2.8,
			"text": "hello um welcome to the show",
			"words": [
				{ "word": "hello", "start": 0.24, "end": 0.56, "confidence": 0.97 },
				{ "word": "um", "start": 0.64, "end": 0.88, "confidence": 0.85 },
				{ "word": "welcome", "start": 1.04, "end": 1.52, "confidence": 0.99 }
			]
		}
	]
}

Speaker IDs are always anonymous ("Speaker 1", "Speaker 2", …) — they are never real names. Filler words (um, uh, like) are preserved. Payload is roughly 80–120 KB per hour of audio.

Workflow: `transcribe_attributed`

Call transcribe_attributed with the path
On notification (or polling), call get_import_status — look for type=="attributed_transcript"
Call get_attributed_transcript with the resultId

Result shape:

{
	"filename": "standup.mp4",
	"durationSeconds": 940.2,
	"createdAt": "2026-03-29T10:15:00Z",
	"speakers": [
		{ "name": "Alice", "attributionSource": "voiceProfile", "totalDurationSeconds": 412.6 },
		{ "name": "Bob", "attributionSource": "transcript", "totalDurationSeconds": 327.4 },
		{ "name": "Speaker C", "attributionSource": "fallback", "totalDurationSeconds": 200.2 }
	],
	"transcript": [
		{ "speaker": "Alice", "start": 0.5, "end": 12.3, "text": "Hi everyone — let's start with the deploy status." }
	]
}

attributionSource reports how each speaker name was derived:

voiceProfile — matched a registered voice profile in MimicScribe (highest confidence)
transcript — name inferred from speech context (someone addressed by name)
fallback — no identification possible; the label is generic (e.g., “Speaker C”)

Always surface attributionSource to users for fallback speakers — those names are not real identifications. Filler words are stripped (post-processed by the V6_SEAL attribution pipeline). Payload is roughly 8–12 KB per hour, safe to pass through agent context even for multi-hour recordings.

Workflow: `import_meeting`

Call import_meeting with the path (and offline: true if the user wants to skip Gemini)
On notification (or polling), call get_import_status — look for type=="meeting"
Call get_meeting_data with the meetingId to read the summary, transcript, and action items

import_meeting with offline: false runs the full pipeline (the same one used for live meetings) and counts against the AI cap. With offline: true, the meeting saves with diarization only and skips Gemini — useful when the cap is exhausted or the user has opted out of AI for this meeting. The user can backfill the summary later by tapping “Generate Summary Now” in the app.

Result lifecycle

transcribe_with_speakers and transcribe_attributed results are ephemeral — stored for 24 hours, then garbage-collected. No meeting is created in the user’s library; if a “not found” error comes back from get_transcription or get_attributed_transcript, the result has expired and the agent should re-queue with the original write tool.

import_meeting results are permanent — the meeting lives in the user’s library and is searchable via search_meetings. Local Mode meetings are hidden from MCP read tools by default unless the user enables “Allow connected AI tools to read Local Mode meetings” in Settings > Integrations.

Billing & caps

On the Free tier, all MCP tool calls share one cap of 25 calls per day (paid plans are unlimited). Within that, the per-feature Gemini limits below also apply:

Tool	Counts against AI cap?	Free-tier daily limit (shared bucket)
`transcribe_with_speakers`	No — on-device only	No daily cap
`transcribe_attributed`	Yes — one Gemini call	100/day shared with `import_meeting`
`import_meeting`	Yes (attribution + summary)	100/day shared with `transcribe_attributed`
`import_meeting` (offline)	No — Gemini skipped	No AI-cap charge

If import_meeting is rejected due to a cap, retry the same path with offline: true — the meeting saves without Gemini and the user can backfill the summary later.

Shared details

Supported formats: M4A, WAV, MP3, MP4, MOV, and any format readable by AVFoundation. Minimum 3 seconds, maximum 4 hours of audio. The file path must be absolute and accessible to the MimicScribe app — files on the local disk work; files on network volumes may not.

Meeting processing status values (import_meeting only — the two transcription paths complete in one step):

Status	Meaning
`pending_enrichment`	Diarized; Gemini summary pending
`processing`	Gemini enrichment in progress
`completed`	Fully processed — transcript, speakers, summary, and action items available
`offline_mode`	Saved without AI — user can backfill via “Generate Summary Now” in the app
`billing_blocked`	Transcript saved but Gemini enrichment requires an active subscription

Queueing: Multiple files can be queued at once — they process sequentially across all three tools (only one Neural Engine task runs at a time). If a meeting is being recorded, queued imports pause and resume automatically when the meeting ends. Agents can poll get_import_status if they don’t support notifications.

Meeting prep

Agents can set context before a meeting starts, enriching the AI assistant with background information it wouldn’t otherwise have. Agent-set context and user-typed prep notes (from the app’s “Prepare for Meeting” feature) share the same store — both are visible to agents and to the user.

A typical agent workflow:

Call get_meeting_context to check for existing content (could be user prep notes or another agent’s context)
Research attendees (from a CRM, email threads, past MimicScribe meetings, etc.)
To shape the post-meeting summary, either call list_templates and pick a template_id (a saved summary view — e.g. Walkthrough or By Participant), or pass summary_format free-text rules to shape this one meeting without a saved view
Call set_meeting_context — preserve any existing content verbatim at the top, append your additions below, and pass template_id or summary_format to shape the summary
When the user starts their next meeting, MimicScribe automatically injects the context and applies the chosen view (or formatting rules) to the summary

Important: set_meeting_context overwrites the entire context slot. If the user has already typed prep notes in the app and your agent doesn’t call get_meeting_context first, those notes will be lost. Agents should always read before writing.

View and format semantics on re-writes: When you omit template_id (or summary_format), any previously-staged value is preserved — a safe default for get → append → set flows. Pass an empty string to explicitly clear it and fall back to the global default. A template_id that isn’t a known view returns an error; always source ids from list_templates rather than hardcoding. If both template_id and summary_format are set, the saved view wins. A view the user picks in the app is always respected at meeting start — agent-staged values only apply when the user hasn’t made a pick.

Context set by agents expires after 3 hours by default (configurable via ttl_minutes, max 24 hours). Prep notes saved by the user via the app do not expire. The maximum context size is 50,000 characters. Only one slot of context exists at a time — setting new context overwrites whatever was there. The context is cleared when a meeting ends and won’t carry over to subsequent meetings.

Reference documents

Agents can manage persistent reference documents that are semantically retrieved during meetings. Unlike meeting prep context (which is consumed once and expires), reference documents persist across all meetings and are automatically matched to what’s being discussed.

Use set_context_source to add URLs, local files, or raw text as reference sources. The app chunks, embeds, and indexes each source — during meetings, the most relevant chunks are injected into AI prompts based on the conversation.

A typical agent workflow:

Call set_context_source with operation: "upsert", a title, source_type, and content
The source appears immediately in the response. Processing (chunking + embedding) takes 5-15 seconds.
Call with operation: "list" to check status — look for status: "ready"

Source types:

Type	Content
`url`	A web page URL — the app fetches and processes the page content
`file`	An absolute local file path — the app reads and processes the file
`text`	Raw text provided inline — best for company info, org charts, or content from any source

What makes good reference context: company background, product documentation, org charts, competitive landscape, key terminology glossaries, project briefs, or prior meeting summaries. Structure text with markdown headers — headers become the semantic search keys, so make them descriptive.

Sources are managed by title (case-insensitive). Upserting with an existing title replaces that source. Maximum 10 sources, up to 200,000 characters each. Sources added through the app UI can be viewed by agents but can only be removed through the app.

Reference documents vs. prep notes: Use set_context_source for persistent material reused across many meetings (product docs, org charts, glossaries). Use set_meeting_context for per-meeting prep notes that should expire (today’s attendees, agenda, deal stage). For best results, use both.

Configuration

Open Settings > Integrations in MimicScribe and click Copy Configuration to get the MCP config JSON for your agent client. The configuration looks like this:

{
	"mcpServers": {
		"mimicscribe": {
			"command": "/Applications/MimicScribe.app/Contents/MacOS/mimicscribe",
			"args": ["--mcp-server"]
		}
	}
}

CLI agents can be configured with a single command:

Agent	Command
Claude Code	`claude mcp add mimicscribe -- /Applications/MimicScribe.app/Contents/MacOS/mimicscribe --mcp-server`
Gemini CLI	`gemini mcp add mimicscribe /Applications/MimicScribe.app/Contents/MacOS/mimicscribe --mcp-server`
Codex CLI	`codex mcp add mimicscribe -- /Applications/MimicScribe.app/Contents/MacOS/mimicscribe --mcp-server`

For Gemini CLI, if the server shows as “Disconnected,” run gemini trust in your working directory.

Codex also supports adding to ~/.codex/config.toml:

[mcp_servers.mimicscribe]
command = "/Applications/MimicScribe.app/Contents/MacOS/mimicscribe"
args = ["--mcp-server"]

Desktop and IDE agents — paste the JSON config above into the appropriate settings file:

Agent	Config location
Claude Desktop	`claude_desktop_config.json` (Claude menu > Settings > Developer > Edit Config)
Cursor	`~/.cursor/mcp.json` or `.cursor/mcp.json` in your project
Windsurf	`~/.codeium/windsurf/mcp_config.json` or Windsurf Settings > Cascade > MCP Servers
Zed	`~/.config/zed/settings.json` (use key `"context_servers"` instead of `"mcpServers"`)

VS Code (GitHub Copilot) uses a slightly different format in .vscode/mcp.json:

{
	"servers": {
		"mimicscribe": {
			"type": "stdio",
			"command": "/Applications/MimicScribe.app/Contents/MacOS/mimicscribe",
			"args": ["--mcp-server"]
		}
	}
}

Requires VS Code 1.99+ and Copilot Agent Mode.

Any other MCP client that supports stdio transport will work — use the JSON config from Settings > Integrations.

Remote access via SSH

The MCP server uses stdio (standard input/output), which means it runs locally by default. If you need to access your meetings from another machine — for example, from a cloud-hosted agent or a remote workstation — you can use SSH:

ssh user@your-mac.local "/Applications/MimicScribe.app/Contents/MacOS/mimicscribe --mcp-server"

Configure your MCP client to use this SSH command instead of the local binary path. The SSH connection handles authentication and encryption — no additional security configuration is needed.

Requirements: Enable Remote Login on your Mac (System Settings > General > Sharing > Remote Login). The MimicScribe app must be installed at the path specified in the command.

Troubleshooting MCP

Agent can’t connect or shows “server exited”: MimicScribe needs to have been launched at least once to create its database. Open the app, then restart your agent client.

Agent can’t find any meetings: Make sure you’ve recorded at least one meeting. The MCP server reads from the same database as the app.

Agent shows stale data: The MCP server reads the database directly, so data is always current. For live meetings, the server waits to notify agents until you close the summary view — so if you’re still reviewing or correcting speakers, the agent won’t have the latest version yet. Close the summary when you’re done to trigger the notification.

Wrong binary path: If you moved MimicScribe from /Applications/, update the command path in your MCP configuration. You can find the correct path in Settings > Integrations.