How Meetily's Retranscription Feature Re-processes Recorded Meetings with Different Models or Languages

Meetily's retranscription feature allows users to re-process stored audio files using different Whisper models and languages through an asynchronous Tauri Rust workflow that validates providers, loads models dynamically, and emits real-time progress events.

The retranscription feature in Meetily (Zackriya-Solutions/meetily) provides a flexible mechanism for regenerating transcripts from existing recordings. Unlike live transcription, this capability allows users to experiment with different model sizes, switch languages, or migrate to improved AI providers without re-recording meetings. The implementation resides entirely in the Tauri Rust core and exposes a command-based API that the frontend consumes for seamless UI integration.

Core Retranscription Workflow

The retranscription engine operates inside frontend/src-tauri/src/audio/retranscription.rs. When triggered, the start_retranscription command accepts five critical parameters: the meeting identifier, the folder containing the original audio file, the target language, the Whisper model name (e.g., "base", "small", "medium"), and the AI provider (Ollama, OpenAI, Groq) at line 89.

The workflow executes through the run_retranscription function, which orchestrates model loading, audio processing, and result storage.

Concurrency Control and Safety

To prevent resource conflicts, Meetily implements a global atomic flag named RETRANSCRIPTION_IN_PROGRESS. This flag ensures only one retranscription job executes simultaneously across the entire application. A dedicated guard automatically releases this flag if the task panics, preventing deadlocks (lines 19-27 of frontend/src-tauri/src/audio/retranscription.rs).

Provider Validation and Model Loading

Before processing begins, the engine validates that the selected provider supports Whisper transcription. If an unsupported provider is chosen, the system emits a clear error event at line 612 of the retranscription module.

For valid providers, run_retranscription invokes whisper_engine::WhisperEngine::load_model at line 187, passing the user-specified model string. The engine automatically selects the appropriate GPU acceleration—Metal for macOS, CUDA for NVIDIA GPUs, or Vulkan as a fallback—or degrades gracefully to CPU execution (frontend/src-tauri/src/whisper_engine/whisper_engine.rs).

Language Selection and Processing

The language argument provided to start_retranscription is forwarded directly to Whisper's transcription call at line 187. This architecture allows the same audio file to be re-processed in different languages or locales without altering the source recording, enabling multilingual transcript generation from a single meeting.

Data Persistence and Metadata Updates

Upon completion, Whisper returns the new transcript to the database layer (database::repositories::transcript). The system updates the original meeting metadata with a retranscribed_at timestamp and adds a "source": "retranscription" marker to distinguish regenerated transcripts from originals (lines 723-756 of frontend/src-tauri/src/audio/retranscription.rs).

Progress Reporting and Cancellation

Throughout the job lifecycle, the backend emits "retranscription-progress" events containing percentage completion data to keep the frontend responsive. Upon successful completion, a "retranscription-complete" event fires; errors trigger "retranscription-error" (lines 116-127).

Users can abort processing via the cancel_retranscription command, which clears the atomic flag and stops the workflow gracefully (lines 84-85).

Frontend Integration

The three Tauri commands—start_retranscription_command, cancel_retranscription_command, and is_retranscription_in_progress_command—are registered in frontend/src-tauri/src/lib.rs at lines 742-744, making them available to the TypeScript frontend.

Triggering Retranscription

To initiate retranscription from the frontend:

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

await invoke('start_retranscription_command', {
  meetingId: '12345',
  language: 'es',               // Spanish transcription
  model: 'small',               // Whisper "small" model
  provider: 'ollama'            // Provider supporting Whisper
});

Checking Status and Cancelling

Check if a job is running:

const inProgress = await invoke<boolean>('is_retranscription_in_progress_command');

Cancel an ongoing job:

await invoke('cancel_retranscription_command');

Listening for Progress

Implement real-time progress updates in React:

import { listen } from '@tauri-apps/api/event';
import { useEffect, useState } from 'react';

function useRetranscriptionProgress() {
  const [progress, setProgress] = useState(0);
  useEffect(() => {
    const unlisten = listen<{ percent: number }>('retranscription-progress', e => {
      setProgress(e.payload.percent);
    });
    return () => { unlisten.then(f => f()); };
  }, []);
  return progress;
}

Summary

• Single Concurrency: The RETRANSCRIPTION_IN_PROGRESS atomic flag prevents simultaneous retranscription jobs and automatically releases on panic.
• Provider Flexibility: Only Whisper-supporting providers (Ollama, OpenAI, Groq) are accepted, validated before model loading.
• Dynamic Configuration: Users specify model size (base, small, medium) and language independently for each retranscription job.
• GPU Acceleration: The Whisper engine automatically utilizes Metal, CUDA, or Vulkan, falling back to CPU when necessary.
• Event-Driven UI: Progress events (retranscription-progress, retranscription-complete, retranscription-error) enable responsive frontend implementations.
• Safe Cancellation: The cancel_retranscription command allows users to abort long-running jobs without restarting the application.

Frequently Asked Questions

What is Meetily's retranscription feature?

Meetily's retranscription feature is an asynchronous workflow that allows users to regenerate transcripts from previously recorded meeting audio using different Whisper AI models or languages. Unlike initial recording transcription, it operates on stored audio files in frontend/src-tauri/src/audio/retranscription.rs, enabling experimentation with model accuracy or multilingual output without re-recording.

Which AI providers support retranscription in Meetily?

The retranscription feature supports providers capable of running Whisper models, specifically Ollama, OpenAI, and Groq. The system validates provider compatibility at line 612 of frontend/src-tauri/src/audio/retranscription.rs and rejects unsupported providers before model loading begins.

How does Meetily handle GPU acceleration during retranscription?

The whisper_engine::WhisperEngine::load_model function automatically detects and utilizes available hardware acceleration. It prioritizes Metal on macOS, CUDA on NVIDIA GPUs, and Vulkan as a cross-platform alternative, falling back to CPU execution if no GPU is available (frontend/src-tauri/src/whisper_engine/whisper_engine.rs).

Can users cancel an ongoing retranscription job?

Yes. Users can invoke the cancel_retranscription_command, which clears the RETRANSCRIPTION_IN_PROGRESS atomic flag and halts processing immediately (lines 84-85 of frontend/src-tauri/src/audio/retranscription.rs). The frontend can check active status anytime using is_retranscription_in_progress_command.

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