# Install Munin for an AI agent

> Munin records meetings and writes notes. Its MCP server lets an AI agent list, search and read the human's own meetings. This file tells an agent how to install it by itself. Page for people: https://app.muninlabs.ai/agents

Last checked: 2026-10-16

## If you are an AI agent: do this

1. Can you run shell commands on the human's computer? If not (claude.ai, ChatGPT, another hosted chat), go to "Hosted chat apps" below, tell the human the steps for your app, and stop
2. Detect the system and the Mac app with the two commands below

```sh
uname -s
test -x /Applications/Munin.app/Contents/MacOS/munin-mcp && echo MUNIN_LOCAL || echo MUNIN_REMOTE
```

3. `Darwin` and `MUNIN_LOCAL`: use the local path. No key, no sign in
4. Anything else: use the remote path. Sign in where your client supports it, else ask the human for a connection key
5. Find your client under "Per agent" below and run the one command, or add the one block to the file named there
6. Verify with "Check" below for your path: count the meetings and tell the human the number
7. If your client loads MCP servers only when it starts, tell the human to restart you, then call `list_meetings`

## Rules

- Never invent a connection key. A real one starts with `munin_pat_` and only the human can make one: [Connect AI](https://app.muninlabs.ai/#/integrations), Cloud, Create
- Ask the human for the key. Use it only in the config line and the check command. Never put it in a URL, a commit, a shared file or your reply
- Do not open the Munin app and do not read the Munin data folder. Run only the `munin-mcp` program as shown
- When a config file already exists, add the `munin` entry and keep everything else
- Install one path, not both: both use the name `munin`
- Pass `--client` with your own name from the list below, so the human can tell which agent read what

## What each path can see

| Path | Meetings | Tools |
| --- | --- | --- |
| Local: Mac with Munin.app | Meetings recorded on this Mac. Web meetings too, once the human saves a key with `munin-mcp connect` | `list_meetings`, `search_transcripts`, `get_meeting`, `get_person`. Full transcripts and write tools stay off until the human turns them on |
| Remote: https://app.muninlabs.ai/mcp | Meetings in the human's Munin account: recorded on the web or uploaded from the Mac. Meetings kept only on a Mac are not there | `list_meetings`, `get_meeting`, `search_transcripts`, `get_transcript`, `set_speaker` |

## Check

### Local

Put your own name after `--client`. The last line printed is the answer to `list_meetings`; its text holds `count`, the number of meetings (at most 50 per call)

```sh
printf '%s\n' \
  '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"munin-check","version":"1"}}}' \
  '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
  '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"list_meetings","arguments":{"limit":50}}}' \
  | /Applications/Munin.app/Contents/MacOS/munin-mcp --client your-agent-name
```

The local path shows web meetings only after a key is saved on this Mac. Zero meetings and the human records on the web: ask the human to run the command below in their own Terminal and paste the key at its hidden prompt. It prints `CLOUD_CONNECTED meetings=N`

```sh
/Applications/Munin.app/Contents/MacOS/munin-mcp connect
```

### Remote

With a key: run this. The answer's text holds `count` (at most 50 per call) and `total`, every meeting in the account. HTTP 401 means the key is wrong or revoked: ask the human for a new one. After a sign in there is no key to use here: call `list_meetings` through your client instead

```sh
curl -sS https://app.muninlabs.ai/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'Authorization: Bearer <MUNIN_KEY>' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"list_meetings","arguments":{"limit":50}}}'
```

## Per agent

### Claude Code

Client name: `claude-code`. Docs: [code.claude.com](https://code.claude.com/docs/en/mcp)

**Local**, run in a terminal

```sh
claude mcp add -s user munin -- /Applications/Munin.app/Contents/MacOS/munin-mcp --client claude-code
```

**Remote, sign in**, run in a terminal

```sh
claude mcp add -s user --transport http munin https://app.muninlabs.ai/mcp
```

Then run `claude mcp login munin` (or the human types /mcp in Claude Code, picks munin, Authenticate) and the human signs in to Munin in the browser

**Remote, key** (if the sign in does not work), run in a terminal

```sh
claude mcp add -s user --transport http munin https://app.muninlabs.ai/mcp --header "Authorization: Bearer <MUNIN_KEY>"
```

Loaded when `claude mcp get munin` shows Connected. The tools appear in the next session

### Claude Desktop

Client name: `claude-desktop`. Docs: [modelcontextprotocol.io](https://modelcontextprotocol.io/docs/develop/connect-local-servers)

**Local**, in `~/Library/Application Support/Claude/claude_desktop_config.json`

```json
{
  "mcpServers": {
    "munin": {
      "command": "/Applications/Munin.app/Contents/MacOS/munin-mcp",
      "args": [
        "--client",
        "claude-desktop"
      ]
    }
  }
}
```

**Remote**: a custom connector, as in "Hosted chat apps" below, then sign in

Loaded when after the human quits Claude Desktop completely and opens it again, munin shows under the tools button

### Codex

Client name: `codex`. Docs: [developers.openai.com](https://developers.openai.com/codex/mcp)

**Local**, run in a terminal

```sh
codex mcp add munin -- /Applications/Munin.app/Contents/MacOS/munin-mcp --client codex
```

**Remote, sign in**, run in a terminal

```sh
codex mcp add munin --url https://app.muninlabs.ai/mcp
```

Then run `codex mcp login munin`; the human signs in to Munin in the browser

**Remote, key** (if the sign in does not work), in `~/.codex/config.toml`

```toml
[mcp_servers.munin]
url = "https://app.muninlabs.ai/mcp"
http_headers = { Authorization = "Bearer <MUNIN_KEY>" }
```

Loaded when `codex mcp list` lists munin. Start a new Codex session to use it

### Cursor

Client name: `cursor`. Docs: [cursor.com](https://cursor.com/docs/mcp)

**Local**, in `~/.cursor/mcp.json`

```json
{
  "mcpServers": {
    "munin": {
      "command": "/Applications/Munin.app/Contents/MacOS/munin-mcp",
      "args": [
        "--client",
        "cursor"
      ]
    }
  }
}
```

**Remote, sign in**, in `~/.cursor/mcp.json`

```json
{
  "mcpServers": {
    "munin": {
      "url": "https://app.muninlabs.ai/mcp"
    }
  }
}
```

Cursor asks the human to sign in to Munin the first time it connects

**Remote, key** (if the sign in does not work), in `~/.cursor/mcp.json`

```json
{
  "mcpServers": {
    "munin": {
      "url": "https://app.muninlabs.ai/mcp",
      "headers": {
        "Authorization": "Bearer <MUNIN_KEY>"
      }
    }
  }
}
```

Loaded when the MCP page of Cursor Settings shows munin with a green dot

### Gemini CLI

Client name: `gemini-cli`. Docs: [github.com](https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md)

**Local**, run in a terminal

```sh
gemini mcp add -s user munin /Applications/Munin.app/Contents/MacOS/munin-mcp -- --client gemini-cli
```

**Remote, sign in**, run in a terminal

```sh
gemini mcp add -s user -t http munin https://app.muninlabs.ai/mcp
```

Then the human types `/mcp auth munin` in Gemini CLI and signs in to Munin in the browser

**Remote, key** (if the sign in does not work), run in a terminal

```sh
gemini mcp add -s user -t http munin https://app.muninlabs.ai/mcp -H "Authorization: Bearer <MUNIN_KEY>"
```

Loaded when `gemini mcp list` shows munin connected

### Hermes

Client name: `hermes`. Docs: [hermes-agent.nousresearch.com](https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp)

**Local**, in `~/.hermes/config.yaml`

```yaml
mcp_servers:
  munin:
    command: '/Applications/Munin.app/Contents/MacOS/munin-mcp'
    args: ['--client', 'hermes']
```

**Remote, sign in**, in `~/.hermes/config.yaml`

```yaml
mcp_servers:
  munin:
    url: 'https://app.muninlabs.ai/mcp'
    auth: oauth
```

Then run `hermes mcp login munin` in a fresh terminal; the human signs in to Munin in the browser

**Remote, key** (if the sign in does not work), in `~/.hermes/config.yaml`

```yaml
mcp_servers:
  munin:
    url: 'https://app.muninlabs.ai/mcp'
    headers:
      Authorization: 'Bearer <MUNIN_KEY>'
```

Loaded when after /reload-mcp in Hermes (or a restart), the munin tools are listed

### Grok Build

Client name: `grok`. Docs: [docs.x.ai](https://docs.x.ai/build/features/mcp-servers)

**Local**, run in a terminal

```sh
grok mcp add munin -- /Applications/Munin.app/Contents/MacOS/munin-mcp --client grok
```

**Remote, key**, run in a terminal

```sh
grok mcp add --transport http munin https://app.muninlabs.ai/mcp --header "Authorization: Bearer <MUNIN_KEY>"
```

Loaded when `grok mcp doctor munin` reports it healthy

### Any other MCP client

Client name: `your-agent-name`. Docs: [modelcontextprotocol.io](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http)

**Local**

```text
/Applications/Munin.app/Contents/MacOS/munin-mcp --client your-agent-name
```

**Remote, key**

```text
https://app.muninlabs.ai/mcp
Authorization: Bearer <MUNIN_KEY>
```

Stdio: the program above. Streamable HTTP: the URL and header above. Sign in (OAuth 2.1 with PKCE and dynamic registration) works when your client's callback is http://localhost or http://127.0.0.1

## Hosted chat apps

These run on their company's servers, so only the remote path works and the human adds it by hand

- **claude.ai**: Customize, Connectors, + Add, Add custom connector; name `Munin`, URL `https://app.muninlabs.ai/mcp`; Continue, then sign in to Munin
- **Claude Desktop, without the Mac app**: The same custom connector as claude.ai; it shows up in Claude Desktop too
- **ChatGPT**: ChatGPT, Customize, Plugins, Add, Add custom MCP server; name `Munin`, Server URL `https://app.muninlabs.ai/mcp`, Authentication OAuth; tick I understand and want to continue, Create as a plugin; Continue to Munin, sign in, Allow; in a chat type @ and pick Munin

## Windows and Linux

The Mac app and its local path are macOS only. Everywhere else, use the remote path