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

> Re-transcribe audio files with Meetily's import and enhance feature. Leverage local processing, VAD segmentation, and GPU acceleration for precise transcriptions using various Whisper models.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-07-07

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/retranscription.rs). The system reuses the `start_import` logic from [`import.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```typescript
// 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:

```typescript
// 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`.