← Back to directory
V

Vexa MCP Server

Official
Open-source meeting bots and real-time transcription for Google Meet, Teams and Zoom
Category
Collaboration #20 of 55
Stars
★ 2.9k Very popular
Transport
Streamable HTTP
Runtime
Hosted (no local runtime)
Credentials
API key / credential required
License
Apache-2.0
Last commit
57FMRS · C

Vexa is an upstream-maintained open-source meeting bot and transcription service offered as an MCP server over hosted streamable-http (https://api.cloud.vexa.ai/mcp) with a required Bearer Vexa API key. It brings real-time, speaker-attributed transcripts from Google Meet, Microsoft Teams and Zoom to AI agents, and supports fully self-hosted, Kubernetes and air-gapped deployment under Apache-2.0. It suits teams that want data sovereignty and want meetings compiled into a Markdown workspace they own; it does not suit users who only want hosted SaaS, or who depend on not-yet-wired features such as mid-call config, bot speech and WebSocket multiplexing. Watch API key handling, participant consent, and propose-only gating for untrusted agent input.

Strongest · Documentation 14/20 Weakest · Reliability 9/20

Reliability
9/20
Security and permissions
10/20
Maintenance
13/20
Documentation
14/20
Setup experience
11/20
Why each score
Reliability 9/20
Static evidence shows a plausible startup path: the only declared transport is a hosted streamable-http endpoint (https://api.cloud.vexa.ai/mcp) requiring just a bearer header, so the init + tool-list handshake is reasonably inferable with no local process or build. However, the source contains no CI workflows, no committed tests, and no reproducible execution evidence for the MCP endpoint itself, and the manifest declares no tools, resources, or prompts at all, making the core requirement — declared tools matching real behavior — unverifiable. The README self-discloses gaps: WebSocket transport not wired, PUT /bots/{…}/config and POST /bots/{…}/speak returning 404, POST /agent/meeting/{start,process} unavailable in the open-core stack, POST /bots returning 503 by default when STT is absent (GPU transcription unit or free token needed), and speaker attribution explicitly not guaranteed (empty speaker instead of guessing, ~4–7% of rows under heavy crosstalk). Dependency surface is broad and coupled (Docker, Postgres, Redis, MinIO, GPU STT, external API key), so diagnosability depends on the hosted side. Net: happy path plausible, boundaries and error handling thin, plus a documented capability gap between 'MCP server' claims and an empty MCP surface. Conservative score 9.
Security and permissions 10/20
Authentication is least-privilege in direction: the remote MCP uses a bearer token, the manifest marks that header isRequired and isSecret, the key comes from the user's account page, and examples use placeholders ($API_KEY, vxa_…) rather than real secrets — satisfying the no-leaked-credentials requirement. Deployment claims are data-sovereign (in-VPC, zero egress, air-gapped, own object storage, bring-your-own LLM endpoint); no covert exfiltration or malicious behavior is visible and no red line is triggered. Deductions are concrete: no MCP tool-level scope documentation, so the read/write/delete boundary is undefined at the manifest level; agents are described as writing to workspaces and producing git commits (side effects), yet the only safeguard described is a principle ('trusted chat writes, untrusted input propose-only') with no explicit confirmation mechanism for MCP-initiated actions; at-rest encryption for workspace/transcript/tokens is explicitly Planned, not implemented; the K8s/Docker agent runtime relies on substrate-enforced isolation rather than agent-enforced policy, and audit logging or rate limiting is not disclosed. Risks are visible but confirmation and scoping are incomplete — 10.
Maintenance 13/20
Maintenance signals are strong: explicit Apache-2.0 license, version 0.12.27, 2767 stars, not archived, plus SECURITY.md reporting channel, security-insights.yml (OpenSSF Security Insights), license-exceptions.json (dependency license gating), architecture.calm.json (FINOS CALM, claimed CI drift-gated), CONTRIBUTOR_RIGHTS.md with DCO, a deploy/helm chart, and public roadmap board and milestones. These point to sustained maintenance with clear ownership and an update path. Deductions: 544 open issues against 2767 stars suggests meaningful backlog, and no response-time or closure-rate evidence is provided; README self-reports several in-progress items (Helm/K8s status, Jitsi live validation, WebSocket, mid-call control); no concrete release notes or dependency-update evidence appears (README claims are untrusted evidence). Score 13.
Documentation 14/20
Documentation is layered and substantial: motivation, architecture diagram, quickstart for both hosted curl and self-host (make all/lite/dev), environment variables and runtime backends (docker/process/k8s), hosted vs self-host base URLs, endpoint tables for the Meetings API and Agent API, SSE frame types (message-delta, tool-call, commit, done, error), platform enum, STT/503 behavior, pricing ($0.30/hr, $5 free credit ≈ 16 hours), and an honest status/roadmap table with three states, including the 4–7% empty-speaker attribution disclosure, Jitsi pending live validation, and K8s backend status. Compliance artifacts are also cited (SECURITY.md, security-insights.yml, CALM, license-exceptions). Deductions: MCP-client documentation is delegated to docs.vexa.ai/vexa-mcp, so this repo lacks the tool list, parameters, return shapes, and client snippets; rate limits and quotas are unstated; the v0.12 404 behaviors are scattered between body text and a blockquote and are easy to miss; no troubleshooting section appears in the supplied source. Usable but with hidden assumptions and troubleshooting gaps — 14.
Setup experience 11/20
The hosted MCP path is very light: one streamable-http URL plus a bearer key from vexa.ai/account, no local runtime or build, few explicit steps — a clear plus. Self-hosting also documents concrete targets (make all/lite/dev/probe/down/help) and ports (Terminal 13000, Gateway 18056). Deductions are significant: the self-host bar is not low — Docker engine ≥ v26 and make, Linux (Ubuntu 24.04) as the production target, transcription as a separate GPU unit that is required by default (503 on POST /bots without it), and a nine-container stack (gateway, terminal, meeting-api, agent-api, runtime, admin-api, redis, postgres, minio); the agent plane is self-host only (absent from the hosted service); contributor builds want 8 vCPU / 16 GB; production needs a user-supplied TLS reverse proxy; and no mainstream MCP client config examples (Claude Desktop, Cursor, VS Code) appear — only curl samples. Steps are clear but component-heavy, platform-heavy, and missing client config samples; conservative score 11 under the static cap.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the network

Best for

  • Teams that want to self-host and fully own their meeting data and transcripts
  • Regulated organizations needing air-gapped meeting intelligence on their own infrastructure
  • Developers wiring meeting transcripts into their own AI agents and knowledge bases

Not for

  • Users who only want hosted SaaS and do not need self-hosting (agent-plane features are self-hosted only)
  • Users needing full mid-call bot control or TTS speech into calls (those endpoints return 404 in the open-core stack)
  • Scenarios requiring guaranteed speaker attribution (heavy crosstalk yields empty speakers on roughly 4–7% of rows)

Required permissions

  • A Vexa API key is required for the remote MCP endpoint (Authorization: Bearer header, secret)
  • HTTP API calls use the X-API-Key header
  • Self-hosting requires Docker (engine ≥ v26 recommended) or a Kubernetes/OpenShift cluster
  • Transcription requires an STT service or hosted token; recordings require object storage such as MinIO

Risks and side effects

  • A leaked API key lets someone send bots, read transcripts and dispatch agents as you
  • The bot joins calls as a visible participant, so participant knowledge and consent matter
  • Recordings and transcripts may contain sensitive content; self-hosting with your own storage controls the data boundary
  • Agents handling untrusted input (email, web pages) must run propose-only with human approval, otherwise writes can be irreversible
  • In the open-core stack, mid-call bot config and speak endpoints currently return 404 and should not be relied on

Setup

Before you start

Runtime:Hosted (no local runtime)

  1. Hosted path: sign in at vexa.ai/signin and copy your API key from vexa.ai/account.
  2. Self-hosted path: clone https://github.com/Vexa-ai/vexa and run make all (pulls published images, seeds .env, prints your API key and URLs); make lite is a single-container option and make dev builds from the checkout.
  3. Transcription (STT) is required by default: use a free token from vexa.ai/account, or deploy the GPU transcription unit from deploy/transcription and point .env at it; without STT, POST /bots returns 503.
  4. Point your MCP client at https://api.cloud.vexa.ai/mcp for the hosted service, or the gateway's /mcp path when self-hosting, using the streamable-http transport.
  5. Auth header: Authorization: Bearer <Vexa API key> — required and secret.
  6. Beyond MCP you can call the gateway HTTP API directly using X-API-Key auth.

Check that it works

Point your MCP client at https://api.cloud.vexa.ai/mcp with an Authorization: Bearer header using a Vexa API key from https://vexa.ai/account; a successful connection should let you ask for a meeting transcript and get speaker-attributed text back.

Troubleshooting

  1. POST /bots returns 503: transcription (STT) is likely unconfigured — supply a token, deploy the STT unit, or set transcribe_enabled=false for capture-only
  2. MCP connection fails: confirm streamable-http transport, the correct URL, and a valid API key in the Authorization: Bearer header
  3. Generic Agent API errors: verify X-API-Key auth; identity is derived server-side from your key
  4. Live transcripts: poll GET /transcripts/{platform}/{native_meeting_id}; WebSocket multiplex is still planned
  5. PUT /bots/{...}/config or POST /bots/{...}/speak returns 404: these capabilities are not yet wired in the open-core stack

Things to try

Once connected, you can ask your AI assistant things like:

  • Send a Vexa bot into my Google Meet call abc-defg-hij and start transcribing.
  • Show me the live transcript from the google_meet meeting abc-defg-hij.
  • Brief me on the Acme account: every meeting, the open decisions, and the next step.
  • What did we decide in my last meeting?

Use cases

Have a bot auto-join Google Meet, Microsoft Teams or Zoom calls and read speaker-attributed transcripts live
Ask an agent about a live meeting using the live transcript plus your workspace as context
Generate a morning brief or post-meeting report through a scheduled (cron) routine
Dispatch a one-shot agent after a call for summaries, decisions and action items with owners
Triage incoming email via an event-triggered, read-only, propose-only agent flow
Browse and read your Markdown workspace (OKF kg/ bundle) for accumulated meeting knowledge

Supported clients

Claude CodePartial support
CodexPartial support

Listed from the project's documentation, not tested by this site.

Overview

Vexa is an open-source meeting bot and transcription service. A bot joins Google Meet, Microsoft Teams and Zoom calls and streams speaker-attributed transcripts in real time. It exposes a Meetings API (send a bot, fetch transcripts, recordings) and an Agent API (workspace chat, cron routines, event-triggered dispatch), plus an MCP endpoint at /mcp on the gateway for AI agent clients. Run it self-hosted via Docker Compose or Helm on Kubernetes/OpenShift, or use the hosted service. Licensed Apache-2.0 and air-gap-ready.

Similar servers

Source revision f1a62fbbdfd2 Data synced 2026-10-19 Read the FMRS scoring method