Meetily: a local-first open-source AI meeting assistant

Meetily is an AI meeting assistant focused on privacy and local processing. It captures meeting audio on your machine, transcribes it in real time, and then uses AI to generate meeting summaries.

The problem is practical: meeting audio and transcripts often contain customer data, code, financial details, medical or legal information, and internal decisions. Meetily keeps transcription, storage, and optionally summarization closer to your own device or infrastructure.

What Meetily is

Meetily describes itself as a privacy-first AI meeting assistant with real-time transcription, summaries, local processing, and self-hosting. The repository is MIT licensed, mainly written in Rust, and uses Tauri plus Next.js for the desktop app.

It mainly does four things:

• captures microphone and system audio;
• runs local speech-to-text with Whisper or Parakeet;
• stores meeting metadata, transcripts, and summaries;
• generates minutes with Ollama, local models, or other LLM providers.

It supports macOS, Windows, and Linux. Some README links still use the old meeting-minutes repository name, so prefer the current GitHub page and official site when downloading.

Who it is for

Meetily fits users who do not want recordings or transcripts to leave the machine, teams replacing cloud meeting bots, organizations with compliance or confidentiality requirements, users who want Ollama or an internal OpenAI-compatible endpoint, and developers studying a Tauri + Rust + Next.js local AI app.

If you only meet occasionally and do not care about cloud upload, SaaS tools are easier. Meetily is about control, not zero setup.

Main features

Local-first

Transcription models, recordings, transcripts, and summaries can stay on the local machine. For professional teams, that makes the data boundary easier to explain.

Real-time transcription

Meetily can generate transcripts while a meeting is running. The README mentions Whisper and Parakeet models and emphasizes that cloud transcription is not required.

Parakeet is attractive for speed; Whisper has a broader ecosystem and more references. The right choice depends on OS, GPU, language, and accuracy needs.

AI summaries

Meetily can send transcripts to an LLM for summaries. Listed providers include:

• Ollama, for local-first use;
• Claude;
• Groq;
• OpenRouter;
• OpenAI;
• custom OpenAI-compatible endpoints.

For maximum locality, start with Ollama. If your organization has a model gateway, use the OpenAI-compatible endpoint path.

Audio mixing

The README mentions microphone plus system audio capture, audio mixing, ducking, and clipping prevention. This matters because recording only the microphone often misses other speakers, while recording only system audio may miss your own voice.

Import and re-transcription

Import & Enhance can import existing audio files, create transcripts, and re-transcribe meetings with a different model or language. This is useful for old recordings or important meetings that deserve a more accurate rerun.

Rough architecture

Meetily is a Tauri desktop app:

• frontend: Next.js for meeting management, transcript display, and settings;
• backend: Rust Core exposed through Tauri commands;
• Audio Engine: microphone and system audio capture;
• Transcription Engine: local speech-to-text models;
• Database: local SQLite for metadata, transcripts, and summaries;
• Summary Engine: Ollama or another LLM provider.

The tradeoff is familiar: the desktop app stays relatively light, but building from source means dealing with Node.js, Rust, Tauri, system audio permissions, model dependencies, and GPU acceleration.

Installation

Normal users should download a release package.

Windows

Download the latest x64-setup.exe and run the installer.

The README still points to:

1

https://github.com/Zackriya-Solutions/meeting-minutes/releases/latest

If that changes, start from:

1
2

https://github.com/Zackriya-Solutions/meetily
https://meetily.ai

macOS

Download the .dmg, for example:

1

meetily_0.4.0_aarch64.dmg

Install it like a normal macOS app:

1. open the .dmg;
2. drag Meetily to Applications;
3. launch it from Applications.

Apple Silicon machines are a good fit for local AI because unified memory and Metal acceleration help the local-model experience.

Linux

Linux mainly uses source builds. The README quick start is:

1
2
3
4

git clone https://github.com/Zackriya-Solutions/meeting-minutes
cd meeting-minutes/frontend
pnpm install
./build-gpu.sh

The current repository is:

1

git clone https://github.com/Zackriya-Solutions/meetily

If old commands redirect or directory names differ, confirm the current build script location first.

Building from source

docs/BUILDING.md covers Linux, macOS, and Windows.

Linux dependencies

Ubuntu/Debian:

1
2

sudo apt update
sudo apt install build-essential cmake git

Fedora/RHEL:

1

sudo dnf install gcc-c++ cmake git

Arch Linux:

1

sudo pacman -S base-devel cmake git

Development and production builds:

1
2

./dev-gpu.sh
./build-gpu.sh

macOS build

Install Homebrew dependencies:

1

brew install cmake node pnpm

Then run:

1
2

pnpm tauri:dev
pnpm tauri:build

The docs say macOS uses Metal GPU acceleration by default.

Windows build

Windows needs Node.js, Rust, Visual Studio Build Tools with the Desktop development with C++ workload, and CMake.

1
2

pnpm tauri:dev
pnpm tauri:build

The docs describe Windows as CPU-only by default. For GPU acceleration, see docs/GPU_ACCELERATION.md.

Understanding GPU acceleration

The Linux scripts try to detect GPU support:

A display driver is not enough. For CUDA, at least verify:

1
2

nvidia-smi
nvcc --version

You can force a backend with TAURI_GPU_FEATURE:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

TAURI_GPU_FEATURE=cuda ./dev-gpu.sh
TAURI_GPU_FEATURE=cuda ./build-gpu.sh

TAURI_GPU_FEATURE=vulkan ./dev-gpu.sh
TAURI_GPU_FEATURE=vulkan ./build-gpu.sh

TAURI_GPU_FEATURE=hipblas ./dev-gpu.sh
TAURI_GPU_FEATURE=hipblas ./build-gpu.sh

TAURI_GPU_FEATURE="" ./dev-gpu.sh
TAURI_GPU_FEATURE="" ./build-gpu.sh

Real-time transcription depends heavily on CPU/GPU, memory, model size, and audio length. Test with a short recording first.

Choosing a summary model

Transcription and summarization are separate. Speech-to-text cares about accuracy, language support, and speed; summarization cares about turning a long transcript into decisions, action items, and useful minutes.

For privacy-first use:

• transcription: local Whisper or Parakeet;
• summary: Ollama local model;
• storage: local SQLite;
• network: avoid cloud providers where possible.

For better summaries, keep transcription local but send transcripts to Claude, OpenRouter, Groq, OpenAI, or an internal OpenAI-compatible endpoint. That changes the privacy boundary because the transcript leaves the machine.

Community Edition vs PRO

The README says Meetily Community Edition will remain free and open source. Meetily PRO targets professional users and teams with higher transcription accuracy, custom summary templates, advanced export, automatic meeting detection, self-hosted deployment, and team features.

Community Edition is best for individuals, local-first use, open-source use, and customization. PRO is for teams that need stronger workflow, export, and deployment management.

Things to watch

Recording meetings can have legal and company-policy requirements. Confirm notice and consent rules before using any recording tool.

Local-first also does not mean zero risk. Once recordings and summaries are stored locally, think about disk encryption, backups, access control, and device loss.

AI summaries are not the meeting record. Keep the original transcript for important meetings and review final minutes manually.

Some README links still contain meeting-minutes; use the current repository and official site when release names or directories differ.

Summary

Meetily matters because it moves the meeting AI pipeline back toward the local machine: capture, transcription, storage, and optionally summarization. For privacy- and compliance-sensitive teams, that is more controllable than a convenient but opaque cloud bot.

It is not a no-setup tool. Start with a release package to test transcription and summary quality, then decide whether source builds, GPU tuning, or internal model integration are worth the engineering time.