Dependencies for the Meetily Project: Complete Guide to Rust, Node.js, and Legacy Python Libraries

The Meetily project declares its core third-party libraries in frontend/src-tauri/Cargo.toml for Rust, frontend/package.json for the Next.js frontend, and retains an archived backend/requirements.txt for historical Python dependencies.

Meetily, maintained by Zackriya-Solutions, is a Tauri-based desktop application that combines a Rust backend with a Next.js/TypeScript frontend to deliver local meeting transcription and summarization. Understanding the dependencies for the Meetily project is essential for anyone building from source, contributing to the audio pipeline, or auditing the technology stack. The following sections break down each manifest, highlight the most critical crates and packages, and show exactly how they are used in the source code.

Rust (Tauri) Dependencies Declared in Cargo.toml

The native desktop runtime is controlled by frontend/src-tauri/Cargo.toml. According to the Meetily source code, this manifest defines the async runtime, audio I/O, speech-to-text engine, local database bindings, and serialization crates required by the backend.

# frontend/src-tauri/Cargo.toml  (excerpt)

[dependencies]
tauri = { version = "2", features = ["api-all"] }          # Core Tauri framework

tokio = { version = "1", features = ["full"] }            # Async runtime

serde = { version = "1", features = ["derive"] }          # (De)serialization

anyhow = "1"                                               # Error handling convenience

log = "0.4"                                                # Logging facade

env_logger = "0.10"                                       # Simple logger implementation

cpal = "0.15"                                             # Cross‑platform audio I/O

whisper-rs = "0.1"                                        # Whisper transcription wrapper

serde_json = "1"                                          # JSON handling

chrono = { version = "0.4", features = ["serde"] }       # Date‑time utilities

sqlx = { version = "0.7", features = ["sqlite", "runtime-tokio-rustls"] } # Async DB

rusqlite = "0.29"                                         # SQLite bindings (fallback)

serde_yaml = "0.9"                                        # YAML parsing (config)

# … plus a few optional dev‑only crates such as

test‑case = "2"

These crates give Meetily its essential backend capabilities:

• Tauri — Bridges the Rust core to the webview UI via IPC commands and events.
• Tokio — Powers the concurrent audio capture, VAD processing, and Whisper transcription pipelines.
• Cpal — Abstracts microphone and system-audio capture across macOS, Windows, and Linux.
• Whisper-rs — Runs the local Whisper model for on-device speech-to-text.
• SQLx / Rusqlite — Stores meetings, transcripts, and summary data locally in SQLite.
• Serde, Serde-json, and Serde-yaml — Handle configuration files, command payloads, and persisted data.

Node.js Frontend Dependencies Declared in package.json

The React UI layer tracks its requirements inside frontend/package.json. These dependencies supply the build toolchain, UI utilities, state container, and HTTP client that the frontend uses to communicate with the Rust core.

// frontend/package.json (excerpt)

{
  "dependencies": {
    "next": "14.x",                // React‑based web framework
    "react": "18.x",
    "react-dom": "18.x",
    "@tauri-apps/api": "^2.0.0",   // Front‑end wrapper for Tauri commands/events
    "typescript": "^5.2.0",
    "tailwindcss": "^3.4.0",      // UI styling utilities
    "zustand": "^4.5.0",           // Simple global state management (used by SidebarProvider)
    "clsx": "^2.0.0",              // Conditional className helper
    "axios": "^1.7.0",             // HTTP client (used for remote LLM calls to Ollama, Groq, etc.)
    "uuid": "^10.0.0"              // Unique identifiers for meetings and recordings
  },
  "devDependencies": {
    "eslint": "^8.57.0",
    "prettier": "^3.2.5",
    "tailwindcss": "^3.4.0",
    "typescript": "^5.2.0",
    "jest": "^29.7.0",
    "ts-jest": "^29.1.2"
  }
}

Key roles of these packages include:

• @tauri-apps/api — Lets the React UI invoke Rust commands such as start_recording and subscribe to backend events.
• Next.js — Serves the UI locally during development and bundles it for the Tauri desktop build.
• Tailwind CSS — Provides the utility-first styling used throughout the application.
• Zustand — Lightweight state container that powers global UI state, including the SidebarProvider.
• Axios — Performs outbound LLM requests to local Ollama instances or remote endpoints after transcription completes.

