Core Features of Meetily: A Privacy-First AI Meeting Assistant

Meetily is a self-contained desktop application built with Tauri 2 that delivers real-time transcription, AI-powered meeting summaries, and professional audio processing entirely on your local machine, ensuring no meeting data ever leaves your computer.

The Zackriya-Solutions/meetily repository provides a complete, open-source meeting assistant that combines a Rust backend with a Next.js frontend. By leveraging local Whisper models and OpenAI-compatible LLMs, Meetily eliminates cloud dependencies while providing enterprise-grade audio processing capabilities.

Local-First Real-Time Transcription

Meetily captures both microphone and system audio simultaneously, processes it through Voice Activity Detection (VAD), and streams speech chunks to local Whisper or Parakeet models for instant transcription.

The audio pipeline in frontend/src-tauri/src/audio/pipeline.rs handles the complex task of mixing multiple audio sources while applying real-time buffering. When speech is detected, the system passes audio segments to frontend/src-tauri/src/whisper_engine/whisper_engine.rs, which manages model loading and inference without requiring internet connectivity.

AI-Powered Meeting Summaries

Once transcription completes, Meetily generates concise meeting minutes by sending the transcript to a locally-hosted LLM via Ollama or any OpenAI-compatible endpoint.

The summarization logic resides in frontend/src-tauri/src/commands/summary.rs, registered as a Tauri command in frontend/src-tauri/src/lib.rs. This architecture allows users to process sensitive meeting content without transmitting data to external APIs, though the system supports external endpoints when desired.

Professional Audio Mixing

The application includes sophisticated audio processing through the ProfessionalAudioMixer implementation in frontend/src-tauri/src/audio/pipeline.rs. This system simultaneously records microphone and system audio while applying RMS-based ducking and clipping prevention to produce balanced, broadcast-quality recordings.

Audio device management is platform-specific, with separate implementations for macOS (macos.rs), Windows (windows.rs), and Linux (linux.rs) under frontend/src-tauri/src/audio/devices/platform/.

GPU Acceleration Support

Meetily automatically detects available GPU backends and loads optimized inference kernels for transcription. The system supports Metal on macOS (Apple Silicon and Intel), CUDA on Windows and Linux, and Vulkan on Linux systems.

Feature flags in frontend/src-tauri/Cargo.toml control backend compilation:

# macOS – Metal (Apple Silicon)

cargo build --release --features metal

# Windows – CUDA

cargo build --release --features cuda

# Linux – Vulkan

cargo build --release --features vulkan

The Whisper engine in frontend/src-tauri/src/whisper_engine/whisper_engine.rs selects the appropriate backend at runtime based on available hardware.

Cross-Platform Audio Device Management

The application provides native audio device enumeration across all supported platforms. Platform-specific modules in frontend/src-tauri/src/audio/devices/platform/ handle device discovery and selection, allowing users to choose specific input and output devices for recording.

The React frontend in frontend/src/app/page.tsx presents these devices through a unified interface, enabling users to configure complex routing scenarios like capturing system audio through virtual cables alongside physical microphones.

Custom OpenAI-Compatible Endpoints

For enterprise deployments, Meetily supports custom LLM endpoints beyond local Ollama instances. Configuration parsing in frontend/src-tauri/src/config.rs defines the LlmConfig struct:

pub struct LlmConfig {
    pub endpoint: String,
    pub api_key: String,
    pub model: String,
}

The summary command uses this configuration to send authenticated requests to self-hosted or corporate LLM endpoints, enabling flexible deployment scenarios while maintaining the application's local-first architecture.

Working with Meetily's API

Starting and Stopping Recordings

Frontend applications interact with the Rust backend through Tauri commands:

import { invoke } from '@tauri-apps/api/tauri';
import { listen } from '@tauri-apps/api/event';

// Start a new meeting recording
await invoke('start_recording', {
  mic_device_name: 'Built-in Microphone',
  system_device_name: 'BlackHole 2ch',
  meeting_name: 'Team Stand-up',
});

// Listen for live transcript updates
await listen<{ text: string }>('transcript-update', (e) => {
  console.log('Live transcript:', e.payload.text);
});

// When the meeting ends
await invoke('stop_recording');

These commands are defined in frontend/src-tauri/src/lib.rs using the #[tauri::command] macro and exported through tauri::generate_handler!.

Generating Meeting Summaries

Trigger summary generation with specific model selection:

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

const summary = await invoke<string>('generate_summary', {
  meeting_id: '2024-07-08-standup',
  provider: 'ollama',          // can also be 'openai', 'groq', etc.
  model: 'llama3.1',           // the model name on the selected provider
});

console.log('Meeting summary:', summary);

Import and Enhancement Workflow

Meetily supports importing existing audio files for re-transcription with different models or languages. This workflow is implemented in the frontend at frontend/src/app/page.tsx and backed by frontend/src-tauri/src/audio/recording_manager.rs, allowing users to process historical recordings or experiment with different Whisper model sizes.

Summary

Meetily delivers a comprehensive set of core features designed for privacy-conscious users and organizations:

• Local transcription using Whisper/Parakeet models with no cloud dependencies, implemented in frontend/src-tauri/src/whisper_engine/whisper_engine.rs
• AI summarization through configurable LLM endpoints (local Ollama or custom OpenAI-compatible APIs) in frontend/src-tauri/src/commands/summary.rs
• Professional audio mixing with VAD, ducking, and clipping prevention via ProfessionalAudioMixer in frontend/src-tauri/src/audio/pipeline.rs
• GPU acceleration with automatic backend detection for Metal, CUDA, and Vulkan through Cargo feature flags
• Cross-platform support with native audio device handling for macOS, Windows, and Linux
• Extensible architecture built on Tauri 2, exposing Rust commands to a Next.js frontend via frontend/src-tauri/src/lib.rs

Frequently Asked Questions

Does Meetily require an internet connection to transcribe meetings?

No. Meetily performs all transcription locally using Whisper or Parakeet models loaded into frontend/src-tauri/src/whisper_engine/whisper_engine.rs. The application only requires internet connectivity if you choose to use cloud-based LLM endpoints for summarization, though local Ollama integration works completely offline.

How does Meetily handle audio quality when recording both microphone and system audio?

The ProfessionalAudioMixer in frontend/src-tauri/src/audio/pipeline.rs applies RMS-based ducking and clipping prevention algorithms to balance multiple audio sources. This ensures that system audio and microphone input maintain consistent levels without distortion, producing professional-quality recordings suitable for transcription.

Can Meetily run on Apple Silicon Macs with GPU acceleration?

Yes. Meetily fully supports Apple Silicon through Metal acceleration. Build the application with cargo build --release --features metal to enable GPU-accelerated transcription. The detection logic in frontend/src-tauri/Cargo.toml and the engine code automatically utilize the Neural Engine and GPU cores on M1/M2/M3 chips.

Is it possible to use Meetily with my company's internal LLM endpoint?

Absolutely. Configuration in frontend/src-tauri/src/config.rs allows you to specify custom endpoints, API keys, and model names. The summary command in frontend/src-tauri/src/commands/summary.rs sends standard OpenAI-compatible requests, making it compatible with self-hosted solutions like vLLM, text-generation-inference, or corporate OpenAI proxies.

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