Meetily API Endpoints: Complete Reference for Tauri Commands

Meetily exposes over 30 Tauri commands that bridge the TypeScript frontend and Rust backend, covering recording management, Whisper transcription, LLM summarization, and audio device handling.

Meetily is an open-source, AI-powered meeting assistant built with Tauri. Unlike traditional REST APIs, its Meetily API endpoints are implemented as Rust commands exposed to the JavaScript frontend via Tauri's invoke mechanism. This architecture keeps all processing local while providing a seamless desktop experience.

Recording and Meeting Management Commands

The core recording functionality resides in frontend/src-tauri/src/lib.rs. These commands handle audio capture lifecycle and meeting metadata.

start_recording initiates audio capture with configurable input sources. Located at lines 83-90 in lib.rs, it accepts optional microphone and system audio device names along with a meeting identifier.

stop_recording terminates the active recording session and finalizes the audio file. This command is defined at lines 44-51 in frontend/src-tauri/src/lib.rs.

is_recording provides a boolean status check for the recording state, implemented at lines 8-11.

start_recording_with_devices and start_recording_with_devices_and_meeting offer convenience wrappers that combine device selection with recording initiation. The latter accepts a meeting_name parameter for UI labeling, found at lines 98-103 and 6-13 respectively.

set_language_preference configures transcription language settings such as auto-translation options (lines 75-82).

Audio Device and Permission Endpoints

Before recording begins, the application must enumerate hardware and secure OS permissions.

get_audio_devices returns a vector of AudioDevice structs representing available input sources. The implementation resides at lines 84-89 in frontend/src-tauri/src/lib.rs, utilizing the discovery logic in frontend/src-tauri/src/audio/devices/discovery.rs.

trigger_microphone_permission prompts the operating system for microphone access, required on macOS and Windows platforms. This command is located at lines 92-97 in lib.rs.

Whisper Transcription Engine API

All AI transcription commands are centralized in frontend/src-tauri/src/whisper_engine/commands.rs. These endpoints manage model lifecycle and audio-to-text conversion.

Model Management:

• whisper_init initializes the engine, loads configuration, and detects GPU availability
• whisper_get_available_models lists cached Whisper model files in the local directory
• whisper_load_model loads a specific model (e.g., "base", "small") into memory
• whisper_download_model fetches models from remote repositories with progress tracking
• whisper_cancel_download aborts ongoing downloads
• whisper_delete_corrupted_model removes incomplete or damaged model files
• whisper_get_models_directory returns the absolute path to model storage
• open_models_folder launches the OS file explorer at the models location

Transcription Operations:

• whisper_transcribe_audio processes raw audio samples and returns transcription text
• whisper_get_current_model and whisper_is_model_loaded provide runtime state inspection
• whisper_has_available_models checks for local model presence
• whisper_validate_model_ready performs pre-transcription sanity checks

Audio Level Monitoring Commands

Real-time audio visualization requires continuous device polling.

start_audio_level_monitoring begins per-device level analysis, emitting events to the frontend via Tauri's event system. Located at lines 50-57 in frontend/src-tauri/src/lib.rs.

stop_audio_level_monitoring terminates the monitoring task (lines 66-73).

is_audio_level_monitoring returns the active status of the monitoring subsystem (lines 74-78).

Transcript Persistence Endpoints

Post-meeting data handling is managed through file system commands in lib.rs.

read_audio_file loads raw audio bytes from disk into memory (lines 22-27).

save_transcript persists transcription text to a user-specified path, creating parent directories automatically. Implemented at lines 30-46 in frontend/src-tauri/src/lib.rs.

get_transcription_status returns a TranscriptionStatus struct indicating processing state (lines 13-20).

Summary and LLM Integration API

Meeting summarization interfaces with local and remote LLM providers through commands in frontend/src-tauri/src/summary/commands.rs and summary/summary_engine/commands.rs.

summarize_transcript sends transcript content to configured providers (Ollama, OpenAI, Claude) and returns structured summaries.

set_summary_prompt allows runtime customization of the LLM system prompt.

get_summary_status provides progress updates and error reporting during generation.

cancel_summary aborts in-progress summarization tasks.

Notification and Onboarding Commands

show_recording_started_notification, show_recording_stopped_notification, and show_custom_notification emit native desktop alerts. These are defined in frontend/src-tauri/src/notifications/commands.rs.

onboarding_complete and reset_onboarding manage first-run user flows in frontend/src-tauri/src/onboarding.rs.

set_user_setting and get_user_setting provide generic key-value storage for application preferences.

How to Invoke Meetily API Endpoints from TypeScript

All Meetily API endpoints are accessible via @tauri-apps/api/tauri. The invoke function accepts the command name as the first argument and an optional payload object.

Starting a Recording with Metadata

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

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

This corresponds to the Rust implementation at frontend/src-tauri/src/lib.rs lines 6-13.

Loading a Whisper Model

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

await invoke('whisper_load_model', { model_name: 'base' });

Persisting Transcription Results

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

await invoke('save_transcript', {
  file_path: '/Users/me/Meetings/TeamSync.txt',
  content: transcriptText
});

Enumerating Audio Hardware

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

interface AudioDevice {
  name: string;
  id: string;
}

const devices = await invoke<AudioDevice[]>('get_audio_devices');
console.log(devices);

Summary

• Meetily API endpoints are Tauri commands defined in Rust and invoked from TypeScript, not HTTP endpoints
• Core recording controls reside in frontend/src-tauri/src/lib.rs with functions like start_recording and stop_recording
• Whisper transcription commands are modularized in whisper_engine/commands.rs and include model management and audio processing
• Audio device discovery and permission handling are abstracted through get_audio_devices and trigger_microphone_permission
• LLM integration supports multiple providers via the summary commands in summary/commands.rs
• All commands follow Tauri's standard invoke pattern with strongly-typed parameters and return values

Frequently Asked Questions

How do I call Meetily API endpoints from the frontend?

Use the invoke function from @tauri-apps/api/tauri, passing the command name as a string and an optional payload object containing parameters. All commands are registered in the Tauri builder within frontend/src-tauri/src/lib.rs and become available to the TypeScript layer immediately upon application launch.

Where are the Whisper transcription commands defined?

The Whisper engine commands are located in frontend/src-tauri/src/whisper_engine/commands.rs. This file contains implementations for whisper_init, whisper_load_model, whisper_transcribe_audio, and nine other model management functions that handle local AI transcription without external API calls.

How does Meetily handle audio device permissions?

The trigger_microphone_permission command in frontend/src-tauri/src/lib.rs (lines 92-97) requests OS-level microphone access. On macOS and Windows, this triggers the system permission dialog, while Linux implementations depend on PipeWire or ALSA configurations. The get_audio_devices command subsequently returns only authorized and available input sources.

Can I customize the LLM prompt for meeting summarization?

Yes. The set_summary_prompt command in frontend/src-tauri/src/summary/commands.rs accepts a custom prompt string that overrides the default template sent to the configured LLM provider (Ollama, OpenAI, or Claude). This allows users to specify summary formats, focus areas, or output languages dynamically.

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