MCP Server

Chamade runs its own hosted MCP server. You configure your client once with the URL and your API key — no local server to install, no process to keep running.

Overview

The Chamade MCP server is hosted at https://mcp.chamade.io/mcp/ and speaks the Streamable HTTP transport from the MCP spec. It exposes 13 tools that let an AI agent join voice meetings, speak, read transcripts, and handle DMs across every supported platform. Auth is a standard Authorization: Bearer chmd_* header — the same API key you use for the REST API. Real-time push events are supported for channel-aware clients (see Push events below).

Setup

You need an API key from the Dashboard (starts with chmd_). Pick the config that matches your client.

Option A — HTTP direct recommended

For clients that support the Streamable HTTP MCP transport: Claude Desktop (recent), Claude Code, Cursor, Windsurf, and a growing list of others. Zero dependencies, zero install, one endpoint.

        json
        
    
{
  "mcpServers": {
    "chamade": {
      "type": "http",
      "url": "https://mcp.chamade.io/mcp/",
      "headers": {
        "Authorization": "Bearer chmd_your_key_here"
      }
    }
  }
}

Add that block to your client's MCP config file:

Claude Desktop: claude_desktop_config.json
Claude Code: .mcp.json in your project (or ~/.claude.json globally)
Cursor: .cursor/mcp.json
Windsurf: ~/.codeium/windsurf/mcp_config.json

Option B — stdio shim (legacy stdio-only clients)

For MCP clients that only support the older stdio transport, use the @chamade/mcp-server npm package. Since v3 it's a thin wrapper that bridges stdio to our hosted HTTP endpoint under the hood — same tools, same push events, same latency. Zero drift with the hosted surface because there is no parallel stdio implementation to drift against.

        json
        
    
{
  "mcpServers": {
    "chamade": {
      "command": "npx",
      "args": ["-y", "@chamade/mcp-server@3"],
      "env": {
        "CHAMADE_API_KEY": "chmd_your_key_here"
      }
    }
  }
}

Requires Node.js 18+. The shim pins mcp-remote as a dependency so the first run installs it locally — subsequent launches are instant.

Option C — `mcp-remote` direct

If you prefer the community stdio proxy with no Chamade branding, you can invoke mcp-remote directly. Equivalent to Option B but with a more verbose config and a community-maintained package:

        json
        
    
{
  "mcpServers": {
    "chamade": {
      "command": "npx",
      "args": [
        "-y", "mcp-remote",
        "https://mcp.chamade.io/mcp/",
        "--transport", "http-only",
        "--header", "Authorization:Bearer chmd_your_key_here"
      ]
    }
  }
}

Example conversation

Once configured, your AI agent can handle meetings through natural language:

You Join this Teams meeting: https://teams.microsoft.com/l/meetup-join/...

Tool chamade_call_join → call_id: "abc123", state: "connecting"

Your STT [Alice] OK let's start the sprint review.

Agent Alice started the sprint review. Let me confirm in chat.

Tool chamade_call_chat → "Got it, I'm noting this down."

BYO audio (default)

Transcript lines like [Alice] … come from your own STT client reading the call's audio WebSocket — not from Chamade. Hosted STT (which would push transcripts through MCP) and chamade_call_say are beta-gated in early access. See Audio streaming below for the BYO voice path.

Tools reference

Tool	Description
`chamade_call_join`	Join a voice meeting. Returns a call_id, capabilities, and an `audio` block describing the raw-PCM WebSocket endpoint to connect your own STT/TTS stack to (Chamade is a voice and chat gateway — BYO audio is the default).
`chamade_call_chat`	Send a text chat message in the meeting. Works on all platforms, no audio involved.
`chamade_call_status`	Get call status. In BYO audio mode, transcripts come from your own STT client — this only returns transcript deltas when hosted STT is enabled (beta-gated). Polling fallback: call in a loop (delta pattern, only new lines each time) when your client doesn't support channel mode.
`chamade_call_accept`	Answer a ringing inbound call (SIP, Teams DM call, etc.).
`chamade_call_refuse`	Refuse/reject a ringing inbound call.
`chamade_call_typing`	Send a typing indicator in meeting chat.
`chamade_call_leave`	Hang up and leave the meeting.
`chamade_call_list`	List all active calls. Polling fallback: call periodically to detect new `ringing` inbound calls when your client doesn't support channel mode.
`chamade_call_say`	[BETA — gated] Speak text via hosted TTS. Gated in early access; prefer BYO TTS via the call WebSocket. Contact [email protected] for beta access.
`chamade_inbox`	Check DM conversations (Discord, Telegram, Teams, WhatsApp, Slack, NC Talk). Three modes: snapshot, per-platform detail, delta with optional long-poll. Shows the WhatsApp 24h window state inline. Polling fallback: pass `last_message_cursor` to get only new messages since last call, and `wait=55` to long-poll server-side up to 55 s for near-real-time latency without channel mode.
`chamade_dm_chat`	Send a DM message by platform. On WhatsApp outside the 24h window, returns HTTP 202 with `{status: "queued"}` and auto-fires a re-engagement template; queued messages flush automatically when the user replies.
`chamade_dm_typing`	Send a typing indicator in DM by platform.
`chamade_account`	Check account status — plan, the `features` block (which features are ready vs `beta_gated`), per-platform readiness + capabilities, and the identity map (agent handle + operator handle per platform). Call this first on cold start to bootstrap.

Resources

URI template	Description
`chamade://calls/{call_id}/transcript`	[BETA — gated] Live transcript from Chamade's hosted STT. Only populated when hosted STT is enabled for your account. In BYO audio mode (default), your own STT client is the source of truth — this resource will return empty.

Audio streaming (BYO)

MCP is a control plane, not a data plane — it cannot stream audio. This is architectural, not a Chamade limitation: JSON-RPC 2.0 has no primitive for continuous binary streams, so every voice infrastructure in the ecosystem follows the same pattern — raw WebSocket (or WebRTC) for audio, a text protocol for control.

Chamade follows the same split: MCP tools drive the call (chamade_call_join, chamade_call_chat, etc.), and the raw PCM flows over a separate WebSocket described in the REST API reference. Your agent's host code connects to both and pipes bytes between the call WebSocket and your own STT/TTS stack (OpenAI Realtime, LiveKit Agents, Pipecat, Deepgram Voice Agent, or a manual cascade). The audio block returned by chamade_call_join tells you exactly what stream_url, sample rate, and frame format to expect.

Hosted STT/TTS (where Chamade runs the speech layer for you) is beta-gated in early access — contact [email protected] for supervised access. For production, use BYO audio.

Push events (channel mode)

Chamade's MCP server supports real-time push events for channel-aware clients (currently Claude Code): new DMs, incoming calls, and call state changes arrive as notifications/claude/channel on the open MCP session, no polling required. Claude Code needs a per-launch opt-in flag; other MCP clients (Claude Desktop, Cursor, Windsurf) silently fall back to polling and everything keeps working.

See the dedicated Channel Mode page for setup, the launch flag, the event format, and workflow patterns.

Prefer the REST API?

The MCP server is a thin wrapper around the REST API. Every MCP tool maps one-to-one to an HTTP endpoint. If your agent doesn't speak MCP (or you want direct control), use https://chamade.io/api/* with the same X-API-Key or Authorization: Bearer header.