Every week, I sit through at least six to eight meetings. Some are quick stand-ups with my dev team. Others are hour-long planning sessions with stakeholders from different government agencies. And every single time, someone asks the same thing afterward: “Can you send me the minutes?”
I used to scribble notes furiously, miss half the conversation, and end up with a messy bullet list that didn’t capture context. Then I tried cloud-based transcription tools — Otter, Fireflies, you name it. They worked, but every time I uploaded a recording to someone else’s server, that uneasy feeling crept in. Our meetings cover sensitive government IT procurement discussions, infrastructure plans, and sometimes personnel matters. Having that audio sit on a third-party server in who-knows-which data center just didn’t sit right.
That’s when I found Meetily — an open-source, privacy-first AI meeting assistant that runs entirely on your own hardware. No cloud uploads. No bots joining your calls. Just your machine, a Whisper model, and optionally a local LLM for summarization. It’s the kind of tool I wish existed years ago.
What Is Meetily?
Meetily is a desktop application built with Tauri (Rust backend + Next.js frontend) that captures your system audio, transcribes it locally using OpenAI Whisper or NVIDIA Parakeet, and generates AI summaries using your choice of LLM provider. It’s MIT-licensed, has over 15,000 GitHub stars, and processes everything offline if you want it to.
Here’s what makes it different from the competition:
- Bot-free architecture — It captures system audio directly, so no “Meetily Bot” appears in your meeting. Other participants won’t even know you’re recording (check local laws, of course).
- 100% local processing — Audio never leaves your machine. The transcription runs on Whisper.cpp or Parakeet, both fully on-device.
- Pluggable AI summarization — Use Ollama for fully local summaries, or connect Claude, Groq, or any OpenAI-compatible endpoint.
- GPU acceleration — Metal on Apple Silicon, CUDA on NVIDIA, Vulkan on AMD/Intel.
- Import existing recordings — Already have a meeting recording? Import it and let Meetily transcribe and summarize it retroactively.
The Community Edition is free and open source forever. A Pro tier adds higher accuracy models, custom templates, advanced exports, and self-hosted team deployment at $10/user/month.
What You’ll Need
Meetily is surprisingly lightweight. Here are the specs:
- Minimum: 8GB RAM, 4-core CPU, 10GB free storage
- Recommended: 16GB RAM, 8-core CPU, GPU acceleration, 50GB SSD
- OS: Windows 10+, macOS 12+, or Linux (build from source)
For the Ollama integration (local AI summarization), you’ll want at least 16GB of RAM so you can run a 7B-8B model alongside the transcription engine.
Method 1: Desktop Installation (Easiest, 10 Minutes)
This is the path I recommend for most people. No servers, no Docker, no configuration files — just download and run.
Windows
Head over to the GitHub Releases page and download the latest x64-setup.exe. Run the installer — that’s it. Meetily will walk you through model selection on first launch, downloading the Whisper model of your choice.
macOS
Two options here. The manual route: download meetily_0.4.0_aarch64.dmg (for Apple Silicon) or the Intel variant from the same Releases page, open it, and drag Meetily to your Applications folder.
The cleaner route is Homebrew:
brew tap zackriya-solutions/meetily
brew install --cask meetily
After installation, start the backend server with:
meetily-server --language en --model medium
Linux
Linux requires building from source, but the Docker method (covered next) is usually easier. If you want native performance:
git clone https://github.com/Zackriya-Solutions/meeting-minutes
cd meeting-minutes/frontend
pnpm install
./build-gpu.sh
Method 2: Docker Deployment (For Self-Hosted Servers)
If you want to run Meetily as a service on a server — say, on a home lab or a VPS — Docker is the way to go. The team recently added full Docker support with automated scripts.
git clone https://github.com/Zackriya-Solutions/meeting-minutes
cd meeting-minutes/backend
# For CPU-only (works on any machine):
./build-docker.sh cpu
./run-docker.sh start --interactive
# For NVIDIA GPU acceleration:
./build-docker.sh cuda
./run-docker.sh start --interactive
This spins up two services: a transcription backend on port 8178 and a web interface on port 5167. The --interactive flag launches a guided setup where you choose your model size and language.
One thing I’ll note: the Docker approach is about 20-30% slower than native installation according to the project’s benchmarks. For a personal setup on your daily driver, the desktop app is the better choice. Docker shines when you want a team-wide deployment or a server that’s always on.
Setting Up Local AI Summarization with Ollama
This is where Meetily really shines. Instead of sending your meeting notes to OpenAI or Anthropic for summarization (defeating the privacy purpose), you can run a local LLM through Ollama.
If you’ve read my guide on running AI models locally with Ollama, this will feel familiar. If not, here’s the quick version:
# Install Ollama (Linux/macOS)
curl -fsSL https://ollama.com/install.sh | sh
# Pull a good summarization model
ollama pull llama3.1:8b
# Or for faster performance on modest hardware
ollama pull phi4:latest
Once Ollama is running, open Meetily’s settings and go to Model Settings. Select Ollama from the provider dropdown — Meetily will auto-detect the models available on your local Ollama server. Pick one and save.
That’s it. Every meeting summary from that point on is generated entirely on your machine. No API calls, no data leaving your network, no per-token costs.
Alternative: Use a Custom OpenAI-Compatible Endpoint
If you’re running LM Studio, vLLM, or Open WebUI alongside Ollama, Meetily supports custom OpenAI-compatible endpoints too. In Model Settings, choose Custom Server (OpenAI) and point it to your local endpoint (e.g., http://localhost:1234/v1 for LM Studio).
Using Meetily Day-to-Day
The workflow is refreshingly simple:
- Join your meeting as usual (Zoom, Meet, Teams — doesn’t matter, Meetily captures system audio directly).
- Click the Record button in Meetily.
- Go through your meeting normally — Meetily transcribes in real time with under 2 seconds of latency.
- When the meeting ends, stop recording. Meetily generates a summary using your chosen template and LLM provider.
- Export as PDF, DOCX, or Markdown. Or search through past transcripts right in the app.
The real-time transcription is surprisingly accurate. I tested it with a mix of Filipino-accented English (my default) and American English speakers in the same call, and Whisper large-v3 handled both with maybe one or two errors per five-minute segment. Parakeet from NVIDIA is noticeably faster — about 4x according to the benchmarks — though I found Whisper slightly more accurate with non-native accents.
One feature I didn’t expect to use as much as I do: the import audio option. I have a folder of old meeting recordings from pre-Meetily days that I never got around to transcribing. I just drag them in, pick a model, and minutes later I have searchable transcripts. It’s like getting a time machine for your past meetings.
Privacy and Compliance — Why This Matters
I’ve dealt with enough government IT compliance paperwork to know that “the data stays on-premises” is not a nice-to-have — it’s often a legal requirement. Meetily’s architecture makes compliance straightforward because there’s nothing to audit on the cloud side. No data leaves the device unless you explicitly configure a remote LLM endpoint.
The numbers back up why this matters:
- The average cost of a data breach was $4.4 million in 2024 (IBM).
- Over €5.88 billion in GDPR fines had been issued by 2025.
- Hundreds of unlawful recording cases are filed annually in California alone.
Running transcription locally eliminates an entire category of risk. There’s no third-party server to compromise, no cloud storage bucket to misconfigure, no vendor to trust with your meeting content.
If you’re building privacy-respecting tools or workflows, the same principles apply — as I covered in my guide on self-hosting SearXNG, keeping data on your own infrastructure is the gold standard for privacy.
Limitations Worth Knowing
I always believe in being honest about trade-offs, so here are the things Meetily doesn’t do well (yet):
- Speaker diarization — The Community Edition labels speakers as Speaker 1, Speaker 2, etc., but doesn’t identify them by name. The Pro version has this coming “mid-June” as of this writing.
- No mobile app — Desktop only for now. A mobile companion is on the roadmap.
- RAM usage — Running Whisper large-v3 plus a 8B LLM for summarization can push you past 12GB of RAM. If you have 8GB, stick with Whisper base or tiny and a smaller Phi-4 model.
- No native Linux desktop app — Linux users need Docker or build from source. A native Linux build is apparently in the works.
Wrapping Up
Meetily is one of those rare open-source projects that nails both the privacy promise and the user experience. It’s not just a “self-hosted alternative” that you tolerate because you care about privacy — it’s genuinely good software that happens to be private by design.
If you’re tired of meeting bots, worried about sensitive conversations ending up on someone else’s servers, or just want a transcription tool that works offline, give Meetily a shot. The Community Edition is free, and you can have it running in ten minutes.
For more on running local AI tools, check out my guide on building your first MCP server with Python — it pairs nicely with a local-first workflow like Meetily’s. And if you’re evaluating how AI fits into your development process, my guide on reviewing AI-generated code might help you think about quality in automated outputs.
Meetily Community Edition is available under the MIT License on GitHub. This article was written independently — no sponsorship, just a tool I found genuinely useful.