How to Configure Meetily: Complete Setup Guide for Audio Capture, GPU Acceleration, and LLM Integration

To configure Meetily, install platform-specific prerequisites (Node.js, Rust, and build tools), set up virtual audio devices for system capture, enable GPU acceleration via environment variables or build scripts, and select your LLM provider in the Settings panel.

Meetily is a self-contained Tauri desktop application that pairs a Next.js/React UI with a Rust core handling audio capture, VAD-driven transcription, and LLM-based summarization. To configure Meetily effectively, you must properly set up the build environment, audio pipeline, hardware acceleration, and AI provider integration. This guide references the actual implementation in Zackriya-Solutions/meetily to ensure accurate configuration steps.

Prerequisites and Installation

Meetily requires Node.js ≥ 18, pnpm, Rust, and platform-specific build tools. The repository includes automated scripts for GPU detection, but you must first install the base dependencies.

Linux Setup

Install system build tools, Node.js, and pnpm:

sudo apt update && sudo apt install build-essential cmake git
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
npm install -g pnpm

Clone the repository and use the GPU auto-detection wrapper:

git clone https://github.com/Zackriya-Solutions/meetily.git
cd meetily
./dev-gpu.sh

For GPU support, optionally install CUDA (nvidia-cuda-toolkit), ROCm, or the Vulkan SDK with libopenblas-dev.

macOS Setup

Install dependencies via Homebrew, then run the development server:

brew install cmake node pnpm
pnpm tauri:dev

Metal and Core ML are auto-enabled on macOS with no additional configuration required.

Windows Setup

Install Visual Studio Build Tools with the C++ workload, Node.js, and pnpm. Then build or run:

pnpm tauri:dev    # Development

pnpm tauri:build  # Production

For NVIDIA GPUs, install the CUDA Toolkit; for AMD/Intel, install the Vulkan SDK.

Audio Device Configuration

Meetily captures two simultaneous streams: microphone input and system audio output. The Rust audio pipeline in frontend/src-tauri/src/audio/pipeline.rs handles ring-buffer mixing, resampling to 48 kHz, and EBU-R128 loudness normalization.

Virtual Audio Devices

System audio capture requires platform-specific virtual devices:

• macOS: Install BlackHole (2-channel) to create a virtual output that can be captured as input.
• Windows: WASAPI loop-back works out-of-the-box with no extra drivers.
• Linux: Use PulseAudio "monitor" sources or ALSA "hw:..." monitors.

Configure these in the UI under Settings → Audio, selecting your physical microphone as the Microphone device and the virtual loopback (e.g., "BlackHole 2ch") as the System device.

Verifying Audio Input

The Settings panel displays real-time level meters. If you see "zero-audio" warnings, check permissions or verify the virtual device is active. The audio enhancement pipeline applies a high-pass filter and optional RNNoise processing before sending audio to the Whisper transcription engine.

GPU Acceleration Configuration

Meetily can offload Whisper transcription to GPU for real-time performance. The scripts/dev-gpu.sh and scripts/build-gpu.sh scripts automatically detect available hardware and set appropriate Cargo feature flags.

Automatic GPU Detection

Run the wrapper scripts to auto-configure:

./dev-gpu.sh   # Development with auto-detect

./build-gpu.sh # Production build with auto-detect

Manual Backend Override

Force a specific backend by setting TAURI_GPU_FEATURE before invoking the script:

# Force CUDA for NVIDIA GPUs

TAURI_GPU_FEATURE=cuda ./dev-gpu.sh

# Force Vulkan (cross-platform)

TAURI_GPU_FEATURE=vulkan ./build-gpu.sh

# Disable GPU - force CPU only

TAURI_GPU_FEATURE= ./dev-gpu.sh

The feature flags are defined in frontend/src-tauri/Cargo.toml:

[features]
default = ["cuda"]
cuda = ["whisper-rs/cuda"]
vulkan = ["whisper-rs/vulkan"]
openblas = ["whisper-rs/openblas"]

LLM Provider Configuration

Meetily supports multiple LLM providers for meeting summarization, controlled by the LLMProvider enum in frontend/src-tauri/src/summary/llm_client.rs. Configure your provider in Settings → LLM.