Legacy Python Backend Dependencies

The Python FastAPI backend located in backend/ is archived and no longer used by the current Meetily release. Its dependency list remains available in backend/requirements.txt for historical reference only, and you can safely ignore it for any new development or production build.

Practical Code Examples Using Meetily Dependencies

Invoking a Rust Command from the React UI

The frontend uses @tauri-apps/api to call the start_recording command registered in frontend/src-tauri/src/lib.rs.

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

async function startRecording() {
  try {
    await invoke('start_recording', {
      mic_device_name: 'Built‑in Microphone',
      system_device_name: 'BlackHole 2ch',
      meeting_name: 'Team Stand‑up',
    });
    console.log('Recording started');
  } catch (e) {
    console.error('Failed to start recording:', e);
  }
}

Listening for Transcript Updates Emitted by Rust

The audio pipeline in frontend/src-tauri/src/audio/pipeline.rs emits transcript-update events that the frontend captures with @tauri-apps/api/event.

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

listen<TranscriptUpdate>('transcript-update', (event) => {
  const { text, timestamp } = event.payload;
  console.log(`[${timestamp}] ${text}`);
  // Update UI state (e.g., via Zustand or React setState)
});

Performing a Remote LLM Request After Transcription

After transcription, the frontend uses axios to send the transcript to a local or remote LLM endpoint.

import axios from 'axios';

async function summarize(text: string) {
  const resp = await axios.post(
    'http://localhost:11434/api/generate',
    {
      model: 'llama3',
      prompt: `Summarize the following meeting transcript:\n${text}`,
    },
    { headers: { 'Content-Type': 'application/json' } }
  );
  return resp.data.response;
}

Key Source Files That Rely on These Dependencies

The following files consume the crates and packages listed above:

• frontend/src-tauri/src/lib.rs — Registers all Tauri commands (for example, start_recording) and bootstraps the application.
• frontend/src-tauri/src/audio/pipeline.rs — Orchestrates audio mixing, VAD filtering, and emits transcript-update events.
• frontend/src-tauri/src/audio/recording_manager.rs — Coordinates capture streams and persists raw recordings.
• frontend/src-tauri/src/whisper_engine/whisper_engine.rs — Loads the Whisper model and executes STT inference via whisper-rs.
• frontend/src-tauri/Cargo.toml — Lists every Rust crate required for the native backend.
• frontend/package.json — Lists every Node.js package required for the React frontend.
• backend/requirements.txt — Archived Python requirements kept for historical context; not used by the current app.

Summary

• Meetily's active third-party libraries are declared in frontend/src-tauri/Cargo.toml (Rust) and frontend/package.json (Node.js).
• The Rust backend depends on Tauri, Tokio, cpal, whisper-rs, SQLx, and Rusqlite to handle desktop windowing, async tasks, audio capture, transcription, and local SQLite storage.
• The Next.js frontend relies on @tauri-apps/api, Next.js, Tailwind CSS, Zustand, and Axios to render the UI, manage state, and communicate with external LLM services.
• The backend/requirements.txt Python dependency list is archived and is not required for current Meetily builds.

Frequently Asked Questions

What are the main dependencies for the Meetily project?

The main dependencies are declared in two active manifest files. frontend/src-tauri/Cargo.toml manages Rust crates such as tauri, tokio, cpal, and whisper-rs, while frontend/package.json manages Node.js packages including next, @tauri-apps/api, zustand, and axios.

How does the React frontend communicate with the Rust backend?

It uses @tauri-apps/api to invoke commands registered in frontend/src-tauri/src/lib.rs and to listen for events emitted by the Rust audio pipeline. This IPC layer lets the webview trigger native operations like recording start and receive real-time transcript updates without direct file system access.

Is the Python backend required to run Meetily?

No. The Python FastAPI backend inside backend/ is archived and not used by the current release. Its backend/requirements.txt remains in the repository only for historical reference, and the modern application runs entirely on the Rust Tauri core and the Next.js frontend.

Which Rust crate handles speech-to-text transcription?

The Rust backend uses whisper-rs to load and run the local Whisper model for speech-to-text, as implemented in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. Supporting crates such as cpal manage audio input, while tokio schedules the asynchronous inference pipeline.

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