# Meetily Project Goals: Privacy-First AI Meeting Automation

> Discover Meetily's project goals: a privacy-first AI meeting assistant that transcribes and summarizes meetings locally, keeping your data secure on your device.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: getting-started
- Published: 2026-07-08

---

**Meetily is built to deliver a privacy-first, AI-powered meeting assistant that captures, transcribes, and summarizes meetings entirely on your local machine, ensuring sensitive audio and transcript data never leaves your device.**

Meetily is an open-source meeting automation tool developed by Zackriya Solutions. The core Meetily project goals center on eliminating cloud dependencies while providing professional-grade transcription and summarization capabilities. By leveraging a Tauri-based architecture (Rust + Next.js) and local AI models, Meetily ensures complete data sovereignty for users who cannot risk leaking confidential meeting content to third-party services.

## Complete Data Sovereignty

The foundational goal of Meetily is **keeping all meeting data on the user's machine**. According to the project's README, Meetily "captures, transcribes, and summarizes meetings entirely on your local machine"【^1†L69-L73】, meaning no audio streams, transcripts, or AI-generated summaries are transmitted to external APIs or cloud storage.

This local-only approach is enforced through:

- **Local SQLite database** for meeting metadata and transcripts (`frontend/src-tauri/src/database/`).
- **On-device AI inference** using locally-hosted Whisper and Parakeet models for transcription.
- **Offline-capable LLM integration** via Ollama or other local endpoints, avoiding network calls for summary generation.

## Real-Time Local Transcription

Meetily targets real-time speech-to-text processing without relying on cloud transcription services. The [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md) file identifies a dedicated **Transcription Engine**【^2†L39-L40】 that processes mixed audio streams through local models.

The implementation supports multiple transcription backends:

| Engine | Location | Purpose |
|--------|----------|---------|
| **Whisper** | `frontend/src-tauri/src/whisper_engine/` | OpenAI Whisper local inference for high-accuracy transcription |
| **Parakeet** | `frontend/src-tauri/src/parakeet_engine/` | Alternative optimized transcription engine |

Both engines run entirely on-device, processing audio captured in real-time from microphone and system sources.

## AI-Driven Meeting Summaries

Beyond transcription, Meetily generates structured meeting minutes using the **Summary Engine**【^2†L41-L42】. This component processes completed transcripts through local or remote LLMs to extract action items, key decisions, and concise summaries.

The summary system offers **flexible AI provider support**, allowing users to configure:
- **Ollama** for completely local inference
- **Claude, Groq, OpenRouter**, or any OpenAI-compatible API endpoint

When using remote providers, only the transcript text (not raw audio) is sent, and users retain full control over which provider—if any—they trust with their data.

## Cross-Platform GPU Acceleration

Performance optimization across diverse hardware is a critical project goal. Meetily automatically detects and leverages hardware acceleration to ensure real-time transcription remains responsive:

- **Apple Silicon**: Metal/CoreML support for M-series chips
- **NVIDIA GPUs**: CUDA acceleration for Whisper inference
- **Vulkan**: Cross-platform GPU compute support for Linux and Windows

This acceleration applies to both the transcription pipeline and local LLM inference, making the privacy-first approach practical for everyday use.

## Professional Audio Engineering

Meetily aims for broadcast-quality audio capture through **dual-stream processing** (microphone + system audio). The [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) module implements intelligent ducking and clipping prevention, ensuring clear recordings even when multiple participants speak simultaneously.

The audio pipeline mixes both sources into a single stream optimized for speech recognition, handling "intelligent ducking and clipping prevention"【^1†L82-L85】 to maintain transcription accuracy.

## Implementation: How Meetily Achieves These Goals

### Starting Local Recording Sessions

The Tauri backend exposes native recording capabilities through commands registered in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs). The frontend invokes these commands to initiate capture:

```typescript
import { invoke } from '@tauri-apps/api/tauri';

async function startMeetingRecording() {
  try {
    await invoke('start_recording_with_devices_and_meeting', {
      mic_device_name: 'Built‑in Microphone',
      system_device_name: 'BlackHole 2ch',
      meeting_name: 'Team Stand‑up',
    });
    console.log('Recording started');
  } catch (e) {
    console.error('Failed to start recording', e);
  }
}

```

The corresponding Rust command `start_recording_with_devices_and_meeting` is defined in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs)【^3†L6-L13】【^3†L86-L92】, handling device selection and pipeline initialization.

### Audio Device Discovery

Before recording, the application lists available input devices through the `get_audio_devices` command:

```typescript
import { invoke } from '@tauri-apps/api/tauri';

async function listAudioDevices() {
  const devices = await invoke('get_audio_devices');
  console.table(devices);
}

```

On the Rust side, this command forwards to `audio::list_audio_devices()`【^3†L84-L90】, enumerating system audio sources for user selection.

### Generating AI Summaries Locally

The summary workflow demonstrates how Meetily processes transcripts without external dependencies when using local LLMs:

```rust
use tauri::Manager;

#[tauri::command]
async fn generate_summary(app: tauri::AppHandle) -> Result<String, String> {
    // Calls the summary engine (wraps Ollama, Claude, etc.)
    summary::commands::api_process_transcript(&app, /* transcript ID */ 1).await?;
    let summary = summary::commands::api_get_summary(&app, 1).await?;
    Ok(summary)
}

```

These commands (`api_process_transcript` and `api_get_summary`) are exposed via [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs)【^3†L61-L66】, interacting with the summary engine under `frontend/src-tauri/src/summary/` to generate meeting minutes using the configured AI provider.

## Summary

Meetily's project goals deliver a **self-contained meeting workflow** that respects user privacy and maintains high performance:

- **Zero-cloud architecture**: All audio, transcripts, and AI processing remain local by default
- **Real-time transcription**: Whisper and Parakeet engines run on-device with GPU acceleration
- **Flexible AI integration**: Support for Ollama (local) or remote LLM providers via configurable endpoints
- **Professional audio**: Dual-stream capture with intelligent mixing and ducking via [`audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/audio/pipeline.rs)
- **Cross-platform support**: Native acceleration for Apple Silicon, NVIDIA CUDA, and Vulkan hardware

## Frequently Asked Questions

### Does Meetily send my meeting data to the cloud?

No. By default, Meetily operates as a completely local application. Audio capture, transcription, and summarization occur on your machine using local models (Whisper/Parakeet) and local LLMs via Ollama. The README explicitly states that Meetily captures and processes everything "entirely on your local machine"【^1†L69-L73】.

### Which AI models does Meetily use for transcription?

Meetily supports local transcription through **OpenAI Whisper** and **Parakeet** models, with implementations located in `frontend/src-tauri/src/whisper_engine/` and `frontend/src-tauri/src/parakeet_engine/` respectively. These models run locally on your hardware without requiring internet connectivity or API keys.

### How does Meetily handle different hardware configurations?

Meetily automatically detects available hardware acceleration across platforms. It supports **Metal/CoreML** on Apple Silicon, **CUDA** on NVIDIA GPUs, and **Vulkan** for cross-platform GPU compute. This ensures efficient real-time transcription regardless of whether you're running on a MacBook Pro, Windows workstation, or Linux machine.

### Can I use Meetily with my existing cloud AI providers?

Yes. While designed for privacy-first local operation, Meetily offers **flexible AI provider support** through the summary engine. You can configure endpoints for Claude, Groq, OpenRouter, or any OpenAI-compatible API in the application settings. When using these providers, only the transcript text (not audio) is transmitted, and you maintain full control over which services to trust.