Provider	Configuration Method	Required Setting
Built-in AI	Local Ollama/llama-cpp	No external key required
Ollama	Local server endpoint	Endpoint URL (default: http://localhost:11434)
OpenAI	Cloud API	OPENAI_API_KEY
Claude	Anthropic API	ANTHROPIC_API_KEY
Groq	Fast inference cloud	GROQ_API_KEY
OpenRouter	Multi-model marketplace	OPENROUTER_API_KEY and optional endpoint

Set API keys via the UI or export them before launching:

export OPENAI_API_KEY=sk-xxxxx
pnpm tauri:dev

For advanced usage, you can programmatically select providers in Rust:

// From frontend/src-tauri/src/summary/service.rs
let provider = LLMProvider::from_str("ollama")?;
let model = "gemma:2b".to_string();
let summary = generate_summary(&transcript, &model, &provider, None).await?;

Production Build Configuration

When creating release installers, Tauri requires code-signing keys. Copy the placeholder file and populate real values:

cp frontend/.env.example frontend/.env

Set these variables in .env or as CI secrets:

TAURI_SIGNING_PRIVATE_KEY=BASE64_ENCODED_KEY
TAURI_SIGNING_PRIVATE_KEY_PASSWORD=your_password

Running Meetily

Mode	Command	Description
Development	./dev-gpu.sh (Linux)pnpm tauri:dev (macOS/Windows)	Hot-reload with GPU auto-detection
Production	./build-gpu.sh (Linux)pnpm tauri:build (macOS/Windows)	Builds .AppImage, .dmg, or .msi
Debug	RUST_LOG=debug ./clean_run.sh	Verbose logging for troubleshooting

To start recording programmatically via the Tauri command API:

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

await invoke('start_recording', {
  mic_device_name: 'Built-in Microphone',
  system_device_name: 'BlackHole 2ch',
  meeting_name: 'Team Sync'
});

Summary

• Install prerequisites: Node.js 18+, pnpm, Rust, and platform build tools (CUDA/Vulkan optional).
• Configure audio: Set up virtual loopback devices (BlackHole on macOS, PulseAudio monitor on Linux) and select them in Settings → Audio.
• Enable GPU: Use ./dev-gpu.sh for auto-detection, or set TAURI_GPU_FEATURE=cuda|vulkan to force specific backends.
• Select LLM: Choose from built-in, Ollama, OpenAI, Claude, Groq, or OpenRouter in Settings → LLM, providing API keys as needed.
• Build releases: Configure TAURI_SIGNING_PRIVATE_KEY in frontend/.env for code-signed installers.

Frequently Asked Questions

How do I configure GPU acceleration for Whisper transcription in Meetily?

Meetily automatically detects available GPUs via the dev-gpu.sh or build-gpu.sh scripts, which set the appropriate Cargo features for CUDA, Vulkan, or OpenBLAS. To force a specific backend, set the environment variable TAURI_GPU_FEATURE=cuda (for NVIDIA), vulkan (for AMD/Intel), or leave it empty for CPU-only mode, then run the build script.

What audio devices do I need to configure Meetily for meeting recording?

You must configure two devices: a microphone for your voice and a system audio device for capturing meeting output. On macOS, install BlackHole to create a virtual audio sink; on Linux, use PulseAudio monitor sources; on Windows, WASAPI loop-back works without extra drivers. Select both devices in Settings → Audio and verify levels using the built-in meters.

How do I switch between different LLM providers in Meetily?

Open Settings → LLM in the application UI and select your provider from the dropdown. For cloud providers (OpenAI, Claude, Groq, OpenRouter), enter your API key in the provided field. For local models, ensure Ollama is running on http://localhost:11434 and select the Ollama provider. The LLMProvider enum in frontend/src-tauri/src/summary/llm_client.rs handles the backend routing based on your selection.

Why is my system audio not being captured after configuring Meetily?

If the UI shows "zero-audio" warnings for the system device, verify that your virtual audio device (BlackHole on macOS or PulseAudio monitor on Linux) is active and set as the default output in your system sound settings. Ensure Meetily has permission to access the device, and check that the selected device name in Settings → Audio matches the virtual device exactly.

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