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.
import_audio_file	Queue an audio or video file for processing. Two modes: meeting (default) runs full diarization + AI enrichment; transcription returns word-level timestamps with raw text. The server notifies when complete.
get_import_status	Check import outcomes and queue status. Call after a notification to see what happened. Includes transcription-mode results in recentTranscriptions.
get_transcription	Retrieve word-level timestamps from a completed transcription-mode import. Returns utterances with per-word start/end times and confidence scores.
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
File import succeeded	Enrichment completes (no overlay — notifies immediately)	get_import_status for outcome
Transcription completed	ASR-only processing finishes	get_import_status → recentTranscriptions for ID
File import rejected	Billing cap reached before processing	get_import_status for reason
File import failed	Transcription or enrichment errored	get_import_status 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?} — new or updated meeting ready
• transcriptions[] — {filename, resultId} — transcription-mode import completed (use get_transcription 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. The import_audio_file tool accepts an optional mode parameter:

Mode	Pipeline	Output	Network
meeting	ASR → diarization → AI speaker attribution → summary	Full meeting with speakers, summary, action items	Yes
transcription	ASR only	Word-level timestamps with raw text (filler words preserved)	No

Meeting mode (default) runs the full pipeline — the same one used for live meetings. The file is transcribed on-device, speakers are identified, then AI enrichment adds a summary and action items.

Transcription mode runs only the on-device ASR engine. It returns word-level timestamps at 80ms resolution with the raw spoken text preserved (including filler words like “um” and “uh”). No speaker identification, no AI cleanup, no network call. Use this for video editing (cutting filler words), subtitle generation, or any task that needs precise word-to-audio alignment.

Meeting mode workflow

1. Call import_audio_file with the path — mode defaults to "meeting"
2. Wait for a notifications/resources/list_changed notification, then call get_import_status
3. On success, use get_meeting_data with the meeting ID to access the transcript and summary

Transcription mode workflow

1. Call import_audio_file with mode: "transcription"
2. Wait for a notification, then call get_import_status — check the recentTranscriptions array for the result ID
3. Call get_transcription with the result ID to retrieve word timestamps

The transcription result includes three levels of detail:

• text — full transcript as a single string (for quick content reading)
• utterances[] — speech segments separated by natural pauses (>1 second gaps), each with text, start, end, and a words array
• utterances[].words[] — individual words with word, start, end, and confidence

{
	"filename": "interview.m4a",
	"durationSeconds": 1823.5,
	"createdAt": "2026-03-29T10:00:00Z",
	"text": "hello um welcome to the show today...",
	"utterances": [
		{
			"text": "hello um welcome to the show",
			"start": 0.24,
			"end": 2.8,
			"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 }
			]
		}
	]
}

Transcription results are stored for 24 hours. No meeting is created in your library — if you want a full meeting record with speakers and a summary, use meeting mode instead.

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 accessible to the MimicScribe app — files on the local disk work; files on network volumes may not.

Processing status values (meeting mode only — transcription mode results appear in recentTranscriptions):

Status	Meaning
pending_enrichment	Transcribed with speaker segments, waiting for Gemini summary
processing	Gemini enrichment in progress
completed	Fully processed — transcript, speakers, summary, and action items available
billing_blocked	Transcript saved but Gemini enrichment requires an active subscription

Multiple files can be queued at once — they process sequentially. 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:

1. Call get_meeting_context to check for existing content (could be user prep notes or another agent’s context)
2. Research attendees (from a CRM, email threads, past MimicScribe meetings, etc.)
3. Optionally call list_templates and pick a template_id matching the meeting type (sales call, standup, interview, customer check-in, discovery, presentation, or a user-custom template)
4. Call set_meeting_context — preserve any existing content verbatim at the top, append your additions below, and pass template_id to shape the post-meeting summary
5. When the user starts their next meeting, MimicScribe automatically injects the context and uses the template’s section structure for 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.

Template semantics on re-writes: When you omit template_id, any previously-selected template is preserved — a safe default for get → append → set flows. Pass an empty string to explicitly clear the template and fall back to the global default summary format. Passing an unknown UUID returns an error; always source ids from list_templates rather than hardcoding. A user who taps a template chip in the app is always respected at meeting start — agent-staged ids 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:

1. Call set_context_source with operation: "upsert", a title, source_type, and content
2. The source appears immediately in the response. Processing (chunking + embedding) takes 5-15 seconds.
3. 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.