Relationship Between the Tauri App and the Legacy FastAPI Backend in Meetily

The Tauri desktop application replaces the legacy FastAPI backend entirely, running all core functionality—including audio capture, transcription, and LLM summarization—as a single local process without requiring any external HTTP services.

The open-source Meetily project (Zackriya-Solutions/meetily) has evolved from a distributed client-server architecture to a unified desktop application. Understanding the relationship between the Tauri app and the legacy FastAPI backend in Meetily is essential for contributors evaluating the codebase. The current production implementation consolidates all meeting-assistant logic into a native desktop binary, while the FastAPI code remains only as an unsupported archive.

Architecture Overview

Meetily's current architecture centers on a single-process Tauri desktop application that encapsulates the entire meeting workflow. This represents a fundamental shift from earlier versions that relied on network communication between a web frontend and a separate Python backend.

The Tauri app combines a Rust-based backend with a Next.js/TypeScript frontend, compiling into a standalone native binary. All data flows remain within this desktop process, eliminating network dependencies and preserving user privacy by keeping audio processing local.

How the Tauri App Replaces the FastAPI Backend

Core Functionality Migration

The Tauri implementation in frontend/src-tauri/src/lib.rs registers commands that handle all critical operations previously managed by the FastAPI service. These include:

• Audio capture and mixing via frontend/src-tauri/src/audio/pipeline.rs
• Local transcription using Whisper/Parakeet models
• Meeting persistence to local storage
• LLM summarization without external API calls

The Rust backend exposes these capabilities through Tauri's command system, allowing the frontend to invoke native functionality directly.

Communication Patterns

Unlike the legacy architecture that required HTTP requests to a separate Python process, the current frontend communicates with the Rust backend through Tauri's command API. The frontend service layer in frontend/src/services/transcriptService.ts wraps these invocations, providing a clean interface for UI components.

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

async function startRecording(meetingName: string) {
  await invoke('start_recording', {
    mic_device_name: 'Built‑in Microphone',
    system_device_name: 'BlackHole 2ch',
    meeting_name: meetingName,
  });
}

This approach eliminates the latency and deployment complexity associated with maintaining a separate FastAPI server.

The Legacy FastAPI Backend (Archived)

Historical Purpose

The FastAPI backend located in backend/app/main.py represents an earlier iteration of Meetily's architecture. According to the backend/README.md, this code provided:

• A standalone HTTP API for transcription endpoints
• Docker orchestration for containerized deployment
• A separate Whisper server process

Why It Was Deprecated

The documentation explicitly marks the FastAPI implementation as unsupported and obsolete. The backend/README.md identifies this code as an "Archived Python/FastAPI" project retained only for historical reference. Similarly, the frontend/README.md states that "Current Meetily does not require a separate FastAPI service."

The archived backend lacks authentication mechanisms and should not be started in production environments. The code remains in the repository solely for potential migration work or reference purposes, but active development focuses exclusively on the Tauri implementation.

Code Structure Comparison

The relationship between these two systems becomes clear when comparing their file structures and runtime characteristics:

• Tauri App (Current): Runs as a native desktop binary (Rust + Next.js/TypeScript). Frontend invokes Rust commands via @tauri-apps/api (e.g., invoke('start_recording')). Deploys as a single binary with no external services.
• Legacy FastAPI (Archived): Runs as a separate Python process requiring Docker or virtualenv. Older UI versions called HTTP endpoints that are now removed. Requires separate startup scripts and containerization.

The following Python code from the archived backend illustrates the old HTTP-based transcription approach, which is no longer used by the current application:

# backend/app/main.py (archived)

@app.post("/transcribe")
async def transcribe(file: UploadFile):
    # Handles Whisper transcription over HTTP

    ...

Summary

• The Tauri app completely replaces the FastAPI backend, consolidating all meeting-assistant functionality into a single desktop process.
• No active FastAPI service is required for normal operation; the Tauri app handles audio capture, transcription, and storage locally.
• The legacy backend is archived in backend/ and marked as unsupported and unauthenticated.
• Communication occurs via Tauri commands (e.g., invoke('start_recording')) rather than HTTP API calls.
• All data remains local, eliminating network dependencies and enhancing privacy compared to the distributed architecture.

Frequently Asked Questions

Is the FastAPI backend required for Meetily to function?

No. The FastAPI backend is obsolete and not used by the current Tauri application. The frontend/README.md explicitly states that "Current Meetily does not require a separate FastAPI service." All core functionality—including transcription, recording, and summarization—runs within the Tauri desktop process.

How does the frontend communicate with the Tauri backend?

The frontend uses the @tauri-apps/api library to invoke Rust commands registered in frontend/src-tauri/src/lib.rs. For example, the startRecording function in frontend/src/services/transcriptService.ts calls invoke('start_recording', {...}) to trigger native audio capture handled by frontend/src-tauri/src/audio/pipeline.rs. This direct invocation replaces the previous HTTP client-server communication model.

Can I still use the FastAPI backend for development?

No. The backend/README.md marks the FastAPI code as "Archived Python/FastAPI" and explicitly labels it as unsupported. The code is retained only for historical reference or potential migration work. It should not be started in production, as it lacks authentication mechanisms and is not maintained alongside the current Tauri implementation.

Where is the transcription logic implemented in the current version?

Transcription logic runs locally within the Tauri application's Rust backend. The audio pipeline in frontend/src-tauri/src/audio/pipeline.rs handles mixing and voice activity detection (VAD), while transcription occurs through local Whisper/Parakeet integration rather than HTTP endpoints. This architecture keeps audio data on the user's device rather than transmitting it to a separate server.

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