How Meetily's Import and Enhance Feature Re-Transcribes Existing Audio Files

Meetily treats imported audio files as editable meetings that can be re-transcribed at any time using different Whisper models, processing everything locally through a pipeline of file validation, VAD segmentation, and GPU-accelerated speech recognition.

Meetily (Zackriya-Solutions/meetily) is an open-source meeting assistant that runs entirely on-device. Its import and enhance feature allows users to bring existing audio recordings into the application and later improve transcription accuracy by re-running the pipeline with upgraded models, all without uploading data to external servers.

The Import Pipeline

When you import an existing audio file, Meetily executes a multi-stage pipeline that transforms raw audio into searchable transcript segments. The process is implemented in frontend/src-tauri/src/audio/import.rs and orchestrates file validation, decoding, voice-activity detection, and transcription.

File Validation and Ingestion

The process begins when the frontend invokes start_import_audio_command via Tauri’s invoke API. The backend immediately calls validate_audio_file (lines 121-130 in import.rs), which uses FFmpeg to inspect the container format, sample rate, bit depth, and duration. If validation passes, the system returns an AudioFileInfo struct and copies the file into the application’s sandboxed meetings/ directory.

Audio Decoding and VAD Processing

Once ingested, ffmpeg::decode_to_pcm (defined in frontend/src-tauri/src/audio/ffmpeg.rs) decodes the audio to a raw 48 kHz PCM stream. This stream feeds into the Voice Activity Detector (VAD) in frontend/src-tauri/src/audio/vad.rs, which buffers PCM samples into a ring buffer and emits speech-only AudioChunk objects. By stripping silence before transcription, Meetily reduces processing time and improves Whisper’s accuracy on dense speech content.

Whisper Transcription and Database Storage

Each speech chunk is dispatched to WhisperEngine::transcribe (line 67 in frontend/src-tauri/src/whisper_engine/whisper_engine.rs). The engine loads the configured model via load_model, automatically selecting GPU acceleration when available (Metal on macOS, CUDA on NVIDIA, or Vulkan). The resulting text segments are stored as Segment rows in the local SQLite database via frontend/src-tauri/src/database/repositories/meeting.rs, associated with a new Meeting record that tracks metadata like meeting_id, title, and duration_seconds.

The Enhance Workflow (Re-Transcription)

The enhance capability allows users to re-transcribe existing meetings without re-importing the audio file. This is particularly useful when upgrading from a fast base model to a higher-accuracy medium or large-v3 model.

Model Selection and Re-processing

When the UI triggers enhancement, it invokes retranscribe_meeting_command, which enters through frontend/src-tauri/src/audio/retranscription.rs. The system reuses the start_import logic from import.rs but passes a force flag to bypass file copying and target the existing audio path. The VAD re-segments the original 48 kHz PCM stream, and WhisperEngine::transcribe processes the chunks using the newly specified model (e.g., model_name: "medium-v3").

In-Place Database Updates

Unlike initial imports, enhancement performs an in-place update of the database. The new transcript segments replace the old ones via UPDATE segment SET text = … operations, while the original audio file remains untouched in the meetings/ folder. This design makes re-transcription fast and lossless, as the expensive audio decoding step is skipped and only the neural inference phase repeats.

Progress Tracking and Cancellation

Throughout both import and enhancement workflows, Meetily emits ImportProgress events through Tauri’s event system. The ImportProgress struct (defined in import.rs) reports discrete stages: copying, decoding, vad, transcribing, and saving. The frontend listens via the listen API to drive progress bars and enable a “Cancel” button that triggers cancel_import, safely aborting the VAD or transcription loops.

Implementation Examples

The following TypeScript snippets demonstrate how to interact with the import and enhance feature from a React frontend:

// Import a new audio file from the filesystem
await invoke('start_import_audio_command', {
  path: '/Users/alice/recordings/meeting.wav',
  meetingTitle: 'Team Sync – 2024-06-12'
});

// Subscribe to progress updates for UI feedback
useEffect(() => {
  const unlisten = await listen<ImportProgress>('import-progress', ev => {
    setProgress(ev.payload);
  });
  return () => unlisten();
}, []);

To enhance an existing meeting with a higher-accuracy model:

// Re-transcribe using the medium-v3 model for better accuracy
await invoke('retranscribe_meeting_command', {
  meetingId: 'a1b2c3d4',
  newModel: 'medium-v3'  // Upgrading from default "base"
});

Summary

• Local-only processing: All transcription occurs within the Tauri binary using FFmpeg and Whisper; no network requests are sent to external APIs.
• Model-agnostic architecture: Switching between Whisper models (base, small, medium, large) requires only a configuration change and a re-run of the enhancement command.
• Deterministic progress: The ImportProgress event system provides granular feedback across copying, decoding, VAD, and transcription stages.
• Non-destructive enhancement: Re-transcription updates database records in place without modifying the original audio file, enabling iterative quality improvements.

Frequently Asked Questions

What audio formats does Meetily support for import?

Meetily relies on FFmpeg for decoding, which supports virtually all common audio containers including WAV, MP3, M4A, FLAC, and OGG. The validate_audio_file function confirms compatibility by checking the actual codec and sample rate before copying the file to the meetings/ directory.

Can I cancel a re-transcription job mid-process?

Yes. The import and enhance pipelines expose cancel_import helpers that set an atomic cancellation flag. When the VAD or Whisper engine detects this flag during chunk processing, they gracefully terminate the current operation and emit an import-cancelled event to the frontend.

Does enhancing a meeting overwrite the original transcript permanently?

The enhancement process updates the Segment rows in the SQLite database with new text content, but the operation is transactional. If the process fails mid-way, the database transaction rolls back, preserving the previous transcript. The original audio file in the meetings/ folder is never modified during re-transcription.

How does Meetily utilize GPU acceleration during transcription?

The WhisperEngine::transcribe method in whisper_engine.rs automatically detects and utilizes GPU backends—Metal for Apple Silicon, CUDA for NVIDIA GPUs, or Vulkan for compatible AMD/Intel hardware—when loading the model. This significantly speeds up the re-transcription process when enhancing meetings with large models like medium-v3.

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