How to Use the Meetily API: A Complete Guide to Tauri Commands and Rust Integration

Meetily does not expose a traditional HTTP REST API; instead, it uses Tauri commands to let the Next.js frontend invoke Rust functions directly via JSON-RPC-like messages, enabling local-only, privacy-first operation without network authentication.

Meetily is an open-source desktop meeting assistant developed by Zackriya-Solutions that processes all data locally on the user's machine. Unlike cloud-based services requiring HTTP endpoints and authentication tokens, the Meetily API operates through Tauri's command bridge, allowing the TypeScript frontend to communicate with the Rust backend using secure, local function calls.

Understanding the Meetily API Architecture

Why Tauri Commands Replace REST

The Meetily API is designed with privacy-first architecture. By leveraging Tauri commands instead of network-exposed REST endpoints, all processing—from audio capture to LLM summarization—remains within the local Tauri process. This eliminates the need for API keys, network credentials, or external authentication while ensuring sensitive meeting data never leaves the user's device.

The Command Flow: Frontend to Backend

When the Meetily interface needs backend functionality, communication follows a specific JSON-RPC-like flow:

1. Frontend Invocation – TypeScript code calls invoke('command_name', args) from @tauri-apps/api/tauri.
2. Tauri Bridge – The request marshals across the Tauri runtime boundary to the Rust side.
3. Rust Execution – The corresponding #[tauri::command] function executes in frontend/src-tauri/src/api/api.rs, accessing shared state from frontend/src-tauri/src/state.rs or emitting events back to the UI.
4. Event Listening – The frontend listens for events such as "transcript-update" or "summary-ready" to update React state in real time.

This architecture ensures that all Meetily API calls are local-only and synchronous, with the Rust backend handling threading and state management internally.

Core Meetily API Command Categories

The available commands in frontend/src-tauri/src/api/api.rs organize into distinct functional groups that control the application's behavior.

Recording Controls

Commands such as start_recording, stop_recording, and pause_recording manage the audio pipeline defined in frontend/src-tauri/src/audio/pipeline.rs. These accept parameters for microphone selection, system audio device routing (such as BlackHole virtual devices on macOS), and meeting metadata.

Transcription Management

The get_transcript_chunks and reset_transcript commands interface with the Whisper engine implementation in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. The frontend receives real-time transcription data by listening for "transcript-update" events containing text chunks and timestamps.

Summarization Engine

Commands like generate_summary and get_summary trigger the LLM integration layer in frontend/src-tauri/src/summary/summary_engine/mod.rs. These support multiple providers including Ollama, OpenAI, Groq, and Anthropic, selected via the model parameter passed during invocation.

Settings and State Management

The get_settings, set_setting, and get_app_state commands provide persistent storage for user preferences such as default audio devices and Whisper model size (base, small, medium), managed through the global state in frontend/src-tauri/src/state.rs.

Implementing Meetily API Calls in TypeScript

To interact with the Meetily API from the Next.js frontend, import the Tauri API helpers and invoke the registered commands using the patterns below.

Starting a Recording Session

Use the start_recording command to initialize the audio pipeline with specific device configurations:

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

async function beginMeeting() {
  await invoke('start_recording', {
    mic_device_name: 'Built‑in Microphone',
    system_device_name: 'BlackHole 2ch',      // macOS virtual device
    meeting_name: 'Team Stand‑up'
  });
}

Listening for Real-Time Transcripts

Register an event listener to receive transcription chunks as they are processed by the Whisper engine:

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

listen<{
  text: string;
  timestamp: string;
}>('transcript-update', event => {
  console.log('New transcript chunk:', event.payload.text);
  // Append to React state or UI component
});

Generating Meeting Summaries

After stopping the recording, request a summary from the configured LLM provider:

async function finishMeeting() {
  await invoke('stop_recording');          // stops audio pipeline
  const summary = await invoke<string>('generate_summary', {
    model: 'ollama:llama2',                // selects LLM driver
    language: 'en'
  });
  console.log('Meeting summary:', summary);
}

Retrieving User Settings

Access persistent configuration values using the get_setting command:

async function getWhisperModel() {
  const model = await invoke<string>('get_setting', { key: 'whisper_model' });
  return model;   // e.g., "base", "small", "medium"
}

Backend Command Registration and Implementation

The Meetily API surface is defined in the Rust source files under frontend/src-tauri/src/.

Command Registration in lib.rs

All available commands register in frontend/src-tauri/src/lib.rs through the generate_handler! macro:

tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![
        start_recording,
        stop_recording,
        get_transcript_chunks,
        generate_summary,
        // …additional commands
    ])
    .run(context)
    .expect("error while running tauri application");

API Implementation Layer

The actual business logic resides in frontend/src-tauri/src/api/api.rs, with thin wrappers in frontend/src-tauri/src/api/commands.rs. These functions coordinate:

• Audio pipeline via src/audio/pipeline.rs (handling mixing, VAD, and device routing)
• Whisper inference via src/whisper_engine/whisper_engine.rs
• LLM summarization via src/summary/summary_engine/mod.rs
• Global state via src/state.rs for shared application data

Summary

• Meetily uses Tauri commands, not HTTP REST, ensuring all processing remains local and private to the user's machine.
• Frontend TypeScript calls invoke() to execute Rust functions registered in frontend/src-tauri/src/lib.rs.
• Real-time updates flow via events such as "transcript-update" and "summary-ready" emitted from the Rust backend.
• Core commands cover recording controls (start_recording), transcription retrieval (get_transcript_chunks), LLM summarization (generate_summary), and settings management.
• No authentication required because the API operates entirely within the desktop application boundary without network exposure.

Frequently Asked Questions

Does Meetily expose a REST API for external integrations?

No. According to the Zackriya-Solutions/meetily source code, Meetily does not expose a traditional HTTP REST API. The application is designed as a privacy-first desktop tool where the Next.js frontend communicates with the Rust backend exclusively through Tauri's internal command bridge, keeping all data processing local to the user's machine.

How do I authenticate API requests in Meetily?

Authentication is not required for the Meetily API. Because all commands execute locally within the Tauri process through invoke calls, there are no network credentials, API tokens, or authentication headers to manage. This design eliminates external attack vectors and ensures meeting data never transmits over the network.

Can I use the Meetily API from outside the desktop application?

No. The Meetily API is intentionally encapsulated within the Tauri application shell. The commands registered in frontend/src-tauri/src/lib.rs are only accessible to the bundled frontend code running inside the Meetily desktop app. There is no exposed port or endpoint for external HTTP requests.

Where are the Tauri commands defined in the source code?

Tauri commands are defined in three primary locations: the command handlers are registered in frontend/src-tauri/src/lib.rs using generate_handler!, the core implementations reside in frontend/src-tauri/src/api/api.rs, and thin wrapper functions exist in frontend/src-tauri/src/api/commands.rs. Supporting logic for audio, transcription, and summarization lives in src/audio/pipeline.rs, src/whisper_engine/whisper_engine.rs, and src/summary/summary_engine/mod.rs respectively.

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