How to Integrate Meetily with Other Applications: A Complete Tauri Integration Guide

You can integrate Meetily with external applications by invoking Tauri commands from the frontend using @tauri-apps/api, listening to real-time events like transcript-update, and accessing the SQLite database through the exposed api_* command layer.

Meetily is a self-contained desktop application built by Zackriya-Solutions using Tauri and Next.js. To integrate Meetily with other applications, you interact with its Rust-based backend through the frontend API, enabling automation, custom workflows, and third-party service connections without modifying core system files.

Understanding Meetily's Tauri-Based Architecture

The Command Registry Pattern

All public APIs are declared with #[tauri::command] attributes in the Rust backend. The run() function in frontend/src-tauri/src/lib.rs registers every command through the invoke_handler! macro, creating a thin, well-typed surface for integration. Any new integration point requires only adding a command function to this registry.

Core System Layers

• Frontend UI: React components in frontend/src/app/ use invoke to call backend commands and listen to react to events.
• Audio System: Located in frontend/src-tauri/src/audio/, handles device discovery, professional mixing, and recording management.
• AI Engines: Whisper and Parakeet implementations in frontend/src-tauri/src/whisper_engine/ and parakeet_engine/ directories.
• Database Layer: SQLite operations exposed through api_* commands defined in frontend/src-tauri/src/api/mod.rs.

Methods to Integrate Meetily with Other Applications

Invoking Backend Commands

External integration starts with calling Tauri commands from the frontend using @tauri-apps/api/core. The invoke function accepts command names registered in lib.rs and passes serialized arguments to the Rust backend. All recording, AI, and database operations are accessible through this pattern.

Subscribing to Real-Time Events

The application emits events such as transcript-update during audio processing. Use the listen function from @tauri-apps/api/event to capture live transcription data and forward it to external services or update UI components in real time.

Leveraging the Database API

The api_* command family provides CRUD operations for meetings, transcripts, and configuration. These commands in frontend/src-tauri/src/api/mod.rs allow reading and writing to the SQLite database without direct file access, enabling persistent integration state management.

Practical Integration Code Examples

Starting a Recording Programmatically

Trigger recordings from any external widget or automation script by invoking the start_recording_with_devices_and_meeting command defined in frontend/src-tauri/src/audio/recording_commands.rs.

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

async function startMeetilyRecording() {
  await invoke('start_recording_with_devices_and_meeting', {
    mic_device_name: 'Built-in Microphone',
    system_device_name: 'BlackHole 2ch',
    meeting_name: 'Quarterly Review',
  });
}

Capturing Live Transcript Updates

Listen for the transcript-update event emitted by the audio pipeline to stream text to external webhooks or databases in real time.

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

async function subscribeToTranscripts() {
  await listen<{
    text: string;
    timestamp: number;
  }>('transcript-update', event => {
    console.log('New snippet:', event.payload);
    // Forward to external webhook, store in DB, etc.
  });
}

Configuring Custom AI Endpoints

Swap LLM providers at runtime by updating the custom OpenAI configuration using api_save_custom_openai_config and verify connectivity with api_test_custom_openai_connection.

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

async function setCustomOpenAI() {
  await invoke('api_save_custom_openai_config', {
    config: {
      base_url: 'http://localhost:8000/v1',
      api_key: 'sk-my-local-key',
    },
  });

  const result = await invoke('api_test_custom_openai_connection');
  console.log('Connection test:', result);
}

Exporting Meeting Data

Export completed meetings by calling database commands and saving files to accessible locations using save_transcript and open_meeting_folder.

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

async function exportMeeting(meetingId: string) {
  const folder = await path.appDataDir();
  const markdownPath = `${folder}/exports/${meetingId}.md`;

  const transcript = await invoke<string>('api_get_meeting_transcripts', { meetingId });
  await invoke('save_transcript', { file_path: markdownPath, content: transcript });
  
  await invoke('open_meeting_folder', { meetingId });
}

Key Integration Points in the Source Code

Command Registration

The invoke_handler! macro in frontend/src-tauri/src/lib.rs registers all available commands, including track_event for analytics and show_notification for system alerts.

Audio Commands

frontend/src-tauri/src/audio/recording_commands.rs contains the core recording API for start/stop operations and device selection.

AI Engine Commands

frontend/src-tauri/src/whisper_engine/commands.rs manages model lifecycle operations including initialization, loading, and transcription via whisper_transcribe_audio.

Frontend Service Wrappers

frontend/src/services/recordingService.ts provides TypeScript wrappers around the invoke calls, offering type-safe interfaces for recording operations.

Summary

• Meetily uses Tauri's command pattern to expose Rust backend functionality to the Next.js frontend and external integrations.
• All commands are registered in frontend/src-tauri/src/lib.rs through the invoke_handler! macro, providing a stable API surface.
• Real-time integration is possible by listening to events like transcript-update emitted during audio processing.
• Database operations are accessible through the api_* command family, enabling programmatic access to meetings and transcripts.
• Custom AI providers can be configured at runtime without restarting the application using the custom OpenAI config commands.

Frequently Asked Questions

Can I integrate Meetily with my existing CRM or project management tool?

Yes. You can build a bridge by listening to the transcript-update event in a custom React component and forwarding the payload to your CRM's REST API. Alternatively, query completed transcripts using api_get_meeting_transcripts and push them to external systems on demand.

How do I trigger a recording from an external application?

Use the invoke function to call start_recording_with_devices_and_meeting with specific device names and a meeting identifier. This command is implemented in frontend/src-tauri/src/audio/recording_commands.rs and accepts parameters for microphone and system audio devices.

Is it possible to switch AI providers without restarting Meetily?

Yes. Call api_save_custom_openai_config to update the base URL and API key, then verify the connection with api_test_custom_openai_connection. These commands are defined in the API module and allow runtime configuration of OpenAI-compatible endpoints.

Where are the integration entry points defined in the source code?

All integration entry points are defined in frontend/src-tauri/src/lib.rs within the invoke_handler! macro. Additional command implementations are located in frontend/src-tauri/src/audio/recording_commands.rs for recording operations and frontend/src-tauri/src/api/mod.rs for database interactions.

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