What Is Zackriya-Solutions/meetily? A Privacy-First AI Meeting Assistant

Meetily is a privacy-first AI meeting assistant that runs entirely on your local machine, capturing audio, transcribing speech with Whisper, and generating meeting summaries using locally-hosted LLMs—no cloud processing required.

This open-source desktop application from Zackriya-Solutions eliminates the privacy risks of cloud-based meeting tools by keeping all data on-device. Built with Tauri 2.x and Rust for the core engine, with a Next.js 14 frontend, Meetily processes microphone and system audio without sending anything to external servers.

What Makes Meetily Different from Cloud Meeting Tools

Most AI meeting assistants transmit audio to remote servers for transcription and analysis. Meetily inverts this model: it runs OpenAI Whisper locally for speech-to-text and connects to on-device LLMs via Ollama, Claude, or Groq APIs for summarization.

The architecture removes:

• External FastAPI backends
• Cloud transcription services
• Third-party data storage

Everything happens in the Tauri runtime, with SQLite for local persistence.

Core Architecture: Rust Backend + React Frontend

Meetily follows a split architecture common in modern desktop apps:

Layer	Technology	Responsibility
Desktop UI	Next.js 14 / React 18	Recording interface, settings, meeting history
Bridge	Tauri 2.x	Command registration, event emission between layers
Audio Engine	Rust + CPAL/StreamCapture	Device capture, mixing, VAD filtering
Transcription	Rust + Whisper.cpp	Model loading, GPU/CPU inference
Summarization	Rust + LLM clients	Ollama/Claude/Groq integration
Storage	SQLite + IndexedDB	Local data persistence

The frontend/src-tauri/src/lib.rs file registers all Tauri commands and initializes the application runtime, as shown in this command definition:

// frontend/src-tauri/src/lib.rs
#[tauri::command]
async fn start_recording<R: Runtime>(
    app: AppHandle<R>,
    mic_device_name: Option<String>,
    system_device_name: Option<String>,
    meeting_name: Option<String>,
) -> Result<(), String> {
    audio::recording_commands::start_recording(app, mic_device_name, system_device_name, meeting_name).await
}

Audio Capture and Processing Pipeline

The frontend/src-tauri/src/audio/pipeline.rs module handles the most complex task: capturing both microphone and system audio simultaneously, mixing them professionally, and applying Voice Activity Detection (VAD) to filter silence.

Key capabilities:

• Device discovery across platforms
• Professional mixing of multiple audio sources
• Real-time VAD to reduce transcription load
• Cross-platform backends: ScreenCaptureKit/Metal (macOS), WASAPI/CUDA/Vulkan (Windows), PulseAudio/ALSA (Linux)

The high-level orchestration lives in recording_manager.rs, which coordinates a complete recording session from start to finish.

On-Device Transcription with Whisper

Meetily's transcription engine in frontend/src-tauri/src/whisper_engine/whisper_engine.rs loads Whisper models and handles hardware acceleration automatically:

// frontend/src-tauri/src/whisper_engine/whisper_engine.rs
pub async fn load_model(&self, model_name: &str) -> Result<()> {
    // Detects Metal on macOS, CUDA/Vulkan on Windows/Linux,
    // falls back to CPU if no GPU is available.
    // Model is cached for the session.
}

The engine:

1. Detects available GPU backends (Metal, CUDA, Vulkan)
2. Falls back to CPU inference when necessary
3. Caches loaded models for session reuse
4. Streams transcription results to the UI via Tauri events

Local LLM Summarization Engine

After transcription, the frontend/src-tauri/src/summary/summary_engine/model_manager.rs handles meeting summarization. It supports multiple LLM providers:

Provider	Connection Method	Use Case
Ollama	Local HTTP API	Fully offline, runs models like Llama 3
Claude	API key (user-configured)	High-quality summaries with cloud opt-in
Groq	API key (user-configured)	Fast inference for users who accept remote processing

The model manager abstracts provider differences, allowing users to switch backends without changing the summarization pipeline.

Frontend Integration: React + Tauri Commands

The Next.js frontend in frontend/src/app/page.tsx invokes Rust commands and listens for events:

Starting a recording:

// frontend/src/app/page.tsx
await invoke('start_recording', {
  mic_device_name: "Built‑in Microphone",
  system_device_name: "BlackHole 2ch",
  meeting_name: "Team Stand‑up"
});

Receiving live transcription updates:

// frontend/src/app/_components/TranscriptPanel.tsx
await listen<TranscriptUpdate>('transcript-update', event => {
  setTranscripts(prev => [...prev, event.payload]);
});

The component structure follows standard React patterns, with the Tauri bridge providing type-safe IPC between JavaScript and Rust.

Local Data Storage and Persistence

Meetily stores all data locally using two mechanisms:

1. SQLite (primary): Meeting metadata, transcripts, settings in frontend/src-tauri/src/database/mod.rs
2. IndexedDB (fallback): Browser-based recovery storage when native access is unavailable

The database module handles schema migrations and provides query helpers for the rest of the application.

Legacy Backend Archive

The repository contains a backend/ directory with a Python/FastAPI implementation. Per the project documentation, this is archived for reference only—the current supported product does not use it. All development and deployment targets the Tauri-based desktop app.

This is confirmed in CLAUDE.md and frontend/README.md, which specify that no FastAPI service is required for building or running the application.

Key Source Files Reference

File Path	Purpose
frontend/src-tauri/src/lib.rs	Tauri command registration and app initialization
frontend/src-tauri/src/audio/pipeline.rs	Audio capture, mixing, and VAD processing
frontend/src-tauri/src/audio/recording_manager.rs	Recording session lifecycle management
frontend/src-tauri/src/whisper_engine/whisper_engine.rs	Whisper model loading and inference
frontend/src-tauri/src/summary/summary_engine/model_manager.rs	LLM provider abstraction and summarization
frontend/src-tauri/src/database/mod.rs	SQLite schema and persistence layer
frontend/src/app/page.tsx	Main recording interface
frontend/src/components/Sidebar/index.tsx	Meeting history and navigation
docs/architecture.md	System design documentation
CLAUDE.md	Development patterns and project overview

Summary

• Meetily is a fully local AI meeting assistant from Zackriya-Solutions with no cloud dependencies
• Tauri 2.x + Rust powers the backend; Next.js 14 provides the UI
• Whisper runs on-device for transcription with automatic GPU/CPU selection
• Ollama, Claude, or Groq integrate for summarization based on user preference
• SQLite stores all data locally; no external backend required
• The backend/ Python code is legacy only—current development targets the Tauri app

Frequently Asked Questions

Does Meetily send my meeting audio to the cloud?

No. All audio processing, transcription, and summarization run locally on your machine. The Whisper model loads in frontend/src-tauri/src/whisper_engine/whisper_engine.rs and executes entirely in-process. You can verify this in the source code—no network calls transmit audio data.

Can I use Meetily without an internet connection?

Yes, with Ollama. Install a local LLM through Ollama, configure it in settings, and Meetily operates fully offline. Claude and Groq providers require internet access but still process transcripts rather than raw audio.

Why is there a Python backend folder if it's not used?

The backend/ directory contains a legacy FastAPI implementation from earlier development. According to CLAUDE.md and frontend/README.md, this code is archived for reference and not part of the supported product. The current architecture uses Tauri's Rust backend exclusively.

What hardware acceleration does Meetily support?

The transcription engine in whisper_engine.rs automatically detects and uses Metal on macOS, CUDA or Vulkan on Windows and Linux, with CPU fallback. GPU acceleration significantly improves transcription speed for longer meetings.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}