DOCSEARCHbyAlgolia
Submit Docs

Meetily AI Meeting Assistant

repository·main·Indexed 11 days ago

https://github.com/zackriya-solutions/meetily

A privacy-first, open-source AI meeting assistant that runs locally to provide real-time transcription, AI-powered summaries, and professional audio capture. Built as a Tauri-based desktop application using Next.js and Rust, it supports local transcription via Whisper or Parakeet and integrates with AI providers like Ollama, Claude, Groq, and OpenRouter. Version 0.4.0 features GPU acceleration and customizable JSON summary templates.

Tokens
31.7K
Snippets
99
Records
149
Agent score
98%

What's inside Meetily

  1. Meetily Core Features Overview

    main

    Meetily is a privacy-first AI meeting assistant with the following core capabilities:

    • Local Transcription: Uses Whisper or Parakeet models to transcribe meetings entirely on your device.
    • Real-time Transcription: Provides live transcripts as meetings occur.
    • AI-Powered Summaries: Generates summaries using your chosen AI provider (Ollama, Claude, etc.).
    • Import & Enhance (Beta): Import existing audio files for transcription or re-transcribe them using different models or languages.
    • Professional Audio Mixing: Captures both microphone and system audio with intelligent ducking and clipping prevention.
    • GPU Acceleration: Automatically uses hardware acceleration (Apple Silicon/Metal/CoreML on macOS; NVIDIA/CUDA or AMD/Intel/Vulkan on Windows/Linux) if available at build time.

  2. Understand the current Meetily integration model

    main
    Meetily has moved away from using a standalone whisper-server HTTP service. In the current architecture, the Next.js frontend communicates directly with the Rust/Tauri core via Tauri commands and events. Local transcription is managed internally within the desktop application rather than through an external HTTP API.

  3. Configure AI providers for meeting summaries

    main

    Meetily supports multiple AI providers for generating meeting summaries. You can choose between local models or cloud-based APIs:

    • Ollama: Recommended for local, privacy-first processing.
    • Claude, Groq, or OpenRouter: Cloud-based providers.
    • Custom OpenAI Endpoint: You can use any OpenAI-compatible endpoint, which is ideal for organizations using custom AI infrastructure.

    All transcription and data processing are designed to stay on your local machine to maintain privacy.

  4. Understand logging behavior in Development vs Production

    main

    Meetily's logging behavior changes significantly based on the build profile to optimize transcription latency:

    FeatureDevelopment (debug_assertions = true)Production (debug_assertions = false)
    perf_debug!Active (behaves like log::debug!)No-op (zero overhead)
    Async LoggerProcesses all messagesOnly critical info/warn/error active
    Smart BatchingProvides detailed summariesMinimal logging frequency
    Audio PipelineHigh verbosityReduced by 99% (every 100 chunks)
    Transcription ResultsEvery resultEvery 5th result
    Error MessagesEvery errorEvery 100th error

  5. Understand the Meetily system architecture

    main

    Meetily is a cross-platform desktop application built using the Tauri framework. It follows a decoupled architecture where a Next.js frontend handles the user interface and communicates with a high-performance Rust backend via Tauri's command system.

    Architecture Layers

    1. User Interface (Frontend): A Next.js application used for managing meetings, viewing transcriptions, and application configuration.
    2. Core Logic (Backend): A Rust-based core managed by Tauri that orchestrates several specialized engines:
      • Audio Engine: Handles microphone and system audio capture and processing.
      • Transcription Engine: Performs local speech-to-text using models like Whisper or Parakeet (supports GPU acceleration).
      • Database: A local SQLite instance for storing meeting metadata, transcripts, and summaries.
      • Summary Engine: Generates summaries using LLMs, including local integration via Ollama.

  6. How Meetily's GPU auto-detection works

    main

    The build scripts (dev-gpu.sh and build-gpu.sh) orchestrate the build process by detecting available hardware acceleration SDKs. The process follows these steps:

    1. Locate Project: Finds package.json.
    2. Detect GPU: Runs scripts/auto-detect-gpu.js (or uses the TAURI_GPU_FEATURE environment variable).
    3. Build Sidecar: Builds llama-helper with the detected feature (debug or release).
    4. Copy Binary: Moves the built sidecar to src-tauri/binaries with the target triple.
    5. Run Tauri: Executes npm run tauri:dev or tauri:build with the feature flag passed via environment variable.

    Detection Priority

    PriorityHardwareRequirementResulting Feature
    1NVIDIA CUDAnvidia-smi exists + (CUDA_PATH or nvcc found)--features cuda
    2AMD ROCmrocm-smi exists + (ROCM_PATH or hipcc found)--features hipblas
    3Vulkanvulkaninfo exists + VULKAN_SDK + BLAS_INCLUDE_DIRS set--features vulkan
    4OpenBLASBLAS_INCLUDE_DIRS set--features openblas
    5CPU-onlyNone of the above(no features)

    Note: Having GPU drivers is insufficient; you must have the development SDK (CUDA toolkit, ROCm, or Vulkan SDK) installed for acceleration to work.

  7. Understand the current Meetily architecture

    main

    Meetily has transitioned from a client-server model to a self-contained desktop application. The backend/ directory contains legacy Python/FastAPI and Docker implementations that are unsupported and should not be used for new installations or production deployments.

    The current supported architecture is a Tauri-based desktop application consisting of:

    • Frontend UI: Built with Next.js (located in frontend/src).
    • Local Backend & Native Integration: Provided by Rust/Tauri (located in frontend/src-tauri).
    • Workflows: Local transcription, meeting storage, and AI summaries are handled directly by the bundled desktop app rather than an external FastAPI service.

  8. Meetily PRO vs Community Edition

    main

    Meetily is offered in two tiers:

    Community Edition

    • Free & Open Source forever.
    • Includes local transcription and AI summaries.
    • Focuses on privacy and local-first processing.

    Meetily PRO

    • Professional-grade solution with enhanced accuracy and advanced features.
    • Key Features: Custom summary templates, advanced exports (PDF, DOCX, Markdown), auto-meeting detection, and speaker identification (planned for mid-June).
    • Enterprise Ready: Supports self-hosted deployment, GDPR compliance tools, and priority support.
    • Discount: Use coupon code LAUNCH20 for 20% off until the next Community Edition release.

  9. Supported GPU Acceleration Backends in Meetily

    main

    Meetily utilizes the whisper-rs library to provide GPU acceleration for transcription tasks. The following backends are supported depending on your hardware:

    • CUDA: For NVIDIA GPUs.
    • Metal: For Apple Silicon and modern Intel-based Macs.
    • Core ML: An additional acceleration layer for Apple Silicon.
    • Vulkan: A cross-platform solution for modern AMD and Intel GPUs.
    • OpenBLAS: A CPU-based optimization for improved performance over standard CPU processing.

  10. Understand Meetily's Local-First Data Processing

    main

    Meetily follows a 'Local-First' processing philosophy to ensure meeting data remains private. Most sensitive operations are performed on your own device rather than being transmitted to external servers:

    • Meeting transcription: Handled entirely on your device using local Whisper models.
    • Audio recordings: Never transmitted to external servers.
    • Meeting content: Remains on your local infrastructure.
    • AI summaries: Can be generated locally (e.g., via Ollama) or through your chosen LLM provider.

    Because of this architecture, you maintain full ownership of all meeting data, transcripts, and recordings, with the ability to export or delete them at any time.

  11. Run Meetily in development mode

    main

    Depending on your operating system, use the provided scripts or pnpm commands to start the application in development mode. You can also specify a log level (info, debug, or trace) on macOS.

    macOS: Use ./clean_run.sh. Example for debug logging: ./clean_run.sh debug.

    Windows: Use clean_run_windows.bat or the pnpm command pnpm run tauri:dev.

    Frontend Only (Next.js): Use pnpm run dev to run only the web frontend.

    # macOS development
./clean_run.sh debug

# Windows development
clean_run_windows.bat

# Direct pnpm commands (Cross-platform)
pnpm run tauri:dev
pnpm run dev

  12. Configure GPU acceleration backends manually

    main

    If automatic detection fails or you want to force a specific backend, you can manually enable feature flags in the frontend/src-tauri/Cargo.toml file. After modifying the [features] section, build the application using pnpm tauri:build.

    To enable CUDA, modify your Cargo.toml like this:

    [features]
default = ["cuda"]

# ... other features

cuda = ["whisper-rs/cuda"]