Meetily Project Goals: Privacy-First AI Meeting Automation

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 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 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. The frontend invokes these commands to initiate capture:

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【^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:

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:

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【^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
• 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.

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