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

> Configure Meetily settings easily with this guide. Learn to manage AI transcription preferences for models, devices, languages, and notifications through our intuitive modal UI.

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

---

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

```tsx
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/configService.ts) ([`frontend/src/services/configService.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/SettingsModal.tsx)** ([`frontend/src/app/_components/SettingsModal.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/Sidebar/index.tsx).

### Opening Settings Programmatically

To open the settings page from anywhere in the UI:

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

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

```tsx
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:

```tsx
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:

```tsx
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/utils.rs) (lines 9-24).

The **`PermissionWarning`** component ([`frontend/src/components/PermissionWarning.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.