How to Configure Meetily Settings: A Complete Guide to AI Meeting Transcription Preferences

Meetily stores all user preferences in a centralized React context and persists them via Tauri commands to a Rust backend, exposing configuration through modal UI components for models, devices, languages, and notifications.

Meetily is an open-source AI meeting transcription application built by Zackriya-Solutions that combines a React frontend with a Tauri-powered Rust backend. To configure Meetily settings effectively, you must interact with the ConfigContext provider and its associated modal components, which handle everything from AI model selection to macOS system permissions.

Understanding Meetily's Configuration Architecture

All user-configurable state lives in ConfigContext (frontend/src/contexts/ConfigContext.tsx). This React context tracks model configuration, audio devices, transcription language, notification preferences, and hidden beta flags. The context exposes a rich API consumed by UI components:

const {
  modelConfig, setModelConfig,
  selectedDevices, setSelectedDevices,
  selectedLanguage, setSelectedLanguage,
  showConfidenceIndicator, toggleConfidenceIndicator,
  notificationSettings, updateNotificationSettings,
} = useConfig();

When the application starts, the ConfigProvider hydrates this state by calling methods in configService.ts (frontend/src/services/configService.ts), which wraps Tauri commands to fetch persisted values from disk.

Accessing the Settings Interface

The primary UI for editing configuration is consolidated in SettingsModal.tsx (frontend/src/app/_components/SettingsModal.tsx). This component renders distinct panes based on user navigation:

• Model Settings (lines 95-124): Controls AI summarization providers and model selection via <select> elements.
• Device Settings (lines 84-89): Wraps the DeviceSelection component for microphone and system audio input.
• Language Settings (lines 25-30): Wraps the LanguageSelection component for transcription language.
• Transcript Settings (lines 65-70): Configures provider-specific models like Whisper or Parakeet.

Users access these modals by navigating to /settings, triggered via the router link at line 530 in Sidebar/index.tsx.

Opening Settings Programmatically

To open the settings page from anywhere in the UI:

import { useRouter } from 'next/router';

function openSettings() {
  const router = useRouter();
  router.push('/settings');
}

Configuring AI Models and Providers

Model configuration is defined by the ModelConfig type in configService.ts. The settings UI allows you to select between providers like OpenAI, Ollama, or local Whisper installations.

To switch the summarization provider to Ollama and select a specific model:

setModelConfig(prev => ({
  ...prev,
  provider: 'ollama',
  model: 'llama3.2:latest',
}));

Changes invoke the Tauri command set_model_config implicitly through the setModelConfig setter, persisting your selection to the backend.

Selecting Audio Input Devices

Audio device management is handled by the DeviceSelection component (frontend/src/components/DeviceSelection.tsx). It fetches the platform-specific device list via the Tauri command get_audio_devices (line 57) and updates the context when the user selects inputs.

To programmatically set microphone and system audio devices:

setSelectedDevices({
  micDevice: 'Built-in Microphone',
  systemDevice: 'BlackHole 2ch',
});

Setting Transcription Language and Provider

Language selection works through the LanguageSelection component, which respects the active transcription provider defined in transcriptModelConfig.provider. This ensures that language options are filtered appropriately for Whisper, Azure, or other transcription backends.

Enable confidence indicators for transcript words using:

toggleConfidenceIndicator(true);

Managing Notification Preferences

Notification settings are stored in the NotificationSettings interface within ConfigContext. The UI controls live in PreferenceSettings (imported by the Settings modal) and persist via the updateNotificationSettings method.

To enable meeting reminders every 10 minutes:

await updateNotificationSettings({
  ...notificationSettings,
  meeting_reminder_minutes: [5, 10, 15],
  show_meeting_reminders: true,
});

This ultimately calls Rust-side notification managers through Tauri's invoke bridge.

Handling macOS System Permissions

For platform-specific operations requiring macOS system preferences (microphone or screen-recording permissions), Meetily exposes the helper command open_system_settings in frontend/src-tauri/src/utils.rs (lines 9-24).

The PermissionWarning component (frontend/src/components/PermissionWarning.tsx) invokes this command to guide users to the correct macOS security panes when permissions are missing.

How Configuration Persistence Works

Meetily follows a reactive five-step configuration flow:

1. Load saved settings – On app start, ConfigProvider calls configService methods to hydrate the React context from disk.
2. Render modals – SettingsModals displays the appropriate UI when the user navigates to /settings.
3. User changes a value – UI components update the context via setters like setModelConfig or setSelectedDevices.
4. Persist to backend – Each setter triggers a Tauri invoke that writes to disk (e.g., api_set_model_config, save_notification_settings).
5. Live feedback – Changes instantly affect the running app, such as toggling showConfidenceIndicator to update transcript rendering.

Summary

• Centralized State: All settings live in ConfigContext (frontend/src/contexts/ConfigContext.tsx) and expose getters/setters for models, devices, languages, and notifications.
• Modal UI: The SettingsModal component (frontend/src/app/_components/SettingsModal.tsx) provides the interface for editing configuration across five distinct panes.
• Audio Devices: Use DeviceSelection (frontend/src/components/DeviceSelection.tsx) with the get_audio_devices Tauri command to enumerate and select inputs.
• Persistence: Configuration changes flow through Tauri commands to Rust backend functions that write settings to disk.
• Permissions: macOS-specific system settings are accessed via open_system_settings in frontend/src-tauri/src/utils.rs.

Frequently Asked Questions

Where are Meetily settings stored on disk?

Meetily persists configuration through Tauri commands invoked by configService.ts. The actual storage location depends on the Rust backend implementation, typically following Tauri's standard application data directories for your operating system (e.g., ~/.config/meetily on Linux or ~/Library/Application Support/meetily on macOS).

Can I configure Meetily settings without using the GUI?

Yes. While the Settings modal provides the primary interface, you can programmatically modify any configuration value by importing useConfig from ConfigContext and calling the exposed setters like setModelConfig or updateNotificationSettings. These methods automatically persist changes to the Rust backend via Tauri invoke calls.

How do I change the AI summarization provider to a local Ollama instance?

Navigate to the Model Settings pane (rendered by SettingsModal.tsx lines 95-124) and select "Ollama" from the provider dropdown. Alternatively, programmatically update the context: setModelConfig(prev => ({ ...prev, provider: 'ollama', model: 'your-model-name' })). Ensure your Ollama server is running and accessible before switching providers.

Why don't my microphone changes take effect immediately?

Audio device selection requires valid system permissions. If the device change fails silently, check the PermissionWarning component (frontend/src/components/PermissionWarning.tsx) for guidance. On macOS, you may need to use the open_system_settings command (defined in frontend/src-tauri/src/utils.rs lines 9-24) to grant microphone access in System Preferences before the DeviceSelection component can activate the new input.

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