Integrations

MimicScribe can connect to AI agents and automation tools in two ways: agents pull meeting data through an MCP server, or you push meeting data to a command after reviewing it. Both are 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 query your meeting data directly. When configured, your agent can search meetings, read transcripts, get summaries, and pull action items — all without you copying and pasting.

How it works

MimicScribe runs a lightweight MCP server when launched by your agent client. It reads your meeting database in read-only mode — no data is modified, and the server only runs while your agent client is open.

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"]
    }
  }
}

This works with any MCP-compatible agent client. Here’s how to set it up in the most popular ones:

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

If the server shows as “Disconnected,” run gemini trust in your working directory.

Codex CLI (OpenAI):

codex mcp add mimicscribe -- /Applications/MimicScribe.app/Contents/MacOS/mimicscribe --mcp-server

Or add to ~/.codex/config.toml:

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

Zed: Add to ~/.config/zed/settings.json:

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

Claude Desktop: Edit claude_desktop_config.json (Claude menu > Settings > Developer > Edit Config), paste the JSON above, and restart Claude Desktop.

Cursor: Add to ~/.cursor/mcp.json (or .cursor/mcp.json in your project):

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

Windsurf: Add to ~/.codeium/windsurf/mcp_config.json (or Windsurf Settings > Cascade > MCP Servers). Same JSON format as above.

VS Code (GitHub Copilot): Add to .vscode/mcp.json in your workspace. Note the different key names:

