Skip to content
Back to search

vexa

Open-source meeting transcription API for Google Meet, Microsoft Teams & Zoom. Auto-join bots, real-time WebSocket transcripts, MCP server for AI agents. Self-host or use hosted SaaS.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Vexa-ai/vexa with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Vexa-ai/vexa'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/vexa-ai--vexa/badge.svg)](/listings/vexa-ai--vexa)

HTML

<a href="/listings/vexa-ai--vexa"><img src="/api/listings/vexa-ai--vexa/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Just want a bot in a meeting?** Use the hosted service — no install. Sign in at [vexa.ai/signin](https://vexa.ai/signin), copy your key from [your account page](https://vexa.ai/account), and send a bot:

curl -X POST "https://api.cloud.vexa.ai/bots" \
  -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  -d '{"platform":"google_meet","native_meeting_id":"abc-defg-hij","bot_name":"Vexa"}'

New accounts get **$2 of free bot credit, no card required** — about 6 hours of bot time at $0.30/hr ([pricing](https://vexa.ai/pricing)). More calls: [Send a bot](https://docs.vexa.ai/how-to/send-a-bot).

Or self-host the whole stack

That is also how you get the agent plane, which is not part of the hosted service. Self-host on one host, then explore it in the Terminal or drive it over the API. Linux (Ubuntu 24.04) is the production target; a Mac with Docker Desktop works fine for a local evaluation — everything runs in containers either way.

**Prerequisites** — `make`, **Docker engine ≥ v26** (`make all` checks), and transcription: a free token at [vexa.ai/account](https://vexa.ai/account), or self-host the (GPU) transcription unit for a fully air-gapped setup. By default `POST /bots` **requires** STT and answers **503** when it is missing (`make all` warns when the credentials block in `.env` is empty). Capture-only is an explicit opt-out: `{"transcribe_enabled": false}` on the spawn (or set `TRANSCRIBE_ENABLED=false` for the deployment).

> **Build machine:** `make all` **pulls** the published, release-validated images — no build, so a > modest box is fine. `make lite` (the single-container all-in-one image) is lighter still. Building > from this checkout instead (`make dev`, for contributors) wants **8 vCPUs and 16 GB RAM**.

git clone https://github.com/Vexa-ai/vexa.git && cd vexa
make all      # full Docker Compose stack — seeds .env, pulls the images (bot included),
              # prints your API key + URLs. Contributors: `make dev` builds from this checkout.

When `make all` finishes it prints your key and URLs:

  Terminal UI : http://localhost:13000     # the web workbench
  API gateway : http://localhost:18056     # the API
  API key     : vxa_…

Explore in the Terminal (the fast path)

**The Terminal is the way to see what Vexa can do.** Open **`http://localhost:13000`** — you're already signed in to a self-host account. From the workbench you can, with no curl:

- **Send a bot** — paste a Meet / Zoom / Teams / Jitsi URL; a bot joins as a participant. - **Watch the transcript** stream in live, speaker-attributed, draft-then-confirmed. - **Chat with your workspace** — ask an agent that has every captured meeting as context, and watch it commit what you decide.

Or drive it over the API

export API_KEY=vxa_...
export API_BASE=http://localhost:18056

# WIN 1 — send a bot into a live call, then read the transcript as it streams
curl -X POST "$API_BASE/bots" \
  -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  -d '{"platform":"google_meet","native_meeting_id":"abc-defg-hij","bot_name":"Vexa"}'

curl -H "X-API-Key: $API_KEY" "$API_BASE/transcripts/google_meet/abc-defg-hij"

# WIN 2 — ask an agent that has your whole workspace as context (answer streams back as SSE)
curl -N -X POST "$API_BASE/agent/chat" \
  -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  -d '{"prompt":"What did we decide in my last meeting?"}'

`platform` is `google_meet` · `teams` · `zoom` · `jitsi`; `native_meeting_id` is the code from the join URL. The agent reply streams as Server-Sent Events — `message-delta` frames carry the text, `commit` frames mark anything it recorded into your workspace.

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 17 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "vexa",
  3. "owner": { "name": "Vexa", "url": "https://github.com/Vexa-ai" },
  4. "plugins": [
  5. {
  6. "name": "vexa",
  7. "source": "./clients/claude-plugin",
  8. "description": "Send a bot to a Google Meet, Teams or Zoom call and read the transcript, live or after, with speakers labelled. Hosted or self-hosted.",
  9. "version": "0.1.0",
  10. "category": "productivity",
  11. "tags": ["meetings", "transcription", "google-meet", "microsoft-teams", "zoom", "mcp"],
  12. "homepage": "https://docs.vexa.ai/vexa-mcp",
  13. "repository": "https://github.com/Vexa-ai/vexa",
  14. "license": "Apache-2.0"
  15. }
  16. ]
  17. }
README.md · README · 491 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src="assets/logodark.svg" alt="Vexa logo" width="72"/>
  3. # Vexa
  4. **Open-source meeting bots and real-time transcription — cloud or fully self-hosted.**
  5. A bot joins your Google Meet, Microsoft Teams, and Zoom calls and streams speaker-attributed
  6. transcripts in real time — through our API or one *you* host — then feeds sandboxed agents that build
  7. a Markdown knowledge base your team owns. Apache-2.0, air-gap-ready. (Jitsi: join + capture
  8. offline-proven, live validation pending — [#883](https://github.com/Vexa-ai/vexa/issues/883).)
  9. [![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
  10. [![Version](https://img.shields.io/badge/version-0.12-informational.svg)](#️-status--roadmap)
  11. [![Deploy](https://img.shields.io/badge/deploy-cloud%20or%20self--hosted-success.svg)](#-quickstart)
  12. [![Discord](https://img.shields.io/badge/chat-Discord-5865F2.svg)](https://discord.gg/Ga9duGkVz9)
  13. **[vexa.ai](https://vexa.ai)** runs Vexa 0.12 for meeting bots and transcription.
  14. Sandboxed knowledge agents are self-hosted only — [self-host Vexa](#-quickstart) to run the full stack.
  15. </div>
  16. ---
  17. **[Connect your agent](https://vexa.ai/connect?utm_source=github&utm_medium=readme)**
  18. · **[Get an API key](https://vexa.ai/start?utm_source=github&utm_medium=readme)**
  19. · **[Talk to the founder](https://cal.com/dmitrygrankin/web)**
  20. ## Why Vexa
  21. Every meeting-AI tool you can buy sends your conversations to *their* cloud and rents you
  22. access back. Vexa inverts that: run the stack yourself, point it at your own models, own what
  23. your meetings become.
  24. No one else has all three:
  25. 1. **Vexa is *in* the meeting.** A real bot joins Meet, Teams and Zoom — Jitsi offline-proven, live
  26. validation pending — and streams speaker-attributed transcripts live. That bot fleet is the
  27. genuinely hard part — every "chat with your docs" tool starts *after* a transcript exists. Vexa
  28. produces it.
  29. 2. **Your knowledge is files you own.** Meetings compile into Markdown in a git repo —
  30. portable, diffable, greppable. Knowledge as code.
  31. 3. **Agents work it, safely.** Sandboxed coding agents read and write that repo like
  32. developers — isolated ephemeral containers, no egress, thousands in parallel, on Docker
  33. or your Kubernetes.
  34. > **Only here for the transcription API?** It's a complete standalone product — send a bot,
  35. > read the stream, ignore the agent lane entirely.
  36. ---
  37. ## ⚡ Quickstart
  38. **Just want a bot in a meeting?** Use the hosted service — no install. Sign in at
  39. [vexa.ai/signin](https://vexa.ai/signin), copy your key from [your account page](https://vexa.ai/account),
  40. and send a bot:
  41. ```bash
  42. curl -X POST "https://api.cloud.vexa.ai/bots" \
  43. -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  44. -d '{"platform":"google_meet","native_meeting_id":"abc-defg-hij","bot_name":"Vexa"}'
  45. ```
  46. New accounts get **$2 of free bot credit, no card required** — about 6 hours of bot time at
  47. $0.30/hr ([pricing](https://vexa.ai/pricing)). More calls: [Send a bot](https://docs.vexa.ai/how-to/send-a-bot).
  48. ### Or self-host the whole stack
  49. That is also how you get the agent plane, which is not part of the hosted service.
  50. Self-host on one host, then explore it in the Terminal or drive it over the API.
  51. Linux (Ubuntu 24.04) is the production target; a Mac with Docker Desktop works fine for a local
  52. evaluation — everything runs in containers either way.
  53. **Prerequisites** — `make`, **Docker engine ≥ v26** (`make all` checks), and transcription: a free token at
  54. [vexa.ai/account](https://vexa.ai/account), or self-host the (GPU) transcription unit for a fully
  55. air-gapped setup. By default `POST /bots` **requires** STT and answers **503** when it is missing
  56. (`make all` warns when the credentials block in `.env` is empty). Capture-only is an explicit opt-out:
  57. `{"transcribe_enabled": false}` on the spawn (or set `TRANSCRIBE_ENABLED=false` for the deployment).
  58. > **Build machine:** `make all` **pulls** the published, release-validated images — no build, so a
  59. > modest box is fine. `make lite` (the single-container all-in-one image) is lighter still. Building
  60. > from this checkout instead (`make dev`, for contributors) wants **8 vCPUs and 16 GB RAM**.
  61. ```bash
  62. git clone https://github.com/Vexa-ai/vexa.git && cd vexa
  63. make all # full Docker Compose stack — seeds .env, pulls the images (bot included),
  64. # prints your API key + URLs. Contributors: `make dev` builds from this checkout.
  65. ```
  66. When `make all` finishes it prints your key and URLs:
  67. ```text
  68. Terminal UI : http://localhost:13000 # the web workbench
  69. API gateway : http://localhost:18056 # the API
  70. API key : vxa_…
  71. ```
  72. ### Explore in the Terminal (the fast path)
  73. **The Terminal is the way to see what Vexa can do.** Open **`http://localhost:13000`** — you're
  74. already signed in to a self-host account. From the
  75. workbench you can, with no curl:
  76. - **Send a bot** — paste a Meet / Zoom / Teams / Jitsi URL; a bot joins as a participant.
  77. - **Watch the transcript** stream in live, speaker-attributed, draft-then-confirmed.
  78. - **Chat with your workspace** — ask an agent that has every captured meeting as context, and watch it
  79. commit what you decide.
  80. ### Or drive it over the API
  81. ```bash
  82. export API_KEY=vxa_...
  83. export API_BASE=http://localhost:18056
  84. # WIN 1 — send a bot into a live call, then read the transcript as it streams
  85. curl -X POST "$API_BASE/bots" \
  86. -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  87. -d '{"platform":"google_meet","native_meeting_id":"abc-defg-hij","bot_name":"Vexa"}'
  88. curl -H "X-API-Key: $API_KEY" "$API_BASE/transcripts/google_meet/abc-defg-hij"
  89. # WIN 2 — ask an agent that has your whole workspace as context (answer streams back as SSE)
  90. curl -N -X POST "$API_BASE/agent/chat" \
  91. -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  92. -d '{"prompt":"What did we decide in my last meeting?"}'
  93. ```
  94. `platform` is `google_meet` · `teams` · `zoom` · `jitsi`; `native_meeting_id` is the code from the join URL. The
  95. agent reply streams as Server-Sent Events — `message-delta` frames carry the text, `commit` frames mark
  96. anything it recorded into your workspace.
  97. ---
  98. ## 🧩 How it works
  99. One gateway, two domains — **Meetings** (capture) and **Agents** (work the knowledge) — both running on
  100. the same **runtime**: the engine that spawns every bot and every agent in its own sandboxed container.
  101. <div align="center">
  102. <img src="assets/architecture.svg" width="840"
  103. alt="One API gateway routes to two domains — Meetings and Agents — both running on one runtime that spawns each bot and agent in its own sandboxed container on Docker, Kubernetes, or Process.">
  104. </div>
  105. A bot and an agent are the **same `runtime.v1` workload** — isolated, ephemeral, reaped on idle — so the
  106. machinery already proven by thousands of meeting bots is exactly what runs your agents. Every arrow stays
  107. inside your network.
  108. ---
  109. ## ⚙️ The agentic runtime
  110. A CLI coding agent is just a process on Linux. The **runtime** makes that a multi-tenant,
  111. sandboxed execution layer safe to point at real business data — the same engine that already
  112. spawns Vexa's meeting bots in production.
  113. - **Isolated.** Every dispatch gets its own container: no egress except brokered tools, and
  114. only its granted workspaces exist in its filesystem — enforced by the substrate, not by the
  115. agent. Agents never run in the control plane.
  116. - **Ephemeral.** A container lives while it works and is reaped on idle; continuity is a
  117. session file in the workspace. Sub-second starts, thousands in parallel.
  118. - **Orchestration-agnostic.** One `runtime.v1` lifecycle, pluggable substrate — the same
  119. dispatch runs identically across:
  120. | Backend (`RUNTIME_BACKEND`) | A workload is… | State |
  121. |---|---|---|
  122. | **`docker`** (default) | its own container via the Docker socket — brought up with `make all` | ✅ Shipped (open core) |
  123. | **`process`** | a child process, no Docker socket required | ✅ Available |
  124. | **`k8s`** | a bare **Pod** (`kubectl run --restart=Never`), scheduled across a cluster | ✅ Lifecycle + per-mount workspace isolation; Helm chart in `deploy/helm` |
  125. Same control plane, same worker — only how the container is created changes. One laptop to a
  126. Kubernetes/OpenShift cluster, inside your walls.
  127. ---
  128. ## 🧠 Agents & your workspace
  129. Capture is the front door; **agents** make the knowledge compound. Every meeting compiles into
  130. your **workspace** — a git repo of Markdown (an [Open Knowledge Format](https://github.com/GoogleCloudPlatform/knowledge-catalog/tree/main/okf)
  131. `kg/` bundle) that agents (Claude Code, Codex, …) read and write like developers work a codebase.
  132. > This is [Andrej Karpathy's **LLM Wiki**](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f)
  133. > pattern, run as a team service. The idea: don't RAG over raw documents — where the model
  134. > rediscovers everything from scratch on every question — have agents **compile** sources into
  135. > structured, interlinked markdown entity pages (people, companies, projects, decisions) so
  136. > knowledge **compounds**. Vexa builds that wiki for you from the richest source there is: your
  137. > meetings. Each call is ingested into entity pages; agents keep them current between calls; every
  138. > answer starts from what your team already knows — on your own servers.
  139. Agents work *any* workspace; a meeting is just one trigger of four — **chat**, **schedule**
  140. (cron), **event** (e.g. incoming email), **finished meeting**. Meetings themselves are scheduled
  141. work: connect your calendar (ICS) and planned meetings appear with attendees — bots
  142. **auto-join**, agents prepare before the call and process after it.
  143. - **Multiplayer.** Team-shared, attributed workspaces — not one person's private notes.
  144. - **Automated.** The bot captures the call; the transcript compiles itself in.
  145. - **Safe by design.** Agents are untrusted and enforce nothing themselves. You, in chat, write
  146. directly (git is the undo); untrusted input — an email, a web page — runs **propose-only**:
  147. the agent suggests, a human approves, trusted code applies. Irreversible effects are always gated.
  148. > **Status (honest):** capture, transcription, and speaker attribution are **production**; the
  149. > agent dispatch core is **built and proven live** end-to-end. What's still landing is tracked in
  150. > [Status](#️-status--roadmap).
  151. ---
  152. ## 🖥️ The Terminal: AI-augmented meetings
  153. 0.12 ships a **new Terminal UI** built to put the backend's scale — thousands of bots and
  154. agents — to work on your actual week. It opens on your meetings: coming up, live now, to review.
  155. - **An agent in your meeting, with your knowledge.** Open a live call: the transcript streams
  156. speaker-attributed, and the agent has the live conversation *and* your workspace in context.
  157. Ask mid-call "what did we promise them last time?" — or research a person, company, or
  158. contract the moment it comes up, grounded in your wiki.
  159. - **Knowledge built on meetings — and between them.** Every planned meeting gets an agent that
  160. **prepares the brief before** (who's coming, history, open threads — it interviews *you* for
  161. what it can't know) and **processes the transcript after**. Arrive prepared, leave with the
  162. wiki updated.
  163. - **Sharing.** Invite colleagues into a workspace — same wiki, attributed. Share a meeting with
  164. its attendees — they get the **real-time feed**, not a recording link after the fact.
  165. - **Collaborative, AI-augmented meetings.** Prep a shared workspace together; during the call,
  166. humans edit the brief while agents stream the transcript in and work the knowledge — one room,
  167. human and AI participants on the same files.
  168. ---
  169. ## 📖 How-to recipes
  170. Each is a complete path to one outcome over the [Agent API](#-api-reference). Full guides at
  171. [docs.vexa.ai](https://docs.vexa.ai).
  172. **💬 Chat with your workspace** — ask an agent that has every meeting, email, and note as context; trusted
  173. chat can also record a decision (a git commit).
  174. ```bash
  175. curl -N -X POST "$API_BASE/agent/chat" -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  176. -d '{"prompt":"Brief me on the Acme account: every meeting, the open decisions, and the next step."}'
  177. ```
  178. **🌅 Brief me every morning** — an unattended agent on a cron schedule that commits to your workspace.
  179. ```bash
  180. curl -X POST "$API_BASE/agent/routines" -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  181. -d '{"name":"Morning brief","cron":"0 8 * * 1-5",
  182. "prompt":"Brief me from overnight activity — new meetings, decisions, follow-ups due. Write brief/today.md.",
  183. "run_now":true}'
  184. ```
  185. **📝 Report after every meeting** — dispatch a one-shot agent when a call ends (or a routine that sweeps
  186. recent meetings).
  187. ```bash
  188. curl -X POST "$API_BASE/agent/invocations" -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  189. -d '{"runner":"claude-code","workspaces":[{"id":"u_jane","mode":"rw"}],"trigger":"scheduled",
  190. "start":{"entrypoint":{"inline":"Write a report for the meeting that just ended: summary, decisions, action items with owners."}}}'
  191. ```
  192. **📧 Triage incoming email (safely)** — an event-triggered agent that gets the mailbox **read-only** and can
  193. only *propose* actions as cards; a human approves before anything is written or sent.
  194. ```bash
  195. curl -X POST "$API_BASE/agent/events" -H "X-API-Key: $API_KEY" -H "Content-Type: application/json" \
  196. -d '{"name":"email.received","source":{"uri":"mailbox://u_jane/INBOX/AB12CD"},
  197. "plan":{"prompt":"Triage this email into tasks; propose a record for each action item and a draft reply."}}'
  198. ```
  199. > **During the call** — stream the live transcript with `GET /agent/meeting/stream` and ask your
  200. > agent about it in the chat. Vexa runs no model of its own during a meeting: there is one
  201. > intelligence and it is your agent. See [Status](#️-status--roadmap).
  202. ---
  203. ## 🚀 Deployment options
  204. Two ways to run Vexa, one codebase:
  205. **1. Personal / dev — Docker on your Mac, Linux, or Windows machine.**
  206. Single container (`make lite` — the all-in-one Vexa Lite image) or the full Compose stack
  207. (`make all`). **Reuse your Claude subscription**: workers run the official `claude` CLI against
  208. your own Pro/Max credential, which is a covered, credit-metered use under Anthropic's terms for a
  209. personal deployment — your subscription, your turns, your machine. See
  210. [Model credentials & licensing](https://docs.vexa.ai/model-credentials-licensing) for the exact
  211. terms mapping ([Anthropic's Agent SDK plan-usage article](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan)
  212. is the primary source). You get the full service — bots, transcripts, agents, Terminal — on the
  213. subscription you already pay for.
  214. **2. Cloud — Helm on Kubernetes / OpenShift, scalable to thousands of users.**
  215. The chart in [`deploy/helm`](https://github.com/Vexa-ai/vexa/tree/main/deploy/helm) deploys the same control plane with
  216. `RUNTIME_BACKEND=k8s`: **every bot and every agent is its own Kubernetes workload** (a bare Pod
  217. per dispatch), so capacity is your cluster's scheduler, not a bigger box — built multi-tenant and
  218. multiuser from the start. One compliance rule when you go multiuser: other users' turns must run
  219. on an **API key** (Commercial Terms), never a personal subscription credential — the
  220. [licensing page](https://docs.vexa.ai/model-credentials-licensing) spells out the boundary, and
  221. Settings → Models enforces per-user/global credential resolution. K8s backend status is tracked
  222. honestly in [Status](#️-status--roadmap).
  223. ---
  224. ## 🏠 Deploy & configure
  225. `make all` brings up the full stack via Docker Compose on one Linux host — each service in its own
  226. container, bound to loopback:
  227. | Service | Role |
  228. |---|---|
  229. | **gateway** `:18056` | the one front door — auth, scopes, routing |
  230. | **terminal** `:13000` | the web workbench (proxies `/ws` → gateway) |
  231. | **meeting-api** | bots, transcripts, recordings |
  232. | **agent-api** | the agent control plane — dispatch, chat, routines, events |
  233. | **runtime** | spawns bot + agent containers on demand |
  234. | **admin-api** · redis · postgres · **storage** | keys · bus + scheduler · metadata · recordings (versitygw: plain files in a local volume) |
  235. - **Runtime backend** — `RUNTIME_BACKEND=docker` (default) or `k8s` (a Pod per dispatch).
  236. - **Transcription is a separate GPU unit** — `make all` runs **GPU-free**; stand up the STT service
  237. (faster-whisper, OpenAI-compatible) from `deploy/transcription` on any GPU box and point `.env` at it.
  238. Or use a free hosted token at [vexa.ai/account](https://vexa.ai/account) while testing.
  239. - **Bring your own inference** — point the agent at your own LLM endpoint; no inference leaves the network.
  240. - **Air-gapped** — everything in-VPC, **zero egress** — the posture the regulated verticals require.
  241. - **Targets** — `make all` (pulls) · `make dev` (builds from this checkout) · `make lite` ·
  242. `make probe` (full-journey smoke) · `make down` · `make help`. Expose the Terminal via a TLS reverse proxy for
  243. production; full guide in the [docs](https://docs.vexa.ai).
  244. ---
  245. ## 🆚 How Vexa is different
  246. The crowded "AI second brain / self-hosted knowledge base" space is full of excellent tools for
  247. reasoning over documents you *already have*. None of them join a live meeting — they consume
  248. transcripts other tools produced. That's the whole point: **capture is the moat, and it sits
  249. upstream of where a document-RAG tool's architecture even starts.**
  250. Against the tools developers actually weigh for meeting capture:
  251. | Capability | **Vexa** | Hosted APIs (e.g. Recall.ai) | DIY (Whisper + your own bot) |
  252. |---|:---:|:---:|:---:|
  253. | Self-hosted / own your data | ✅ | ❌ their cloud | ✅ |
  254. | Real-time transcript API | ✅ | ✅ | 🟡 build it |
  255. | Joins **Meet + Teams + Zoom + Jitsi** | ✅ 3 production · 🟡 Jitsi | 🟡 varies | ❌ enormous effort |
  256. | Speaker attribution | ✅ | ✅ | 🟡 build it |
  257. | Knowledge as files you own | ✅ | ❌ | 🟡 build it |
  258. | Agents over your workspace | ✅ | ❌ | ❌ |
  259. | Open source | ✅ Apache-2.0 | ❌ | ✅ |
  260. Vexa is the one combination the others don't offer: a **permissively-licensed (Apache-2.0)
  261. meeting-bot-API server** that is **self-hosted × real-time × multi-platform × knowledge-you-own.**
  262. And it's *complementary* to the document-RAG and "second brain" tools — feed them Vexa's clean,
  263. attributed transcripts and let them do what they're good at.
  264. The full field — including [Attendee](https://github.com/attendee-labs/attendee) (the other
  265. meeting-bot API, source-available under the **Elastic License 2.0**, which does not permit providing
  266. it to third parties as a hosted or managed service) and the local-notetaker tools — is mapped
  267. honestly, trade-offs and all, in [How Vexa compares](https://docs.vexa.ai/comparison).
  268. ---
  269. ## 🏦 For regulated enterprises
  270. For banks, healthcare, government, and anyone in a regulated industry, the meeting-AI question
  271. isn't "which cloud" — it's "how do we get this **without** a cloud." Vexa is **air-gapped meeting
  272. intelligence** — the sovereign alternative to Microsoft Copilot — built for exactly that buyer.
  273. You don't compete with a notes app here — you replace **Microsoft 365 Copilot** and **Zoom AI
  274. Companion** on the axes they structurally can't move:
  275. | | **Microsoft 365 Copilot / Zoom AI Companion** | **Vexa** |
  276. |---|---|---|
  277. | Deployment | Vendor cloud only | Your cloud, your VPC, or **fully air-gapped** |
  278. | Models | Vendor-hosted, fixed | **Bring your own** — local or hosted LLMs |
  279. | Commercial model | Rented, per-seat subscription | **Owned** — Apache-2.0, no per-seat tax |
  280. | Adaptable | Generic; no custom vocabulary; vendor roadmap queue | **Your engineers extend it directly** — domain vocabulary, underserved languages, custom workflows |
  281. | Meeting platforms | Teams-only / Zoom-only | **Meet + Teams + Zoom** (+ Jitsi, live validation pending) |
  282. | Data control | Transits the vendor's cloud | **Never leaves your perimeter** |
  283. | Extensibility | Closed black box | Open source, API-first |
  284. What that means in practice:
  285. - **Air-gapped** — fully offline, your infrastructure, your models. Nothing phones home.
  286. - **Adaptive** — your engineers implement requirements directly: domain vocabulary, underserved
  287. languages, custom workflows. No vendor feature queue.
  288. - **Owned, not rented** — deploy once, extend without asking permission. No per-seat tax.
  289. - **Scales inside your walls** — thousands of isolated agents in parallel on Docker or your
  290. Kubernetes/OpenShift cluster.
  291. **Evaluate it for your org** — the artifacts a security review asks for, in this repo:
  292. | Artifact | What it answers |
  293. |---|---|
  294. | [`architecture.calm.json`](architecture.calm.json) | machine-readable architecture (FINOS **CALM**) — every service and data flow, drift-gated in CI |
  295. | [`SECURITY.md`](SECURITY.md) | how to report a vulnerability |
  296. | [`security-insights.yml`](security-insights.yml) | OpenSSF Security Insights manifest |
  297. | [`license-exceptions.json`](license-exceptions.json) | license gating: Category-A permissive deps, exceptions explicit |
  298. | [`LICENSE`](LICENSE) | Apache-2.0 |
  299. Full review page: [Security & compliance](https://docs.vexa.ai/security-compliance) in the docs.
  300. > Regulated banks and Fortune-500s run Vexa fully air-gapped on their own OpenShift and local LLMs today.
  301. ---
  302. ## 📡 API reference
  303. Two APIs behind the gateway, authenticated with `X-API-Key`. Base URL: `http://localhost:18056`
  304. (self-host) or `https://api.cloud.vexa.ai` (hosted).
  305. **Meetings API** — capture; usable standalone:
  306. | Method | Endpoint | Description |
  307. |---|---|---|
  308. | `POST` | `/bots` | Send a bot into a meeting (`platform`, `native_meeting_id`, `bot_name`, `language`, `task`, optional `transcribe_enabled` / `recording_enabled`) |
  309. | `GET` | `/transcripts/{platform}/{native_meeting_id}` | Fetch the real-time transcript (poll while live) |
  310. | `GET` | `/bots/status` | List running bots |
  311. | `DELETE` | `/bots/{platform}/{native_meeting_id}` | Stop / remove the bot |
  312. | `GET` | `/meetings` · `/recordings` | List meetings; list recordings (audio in your own storage) |
  313. **Agent API** — the control plane, under the `/agent/*` prefix (identity is derived from your key, server-side):
  314. | Method | Endpoint | Description |
  315. |---|---|---|
  316. | `POST` | `/agent/chat` | Chat over your workspace — streams SSE (`message-delta`, `tool-call`, `commit`, `done`, `error`) |
  317. | `POST` | `/agent/invocations` | Dispatch a one-shot agent (e.g. a post-meeting report) |
  318. | `POST` | `/agent/routines` | Create a scheduled (cron) agent routine |
  319. | `POST` | `/agent/events` | Fire an integration event that dispatches an agent (e.g. email triage) |
  320. | `GET` | `/agent/workspace/tree` · `/agent/workspace/file` | Browse and read your Markdown workspace |
  321. `platform` ∈ `google_meet` · `teams` · `zoom` · `jitsi`. The gateway also serves an **MCP endpoint**
  322. at `/mcp` for agent clients ([docs](https://docs.vexa.ai/vexa-mcp)). Full reference:
  323. **[docs.vexa.ai](https://docs.vexa.ai)**.
  324. > **v0.12 note:** live bot-control — `PUT /bots/{…}/config` (change language/task mid-call) and
  325. > `POST /bots/{…}/speak` (TTS into the call) — plus WebSocket streaming are not yet wired in the
  326. > open-core stack and return `404` today. So do `POST /agent/meeting/{start,process}`, the removed
  327. > in-product meeting copilot. Send-a-bot, stop, status, transcripts, recordings, the live transcript
  328. > feed, agent chat, routines, and events are live.
  329. ---
  330. ## 🗺️ Status & roadmap
  331. Honest state of the **0.12** line (mirrors the [status page](https://docs.vexa.ai/roadmap/status) — never aspirational):
  332. | Capability | State |
  333. |---|---|
  334. | Bot joins **Meet / Teams / Zoom** | ✅ Production |
  335. | Bot joins **Jitsi Meet** (meet.jit.si + self-hosted) | 🆕 Built & offline-proven; live validation pending |
  336. | Real-time transcription (Whisper) + speaker attribution | ✅ Production — attribution is not guaranteed: the binder publishes an empty speaker rather than guessing (~4–7% of rows under heavy crosstalk) |
  337. | Redis transcript streaming | ✅ Production |
  338. | Recordings to your own object storage (S3; versitygw in Lite and Compose) | ✅ Available |
  339. | **Runtime — Docker backend** (container per workload) | ✅ Production |
  340. | **Agent chat / routines / events over your workspace** | ✅ Built & proven live |
  341. | Workspace — git Markdown / OKF `kg/` bundle | 🟡 core proven; bucket-backed store landing |
  342. | **Runtime — Kubernetes backend** (Pod per dispatch) | ✅ Lifecycle + per-mount isolation; Helm in `deploy/helm` |
  343. | Live transcript feed as the call runs (+ agent chat over it) | ✅ Built & proven live |
  344. | Calendar sync (ICS) · planned meetings · scheduled auto-join | ✅ Production |
  345. | Shared workspaces & shared meetings (invites, real-time feed) | ✅ Built & proven live |
  346. | Agent chat during a live meeting (live transcript + workspace in context) | ✅ Built & proven live |
  347. | WebSocket transcript multiplex | 🔵 Planned (poll today) |
  348. | At-rest encryption (workspace · transcript · tokens) | 🔵 Planned |
  349. | Mid-call bot config / speak | 🔵 Returns 404 in open-core |
  350. ✅ Production · 🟡 In progress · 🔵 Planned
  351. ---
  352. ## 🤝 Community & contributing
  353. - **Docs** — [docs.vexa.ai](https://docs.vexa.ai)
  354. - **Discord** — [discord.gg/Ga9duGkVz9](https://discord.gg/Ga9duGkVz9)
  355. - **Roadmap** — the [board](https://github.com/orgs/Vexa-ai/projects/2), grouped by contributor
  356. lane, with [milestones](https://github.com/Vexa-ai/vexa/milestones) as the version gates.
  357. - **Contributing** — [how delivery works](https://docs.vexa.ai/governance/delivery): prepared issues
  358. with acceptance tables that *guarantee* merge, and human validation credited as a first-class
  359. contribution (one page, law and how-to together).
  360. - **Contributor rights** — [one rights choice plus DCO](CONTRIBUTOR_RIGHTS.md) for individuals;
  361. private, head-bound authorization when an employer or client owns the work.
  362. - **Issues & PRs** — welcome. See [`SECURITY.md`](SECURITY.md) to report vulnerabilities.
  363. - **Obsidian**: [obsidian-vexa-bridge](https://github.com/rennf93/obsidian-vexa-bridge) turns completed meetings into Obsidian notes or a knowledge graph, a third-party adapter; see [the docs](https://docs.vexa.ai/obsidian).
  364. Vexa is built in the open. If you self-host it, extend it, or run it air-gapped somewhere interesting,
  365. we'd love to hear about it.
  366. ---
  367. ## 📄 License
  368. [Apache-2.0](LICENSE). Own it, run it, fork it, ship it. It's an investment, not a rental.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.