← Back to Portfolio
Project 01 · Agentic AI & RAG

Meet
Companion

An open-source, self-hosted meeting knowledge base. A bot joins your call; what was said comes back as searchable Markdown notes, decisions and action items — on your machine, with the AI model and database you choose. Shipped as a desktop app for Windows, macOS and Linux.

Product Ad

Promotional spot produced for MeetStream, walking through the capture-to-knowledge-base loop.

Overview

Most meeting bots hand you a transcript and forget everything the moment the call ends. A pile of transcripts is an archive, not a memory — nobody reopens forty of them, so decisions get re-debated and action items quietly expire.

Meet Companion closes that gap. A bot joins the Google Meet, Zoom or Teams call through MeetStream; when it ends, the transcript is retrieved automatically, run through your chosen LLM to extract decisions, commitments and action items, and filed as organised Markdown notes you can search by meaning, question with sources, and have an in-call agent recall during the next meeting.

The design constraint that shapes everything else: none of it has to leave your machine. SQLite and a local Ollama model need no API keys at all. Embeddings are always computed locally. Bring your own AI — OpenAI, Anthropic, Gemini, Groq, xAI, Ollama, or any OpenAI-compatible endpoint — and your own database, from local SQLite up to Postgres on Supabase, Neon or Railway.

It ships as a signed-by-you desktop app for Windows, macOS and Linux, a Docker image, or from source. Contributed to the MeetStream organisation and released under MIT.

At a Glance
7+
LLM providers supported
Adapters, not conditionals
261
Automated tests
246 pytest · 15 vitest
3
Desktop platforms built on tag
~40 min from tag to release
384-d
Embeddings, computed locally
all-MiniLM-L6-v2 · ONNX
Architecture

Providers are interfaces, not conditionals — a new LLM vendor is one adapter plus a registry entry, and the adapter’s declared fields are the settings form.

Desktop (Electron) ─┐ Browser ─┼─▶ React UI ─▶ FastAPI ─▶ Services ─▶ Providers MeetStream agent ─▶ MCP server ─┘ (auth gate, │ MeetStream hooks ─▶ /api/webhooks permissions) │ (HMAC) │ ▼ ┌─────────────────────────────────────────────────────────────────┐ │ LLM OpenAI · Anthropic · Gemini · Groq · xAI · Ollama │ │ · any OpenAI-compatible endpoint │ │ Database SQLite (numpy search) │ │ PostgreSQL (pgvector + tsvector) │ │ Capture MeetStream API — bots, transcripts │ └─────────────────────────────────────────────────────────────────┘ Meeting data flow ───────────────── Transcript (webhook or upload) ▼ Segments → participants ▼ LLM extraction → memories + action items (structured JSON, validated; rule-based fallback if the provider fails) ▼ Chunked, embedded locally (all-MiniLM-L6-v2, 384-d) ▼ Markdown note written and filed ▼ Searchable (RRF over vector + keyword) · Ask AI · MCP tools
Key Features
Debugging Note — Agent Silence

The bot would join, record and transcribe perfectly, but the agent itself never produced output — across three different model providers. That pattern pointed hard at a platform bug.

It wasn't. create_bot() was manually injecting socket_connection_url and live_audio_required into the bot-creation payload whenever an agent config was set. Those look like internal bridge endpoints that MeetStream wires up server-side; overriding them broke the agent's audio/text bridge silently. The tell was that the same agent config deployed fine through MeetStream's own API Playground — so the difference had to be in our request, not their platform. Removing both fields fixed it.

Security Note — Closing the Tenant Boundary

The first version had one shared workspace, which was fine while I was the only user. Opening signup turned that into a real data-exposure problem overnight: anyone who created an account could see every meeting already in the system. I closed signup the same day and rebuilt the data model around genuine tenancy — every meeting, memory, document and agent scoped to an organization_id resolved from the caller's session.

The subtler bug surfaced afterwards. Agent activation, agent updates, and the chat relay all accepted a client-supplied agent or meeting ID and performed no ownership check — so one workspace could hijack or overwrite another workspace's live agent, or post into another workspace's meeting chat. Listing agents had the mirror-image flaw, showing every agent on the underlying MeetStream account rather than the ones this workspace created. Both are now ownership-verified server-side, and there is an integration test suite (test_tenant_isolation_integration.py, test_security.py) whose whole job is to fail if that boundary regresses.

Retrieval Note — Recall the Index Was Quietly Dropping

Search kept missing results a human could see were relevant — not ranking them low, omitting them. The ranking layer looked fine, so the fault was upstream of it.

The vector index is ivfflat with lists=100, and pgvector defaults to probes=1 — each query scans roughly 1% of the index's clusters. That's a sane trade at the 100k-row scale the index is tuned for; at a single workspace's real data volume it means genuinely relevant rows are never examined at all. Raising probes to 10 buys back the recall for a small, bounded amount of query time, and still scales as the table grows.

The second half was semantic rather than mechanical. Asking "what did we decide on September 2" was surfacing a meeting from the 3rd where someone recapped the 2nd, ahead of the actual September 2 meeting — both are textually about that date, so pure similarity can't separate them. Results now get a stable date-match boost, and relative words like "yesterday" are resolved when content is indexed, against the meeting's own date rather than the moment of the search. Resolving them at search time instead would make every old transcript saying "yesterday" collide with any query that happens to say it too.

Shipping It

A self-hosted app is only as good as its install story, so the release path is automated end to end. Every push and pull request runs the backend suite twice — once on SQLite, once on PostgreSQL with pgvector — because the database is a swappable provider and a green run on one proves nothing about the other. The same workflow lints, tests and builds the frontend, runs pip-audit, and builds the Docker image and boots it, so a broken container fails CI rather than a user's first launch.

Tagging v* stamps the version from the tag, freezes the server with PyInstaller, and builds and attaches Windows, macOS and Linux installers to a GitHub release — roughly 40 minutes from tag to published. First launch needs no .env, no database setup and no migrations: the app writes its own config and upgrades its own schema.

Tech Stack
Backend
Python 3.12 FastAPI SQLAlchemy 2 (async) Alembic httpx
Data & Retrieval
SQLite PostgreSQL + pgvector tsvector Local ONNX embeddings all-MiniLM-L6-v2 Reciprocal Rank Fusion
AI Providers
OpenAI Anthropic Gemini Groq xAI Ollama
Frontend & Desktop
React 19 Vite Tailwind CSS 4 Electron PyInstaller
Integration
MeetStream bots MCP server HMAC-signed webhooks
Testing & CI
pytest vitest oxlint pip-audit Docker GitHub Actions
Interface

The desktop build on Windows — the same app runs from Docker or source in a browser.