How to Configure Custom Whisper Models and Paths in Meetily

You can configure custom Whisper models and paths in Meetily by instantiating WhisperEngine with a custom directory via new_with_models_dir() and registering your model in the WHISPER_MODEL_CATALOG static array in config.rs.

Meetily, an open-source meeting transcription tool from Zackriya-Solutions/meetily, uses a Rust-based WhisperEngine to handle speech-to-text processing. By default, the engine searches for models in development folders like frontend/models or the OS data directory in production, but you can override these locations and add bespoke model entries to fit your specific requirements.

Understanding the WhisperEngine Configuration

The transcription engine initializes through WhisperEngine::new_with_models_dir() in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. This constructor accepts an optional PathBuf parameter that defines where the engine looks for Whisper model files (e.g., ggml-tiny.bin, ggml-base-q5_1.bin). When you provide a custom path, the engine bypasses default directories and uses your specified location for model discovery, validation, and loading.

Setting a Custom Models Directory

Runtime Configuration via new_with_models_dir

To point Meetily at a specific folder containing your Whisper models, instantiate the engine with your custom path:

use std::path::PathBuf;
use meetily::frontend::src_tauri::whisper_engine::WhisperEngine;

// Point to a user-specified models folder
let custom_dir = PathBuf::from("/home/alice/meetily_models");
let engine = WhisperEngine::new_with_models_dir(Some(custom_dir))
    .expect("Failed to initialise WhisperEngine");

This method, defined at lines 83-105 in whisper_engine.rs, sets the internal models_dir field that subsequent operations reference.

Dynamic Path Updates via Tauri Commands

For runtime updates from the UI, expose a Tauri command that reinitializes the engine with a new directory:

#[tauri::command]
async fn set_custom_models_path(app_handle: tauri::AppHandle, path: String) -> Result<(), String> {
    let engine = app_handle.state::<WhisperEngine>();
    let new_engine = WhisperEngine::new_with_models_dir(Some(PathBuf::from(path)))
        .map_err(|e| e.to_string())?;
    *engine = new_engine;
    Ok(())
}

Register this command in frontend/src-tauri/src/lib.rs to allow the frontend to invoke path changes dynamically.

Adding Custom Models to the Catalog

Before the engine can recognize a custom model, you must register it in the WHISPER_MODEL_CATALOG static array located in frontend/src-tauri/src/config.rs. This catalog defines the model's display name, filename, size, and performance characteristics.

Add your custom entry following the tuple structure (name, filename, size_mb, accuracy, speed, description):

// In config.rs
pub const WHISPER_MODEL_CATALOG: &[(&str, &str, u32, &str, &str, &str)] = &[
    ("tiny", "ggml-tiny.bin", 75, "low", "fast", "Original tiny model"),
    // Custom model entry
    ("my-custom-large", "ggml-my-custom-large.bin", 3900,
        "high", "medium", "Fine-tuned large model for specialized vocabulary"),
];

The engine uses this metadata during discovery and validation to confirm file integrity and present options to users.

Model Discovery, Download, and Loading

Discovering Available Models

After initialization, call discover_models() to scan the configured directory and verify which catalog entries exist, checking file sizes and corruption status:

let available = engine.discover_models().await?;
for model in available {
    println!("{} – status: {:?}", model.name, model.status);
}

This implementation in whisper_engine.rs (lines 71-78) returns the current state of each model without loading them into memory.

Downloading Models

If your custom model is hosted at a URL supported by Meetily's download logic, use the built-in downloader:

engine.download_model("my-custom-large", None).await?;

For models hosted elsewhere or manually transferred, skip this step and place the file directly in your custom models directory with the exact filename specified in the catalog.

Loading Models for Transcription

Activate a specific model for inference using load_model():

engine.load_model("my-custom-large").await?;

Once loaded, the model remains active for subsequent transcription calls like transcribe_audio() or transcribe_audio_with_confidence(). The loading logic (lines 61-70 in whisper_engine.rs) handles GPU-aware context initialization automatically.

Summary

• Override default paths by instantiating WhisperEngine with new_with_models_dir(Some(PathBuf::from("..."))) to point to any readable directory.
• Register custom models in the WHISPER_MODEL_CATALOG static array in frontend/src-tauri/src/config.rs with metadata including filename, size, and performance labels.
• Manage model lifecycle through discover_models() for validation, download_model() for retrieval, and load_model() for activation.
• Expose runtime configuration via Tauri commands to allow UI-driven path changes without restarting the application.

Frequently Asked Questions

What file formats does Meetily support for Whisper models?

Meetily expects Whisper models in the GGML format, specifically files with extensions like .bin (e.g., ggml-tiny.bin, ggml-base-q5_1.bin). The engine validates these files during the discovery phase by checking their presence in the configured directory and verifying expected file sizes against the WHISPER_MODEL_CATALOG entries.

How do I point Meetily to an existing Whisper model directory?

Pass the directory path to WhisperEngine::new_with_models_dir() when creating the engine instance. This method, located in frontend/src-tauri/src/whisper_engine/whisper_engine.rs, accepts an optional PathBuf and directs all model operations to your specified location instead of the default development or OS data directories.

Can I use fine-tuned or specialized Whisper models with Meetily?

Yes. Add your fine-tuned model to the WHISPER_MODEL_CATALOG in frontend/src-tauri/src/config.rs with the appropriate filename, size in megabytes, and descriptive metadata. Place the actual .bin file in your configured models directory, and the engine will treat it as a selectable option alongside standard Whisper variants.

Where does Meetily store models by default?

In development environments, Meetily searches for models in frontend/models and other legacy locations. In production builds, it uses the OS-specific data directory. You can override either location by providing a custom path to WhisperEngine::new_with_models_dir() at initialization.

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