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

> Discover how the Tauri app replaces Meetily's legacy FastAPI backend, running audio capture, transcription, and LLM summarization locally for enhanced performance and security.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: architecture
- Published: 2026-07-15

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/services/transcriptService.ts) wraps these invocations, providing a clean interface for UI components.

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/app/main.py) represents an earlier iteration of Meetily's architecture. According to the [`backend/README.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/README.md) identifies this code as an "Archived Python/FastAPI" project retained only for historical reference. Similarly, the [`frontend/README.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```python

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs). For example, the `startRecording` function in [`frontend/src/services/transcriptService.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/services/transcriptService.ts) calls `invoke('start_recording', {...})` to trigger native audio capture handled by [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.