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

> Learn how to use the Meetily API with this guide on Tauri commands and Rust integration. Discover direct frontend to Rust function calls for local privacy.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-08-03

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/api.rs), accessing shared state from [`frontend/src-tauri/src/state.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```typescript
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:

```typescript
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:

```typescript
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:

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) through the `generate_handler!` macro:

```rust
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/api.rs), with thin wrappers in [`frontend/src-tauri/src/api/commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/commands.rs). These functions coordinate:
- **Audio pipeline** via [`src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/pipeline.rs) (handling mixing, VAD, and device routing)
- **Whisper inference** via [`src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/whisper_engine/whisper_engine.rs)
- **LLM summarization** via [`src/summary/summary_engine/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/summary/summary_engine/mod.rs)
- **Global state** via [`src/state.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) using `generate_handler!`, the core implementations reside in [`frontend/src-tauri/src/api/api.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/api.rs), and thin wrapper functions exist in [`frontend/src-tauri/src/api/commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/commands.rs). Supporting logic for audio, transcription, and summarization lives in [`src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/pipeline.rs), [`src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/whisper_engine/whisper_engine.rs), and [`src/summary/summary_engine/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/summary/summary_engine/mod.rs) respectively.