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

> Discover Meetily, a privacy-first AI meeting assistant. Enjoy local audio capture transcription with Whisper and LLM summaries. No cloud processing needed for secure meetings.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: overview
- Published: 2026-08-03

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) file registers all Tauri commands and initializes the application runtime, as shown in this command definition:

```rust
// 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs) loads Whisper models and handles hardware acceleration automatically:

```rust
// 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) invokes Rust commands and listens for events:

Starting a recording:

```typescript
// 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:

```typescript
// 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/CLAUDE.md) and [`frontend/README.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) | Tauri command registration and app initialization |
| [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) | Audio capture, mixing, and VAD processing |
| [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs) | Recording session lifecycle management |
| [`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs) | Whisper model loading and inference |
| [`frontend/src-tauri/src/summary/summary_engine/model_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/summary_engine/model_manager.rs) | LLM provider abstraction and summarization |
| [`frontend/src-tauri/src/database/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/database/mod.rs) | SQLite schema and persistence layer |
| [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) | Main recording interface |
| [`frontend/src/components/Sidebar/index.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/components/Sidebar/index.tsx) | Meeting history and navigation |
| [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md) | System design documentation |
| [`CLAUDE.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/CLAUDE.md) and [`frontend/README.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.