Meetily Core Features Explained: AI-Powered Offline Meeting Assistant

Meetily is a privacy-first, self-contained desktop application that delivers real-time transcription, GPU-accelerated AI summaries, and professional audio recording entirely on your local machine—no cloud required.

Built by Zackriya Solutions, meetily combines a Rust-powered Tauri backend with a Next.js frontend to process meeting audio, generate transcripts with Whisper/Parakeet, and produce AI summaries through local or custom LLM endpoints. Every feature runs on-device, ensuring sensitive meeting data never leaves your computer.

---

Local-First Real-Time Transcription

Meetily's local-first transcription captures both microphone and system audio, applies Voice Activity Detection (VAD), and feeds speech chunks directly to on-device Whisper or Parakeet models.

The audio pipeline lives in frontend/src-tauri/src/audio/pipeline.rs. This module handles:

• Dual-source capture: Simultaneous recording from microphone and system audio
• VAD processing: Filters silence to reduce unnecessary transcription load
• Buffer management: Streams audio chunks to the inference engine

The actual transcription engine resides in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. It loads models, manages GPU kernels, and returns timestamped text segments.

---

AI-Powered Meeting Summaries

Once a transcript is complete, Meetily sends it to a locally-hosted LLM (default: Ollama) or any OpenAI-compatible endpoint to generate structured meeting minutes.

The summary generation flow:

1. Transcript is collected from the recording session
2. A formatted prompt is constructed with meeting context
3. The LLM provider is called via HTTP with configurable parameters
4. The response is parsed and returned to the UI

The orchestration happens in frontend/src-tauri/src/commands/summary.rs, registered as a Tauri command generate_summary. Configuration parsing for custom endpoints is handled in frontend/src-tauri/src/config.rs.

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

const summary = await invoke<string>('generate_summary', {
  meeting_id: '2024-07-08-standup',
  provider: 'ollama',      // or 'openai', 'groq', 'custom'
  model: 'llama3.1',
});

---

Professional Audio Mixing

Meetily includes a professional audio mixer that balances mic and system recordings in real time. The ProfessionalAudioMixer in frontend/src-tauri/src/audio/pipeline.rs applies:

• RMS-based ducking: Automatically reduces system audio when microphone input is detected
• Clipping prevention: Hard limiters protect against digital distortion
• Synchronized mixing: Outputs a single clean stereo file with properly aligned sources

This eliminates the common problem of one audio source drowning out the other in hybrid meeting recordings.

---

GPU Acceleration for Inference

Meetily automatically detects and utilizes available GPU hardware for faster transcription. The build system supports three backends via Cargo feature flags:

Platform	Backend	Build Command
macOS (Apple Silicon/Intel)	Metal	cargo build --release --features metal
Windows	CUDA	cargo build --release --features cuda
Linux	Vulkan	cargo build --release --features vulkan

Feature flags are declared in frontend/src-tauri/Cargo.toml. At runtime, whisper_engine.rs selects the optimal backend based on availability and model requirements. Hardware-specific documentation is available in docs/GPU_ACCELERATION.md.

---

Cross-Platform Audio Device Support

Meetily runs natively on macOS, Windows, and Linux with platform-specific device enumeration modules:

• frontend/src-tauri/src/audio/devices/platform/macos.rs
• frontend/src-tauri/src/audio/devices/platform/windows.rs
• frontend/src-tauri/src/audio/devices/platform/linux.rs

These modules discover available input and loopback devices, presenting them in the React frontend at frontend/src/app/page.tsx for user selection.

---

Custom OpenAI-Compatible Endpoints

Enterprises and privacy-conscious users can redirect summary generation to self-hosted or third-party API endpoints. The configuration structure in frontend/src-tauri/src/config.rs exposes:

pub struct LlmConfig {
    pub endpoint: String,   // e.g., "https://api.internal.company.com/v1/chat/completions"
    pub api_key: String,
    pub model: String,
}

This enables deployment scenarios where Ollama is hosted on internal infrastructure or where commercial providers (Groq, OpenAI, Azure) are preferred.

---

Import and Enhance Workflow

Meetily supports post-hoc processing of existing audio files through the import workflow:

1. Users select an audio file through the React UI (frontend/src/app/page.tsx)
2. The file is routed through frontend/src-tauri/src/audio/recording_manager.rs
3. Transcription runs with selectable model and language parameters
4. Generated summaries can use different LLM configurations than live meetings

This allows teams to backfill meeting archives or re-process recordings with improved models.

---

Extensible Tauri Command API

The frontend-backend bridge is implemented through Tauri's command system. All core operations are exposed as async Rust functions in frontend/src-tauri/src/lib.rs:

tauri::generate_handler![
    start_recording,
    stop_recording,
    generate_summary,
    // ... additional commands
]

Frontend TypeScript invokes these directly:

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

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

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

// Stop and finalize
await invoke('stop_recording');

---

Summary

• Meetily processes all meeting data locally using a Tauri 2 architecture (Rust backend, Next.js frontend)
• Real-time transcription runs Whisper/Parakeet models with VAD and dual-source audio capture
• AI summaries integrate with Ollama, OpenAI, Groq, or any compatible endpoint via configurable LlmConfig
• GPU acceleration supports Metal, CUDA, and Vulkan through compile-time feature flags
• Professional audio mixing applies RMS ducking and clipping prevention in pipeline.rs
• Cross-platform support covers macOS, Windows, and Linux with dedicated device enumeration modules
• Import workflow enables re-transcription and enhanced processing of existing audio files

---

Frequently Asked Questions

Does Meetily send any meeting data to the cloud?

No. By default, Meetily operates entirely offline according to the architecture documentation. Audio capture, transcription with Whisper/Parakeet, and summary generation through Ollama all run on your local machine. You may optionally configure a cloud LLM endpoint, but this is not required.

What hardware is required for GPU acceleration?

Meetily supports Apple Silicon and Intel Macs via Metal, NVIDIA GPUs on Windows via CUDA, and Vulkan-compatible hardware on Linux. GPU detection and kernel selection happen automatically at runtime in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. CPU-only operation is available as a fallback.

Can I use Meetily with my company's internal LLM?

Yes. The LlmConfig struct in frontend/src-tauri/src/config.rs accepts any OpenAI-compatible endpoint URL. Set your internal API address and authentication key through the configuration interface, and the summary command will route requests accordingly.

How does Meetily handle audio from video calls?

The ProfessionalAudioMixer in frontend/src-tauri/src/audio/pipeline.rs captures system audio (including video call participants) through loopback devices while simultaneously recording your microphone. RMS-based ducking ensures your voice remains intelligible when others speak, producing a balanced single-track recording.

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