{
  "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.

What can agents do with it?

Once connected, you can ask your agent things like:

“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”
“Compare what was discussed in last week’s retro vs this week’s”
“Draft a project status update from my meetings this past week”

The agent has access to three 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.

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. If you just finished a meeting, wait for the summary to finish processing (the summary window shows a progress indicator).

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.

Post-Meeting Command

The post-meeting command lets you send meeting data to any tool, script, or AI agent after you’ve reviewed the summary. This is useful for automations like creating tickets, posting to Slack, or running a follow-up with a local AI agent.

How it works

Configure a shell command in Settings > Integrations
Optionally set a default instruction (e.g., “Create follow-up tasks from this meeting”)
After a meeting, review the summary and make any corrections
Click Run (or press ⇧⌘R) in the meeting summary window
MimicScribe pipes the meeting data as JSON to your command’s stdin, and displays the output

The Run button only appears in the meeting summary window after you’ve configured a command. You can type a custom instruction in the input box before clicking Run — this overrides the default instruction for that invocation.

What your command receives

Your command is executed via /bin/sh -c and receives two things:

Input	How to access	Contains
stdin	Read from standard input (e.g., `cat`, `json.load(sys.stdin)`, `-d @-` with curl)	The full meeting JSON — metadata, transcript, summary, action items, and instruction
`$MIMICSCRIBE_INSTRUCTION`	Environment variable	The instruction text only (what you typed in the input box, or the default from Settings)

The meeting JSON is sent via stdin because it can be large (long meetings produce substantial transcripts). The instruction is available in both places — as the instruction field inside the JSON and as the $MIMICSCRIBE_INSTRUCTION environment variable — so your command can use whichever is more convenient.

Your command’s stdout is captured and displayed in the meeting summary window. stderr is also captured and shown if the command exits with a non-zero code.

Your command is run via /bin/sh -c, so standard shell features work — pipes, &&, ;, and subshells. Use tee to send stdin to multiple commands:

tee >(curl -s -X POST -d @- https://hooks.slack.com/...) | claude -p "$MIMICSCRIBE_INSTRUCTION"

Example: Send to a local AI agent

Send your meeting to Claude Code’s command-line interface for processing:

Command:

claude -p "$MIMICSCRIBE_INSTRUCTION"

Default instruction:

Create follow-up tasks from this meeting's action items

When you click Run, MimicScribe pipes the full meeting JSON to Claude, which processes it according to your instruction and returns the result directly in the summary window.

This works with any command-line agent or LLM tool that reads from stdin — not just Claude.

Example: Post to a webhook

Use curl to send meeting data to any webhook — Slack, Zapier, Make, n8n, or a custom endpoint:

Command:

curl -s -X POST -H "Content-Type: application/json" -d @- https://hooks.slack.com/services/YOUR/WEBHOOK/URL

The -d @- flag tells curl to read the POST body from stdin, which is where MimicScribe pipes the meeting JSON. The webhook receives the full meeting payload including transcript, summary, and action items.

Example: Custom script

For more complex workflows, write a script that reads the meeting JSON from stdin:

Command:

python3 ~/scripts/process_meeting.py

Example script:

import json, sys

meeting = json.load(sys.stdin)
print(f"Meeting: {meeting['title']}")
print(f"Action items: {len(meeting.get('actionItems', []))}")

for item in meeting.get('actionItems', []):
    owner = item.get('owner', 'Unassigned')
    print(f"  - [{owner}] {item['task']}")

Meeting JSON format

The JSON piped to your command includes:

{
  "meetingId": "uuid",
  "title": "Weekly Standup",
  "date": "2026-03-22T10:00:00Z",
  "durationSeconds": 1800,
  "speakers": ["Alice", "Bob"],
  "summary": "## At a Glance\n...",
  "actionItems": [
    {
      "owner": "Alice",
      "task": "Update the roadmap",
      "due": "2026-03-25",
      "dueDescription": "by end of week",
      "type": "task"
    }
  ],
  "transcript": "**[0:00] Alice:** Hello everyone...",
  "tags": "standup planning sprint",
  "instruction": "Your instruction text here"
}

The instruction field contains whatever you typed in the input box, or the default instruction from Settings.

Security

Your command runs locally on your Mac. MimicScribe never sends meeting data to any server on its own. The command is a local shell process, just like running something in Terminal.
You control what runs. The command is exactly what you type in Settings. MimicScribe does not interpret, modify, or sandbox it.
Meeting data is sensitive. If your command sends data to an external service (e.g., a webhook), make sure you trust that endpoint. Meeting transcripts may contain confidential conversations, personnel discussions, or proprietary information.
No automatic execution. The command only runs when you explicitly click Run or press ⇧⌘R. It never runs automatically after a meeting.

Troubleshooting commands

“command not found” error: Make sure the command is in your system PATH. For tools installed via Homebrew (like claude), you may need to use the full path: /opt/homebrew/bin/claude -p "$MIMICSCRIBE_INSTRUCTION".

No output appears: Some commands write to stderr instead of stdout. MimicScribe captures both and displays the combined result. If your command truly produces no output, you’ll see “(no output)“.

Command times out: Commands have a 2-minute timeout. If your command needs longer (e.g., a large meeting processed by an LLM), the process will be terminated and you’ll see a timeout message. Consider breaking the work into smaller operations, or using a webhook to offload processing to a server.

Spinner runs for a long time: This is normal for AI-powered commands. Processing a long meeting transcript through Claude or another LLM can take 30-60 seconds. The Run button shows “Running…” while the command executes.

Test first: Use the Test Command button in Settings > Integrations to verify your command works with sample data before using it on a real meeting. This runs the command with a short test transcript so you can confirm the output looks right.

Programmatic configuration

Integration settings are stored in UserDefaults under the app.mimicscribe domain. Agents and scripts can configure them directly via defaults write:

# Set up a post-meeting command
defaults write app.mimicscribe integrationCommand 'claude -p "$MIMICSCRIBE_INSTRUCTION"'
defaults write app.mimicscribe integrationInstruction 'Create follow-up tasks from this meeting'

# Set your name (used for speaker labeling and action item attribution)
defaults write app.mimicscribe userName 'Marshall'

Key	Type	Purpose
`integrationCommand`	String	Shell command to run (receives meeting JSON on stdin)
`integrationInstruction`	String	Default instruction text
`userName`	String	Your name for speaker labels and action item owners

Changes take effect immediately — no restart required. Read current values with defaults read app.mimicscribe integrationCommand. To see all available preferences, run defaults read app.mimicscribe.