# Vexa
**Open-source meeting bots and real-time transcription β cloud or fully self-hosted.**
A bot joins your Google Meet, Microsoft Teams, and Zoom calls and streams speaker-attributed
transcripts in real time β through our API or one *you* host β then feeds sandboxed agents that build
a Markdown knowledge base your team owns. Apache-2.0, air-gap-ready. (Jitsi: join + capture
offline-proven, live validation pending β [#883](https://github.com/Vexa-ai/vexa/issues/883).)
[](LICENSE)
[](#οΈ-status--roadmap)
[](#-quickstart)
[](https://discord.gg/Ga9duGkVz9)
**[vexa.ai](https://vexa.ai)** runs Vexa 0.12 for meeting bots and transcription.
Sandboxed knowledge agents are self-hosted only β [self-host Vexa](#-quickstart) to run the full stack.
---
## Why Vexa
Every meeting-AI tool you can buy sends your conversations to *their* cloud and rents you
access back. Vexa inverts that: run the stack yourself, point it at your own models, own what
your meetings become.
No one else has all three:
1. **Vexa is *in* the meeting.** A real bot joins Meet, Teams and Zoom β Jitsi offline-proven, live
validation pending β and streams speaker-attributed transcripts live. That bot fleet is the
genuinely hard part β every "chat with your docs" tool starts *after* a transcript exists. Vexa
produces it.
2. **Your knowledge is files you own.** Meetings compile into Markdown in a git repo β
portable, diffable, greppable. Knowledge as code.
3. **Agents work it, safely.** Sandboxed coding agents read and write that repo like
developers β isolated ephemeral containers, no egress, thousands in parallel, on Docker
or your Kubernetes.
> **Only here for the transcription API?** It's a complete standalone product β send a bot,
> read the stream, ignore the agent lane entirely.
---
## β‘ Quickstart
**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:
```bash
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 **$5 of free bot credit, no card required** β about 16 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**.
```bash
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:
```text
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
```bash
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.
---
## 𧩠How it works
One gateway, two domains β **Meetings** (capture) and **Agents** (work the knowledge) β both running on
the same **runtime**: the engine that spawns every bot and every agent in its own sandboxed container.
