Meetily 深度解析：16K Stars 的 Rust 隐私优先 AI 会议助手如何用 Parakeet/Whisper 实时转录 + Ollama 本地摘要让企业会议数据永远不出设备——从 Tauri 架构到生产级部署的完整实战指南

引言：你的会议数据，真的安全吗？

2024 年，IBM《数据泄露成本报告》给出了一个触目惊心的数字：单次数据泄露平均损失 440 万美元。而到 2025 年底，欧盟 GDPR 累计罚款已突破 58.8 亿欧元。仅美国加州一地，当年就立案了超过 400 起非法录音诉讼。

这些数字背后，有一个被大多数团队忽视的盲区——会议录音和转录数据。

当你使用 Otter.ai、Granola、Fireflies 这类云端 AI 会议助手时，你的每一句发言、每一个商业决策、每一次头脑风暴的原始音频和文字记录，都被上传到了第三方服务器。你不知道它们被存储在哪里，不知道谁有权限访问，不知道是否被用于模型训练，更不知道这些数据会在什么时候以什么方式泄露。

对于金融、法律、医疗、国防等行业的从业者来说，这不是"可能的风险"，而是"确定的违规"。

Meetily 的出现，就是为了彻底解决这个问题。

这个由 Zackriya Solutions 团队开发的开源项目，在 GitHub 上已获得超过 16,000 Stars，累计下载量突破 279,000 次。它的核心承诺只有一句话：所有音频捕获、语音转录、AI 摘要生成，全部在你自己的设备上完成，数据永远不离开你的电脑。

本文将从架构设计、核心算法、代码实现、性能优化、部署实战五个维度，深度解析 Meetily 是如何用 Rust + Tauri + Whisper/Parakeet + Ollama 构建出一个生产级的隐私优先 AI 会议助手的。

第一章：为什么需要本地化 AI 会议助手？

1.1 云端会议工具的隐私困境

市面上主流的 AI 会议助手（Otter.ai、Fireflies.ai、Granola、Noty.ai 等）无一例外采用云端架构：

用户设备 → 音频上传 → 云端 ASR 转录 → 云端 LLM 摘要 → 结果返回

这条链路上的每一个环节都存在数据泄露风险：

• 传输层：音频数据经过公网传输，可能被中间人攻击截获
• 存储层：原始音频和转录文本存储在第三方 S3/GCS 上，供应商员工理论上可访问
• 模型层：部分供应商会将用户数据用于模型微调，你的商业机密可能成为训练数据
• 合规层：数据跨境传输可能违反 GDPR、HIPAA、SOX 等法规

1.2 本地化的技术可行性

2024-2026 年，本地 AI 推理技术发生了质变：

这些技术的成熟，让"全本地 AI 会议助手"从理想变成了现实。而 Meetily，正是这个交汇点上最完整的作品。

第二章：系统架构——Tauri + Rust + Next.js 的精妙组合

2.1 技术栈选择

Meetily 采用 Tauri 框架构建，这是一个用 Rust 编写的跨平台桌面应用框架。与 Electron 相比，Tauri 有三个决定性优势：

1. 内存占用低：Electron 应用通常占用 200-500MB 内存，Tauri 应用仅需 30-80MB
2. 安全性高：Rust 的内存安全特性 + Tauri 的权限沙箱机制
3. 包体积极小：Electron 应用通常 100MB+，Tauri 应用仅 5-15MB

Meetily 技术架构图：

┌─────────────────────────────────────────────┐
│                  Tauri Shell                 │
│  ┌─────────────────────────────────────────┐ │
│  │         Next.js Frontend (WebView)      │ │
│  │  ┌──────────┐ ┌──────────┐ ┌─────────┐ │ │
│  │  │ 录音控制  │ │ 实时字幕  │ │ AI摘要  │ │ │
│  │  └──────────┘ └──────────┘ └─────────┘ │ │
│  └─────────────────────────────────────────┘ │
│                    ↕ IPC                     │
│  ┌─────────────────────────────────────────┐ │
│  │           Rust Backend (Core)           │ │
│  │  ┌──────────┐ ┌──────────┐ ┌─────────┐ │ │
│  │  │ Audio    │ │ ASR      │ │ LLM     │ │ │
│  │  │ Capture  │ │ Engine   │ │ Summary │ │ │
│  │  │ (CPAL)   │ │ (Whisper/│ │ (Ollama)│ │ │
│  │  │          │ │ Parakeet)│ │         │ │ │
│  │  └──────────┘ └──────────┘ └─────────┘ │ │
│  └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────┘

2.2 为什么选 Rust 做后端？

语音处理是 CPU 密集型任务，Rust 在这个场景下的优势非常明显：

// Rust 的零成本抽象在音频处理中的体现
// 音频缓冲区直接操作，无 GC 停顿
pub struct AudioBuffer {
    samples: Vec<f32>,
    sample_rate: u32,
    channels: u16,
}

impl AudioBuffer {
    /// 实时音频流处理——Rust 的所有权系统确保无数据竞争
    pub fn process_chunk(&mut self, raw: &[i16]) -> &[f32] {
        self.samples.clear();
        for &sample in raw {
            // i16 → f32 归一化，零拷贝
            self.samples.push(sample as f32 / 32768.0);
        }
        &self.samples
    }
}

对比 Python 实现，Rust 版本的音频预处理速度快 15-20 倍，且没有 GIL 限制，可以真正并行处理音频采集和 ASR 推理。

2.3 前端架构

前端使用 Next.js 构建，通过 Tauri 的 IPC 机制与 Rust 后端通信：

// 前端通过 Tauri IPC 调用 Rust 后端
import { invoke } from '@tauri-apps/api/core';

// 开始录音
async function startRecording() {
  await invoke('start_audio_capture', {
    deviceName: selectedDevice,
    sampleRate: 16000,
  });
}

// 监听实时转录结果
import { listen } from '@tauri-apps/api/event';

const unlisten = await listen<TranscriptChunk>('transcription-update', (event) => {
  const { speaker, text, timestamp, confidence } = event.payload;
  appendToTranscript({ speaker, text, timestamp, confidence });
});

// 请求 AI 摘要
async function generateSummary(transcript: string) {
  const summary = await invoke<string>('generate_meeting_summary', {
    transcript,
    provider: 'ollama', // 或 'claude', 'groq', 'openrouter'
    model: 'llama3.1:8b',
  });
  return summary;
}

第三章：语音转录引擎——Whisper 与 Parakeet 的双引擎架构

3.1 Whisper：开源语音识别的基石

OpenAI 的 Whisper 是目前最广泛使用的开源语音识别模型。Meetily 集成了 whisper.cpp（Georgi Gerganov 的 C++ 移植版本），实现了在纯 CPU 上的实时转录。

Whisper 的核心架构是 Encoder-Decoder Transformer：

# Whisper 的核心处理流程（概念性伪代码）
class WhisperEncoder:
    def __init__(self, n_mels=80, n_ctx=448, n_state=1024):
        self.conv1 = Conv1d(n_mels, n_state, kernel_size=3, padding=1)
        self.conv2 = Conv1d(n_state, n_state, kernel_size=3, stride=2, padding=1)
        self.blocks = [ResidualAttentionBlock(n_state) for _ in range 24]
        self.ln_post = LayerNorm(n_state)

    def forward(self, mel: torch.Tensor) -> torch.Tensor:
        # mel: [batch, n_mels, n_frames]
        x = F.gelu(self.conv1(mel))
        x = F.gelu(self.conv2(x))
        x = x.permute(0, 2, 1)  # [batch, n_ctx, n_state]
        for block in self.blocks:
            x = block(x)
        return self.ln_post(x)

Meetily 支持多种 Whisper 模型变体：

3.2 NVIDIA Parakeet：4 倍速的秘密武器

Parakeet 是 NVIDIA 基于 FastConformer 架构开发的语音识别模型系列。其中 Parakeet-TDT-0.6B 是 Meetily 的默认推荐模型，原因在于它的性能/速度比远超 Whisper：

# Parakeet FastConformer 的核心创新
class FastConformerBlock(nn.Module):
    """
    FastConformer vs 标准 Conformer 的关键改进：
    1. 深度可分离卷积（Depthwise Separable Conv）替代标准卷积
    2. 下采样因子从 4 降到 2，减少信息损失
    3. 注意力头数增加，但每头维度减小
    """
    def __init__(self, d_model=512, n_heads=8, conv_kernel=31):
        super().__init__()
        # 前馈模块 1
        self.ff1 = FeedForward(d_model, d_model * 4)
        # 多头自注意力
        self.self_attn = MultiHeadAttention(d_model, n_heads)
        # 深度可分离卷积模块
        self.conv = DepthwiseSeparableConv(d_model, conv_kernel)
        # 前馈模块 2
        self.ff2 = FeedForward(d_model, d_model * 4)
        # 层归一化
        self.norm = LayerNorm(d_model)

class TDTDecoder(nn.Module):
    """
    TDT（Token-and-Duration Transducer）解码器
    与 CTC 不同，TDT 同时预测 token 和持续时间
    优势：更自然的对齐，减少重复/遗漏
    """
    def __init__(self, vocab_size, d_model=512):
        super().__self__)
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.rnn = nn.LSTM(d_model, d_model, num_layers=2)
        self.joint = JointNetwork(d_model, vocab_size)

    def forward(self, encoder_out, targets):
        # 预测 token 和 duration
        token_logits, duration_logits = self.joint(encoder_out, targets)
        return token_logits, duration_logits

Parakeet-TDT-0.6B 的核心数据：

• 参数量：600M（Whisper-large 的 38%）
• WER：英语 ~2.5%（与 Whisper-large-v3 相当）
• 推理速度：比 Whisper-large-v3 快 4 倍
• 支持语言：英语为主，通过 ONNX 可在任何平台运行

3.3 Meetily 的双引擎切换机制

Meetily 允许用户在 Whisper 和 Parakeet 之间自由切换：

// Rust 后端的 ASR 引擎抽象
pub trait AsrEngine: Send + Sync {
    fn transcribe(&self, audio: &[f32]) -> Result<TranscriptSegment>;
    fn is_realtime(&self) -> bool;
    fn model_name(&self) -> &str;
}

// Whisper 实现
pub struct WhisperEngine {
    model: WhisperModel,
    language: Option<String>,
}

impl AsrEngine for WhisperEngine {
    fn transcribe(&self, audio: &[f32]) -> Result<TranscriptSegment> {
        // 音频预处理：重采样到 16kHz，转 mel 频谱
        let mel = self.audio_to_mel(audio);
        // 编码器前向
        let encoder_out = self.model.encoder.forward(&mel);
        // 解码器自回归生成
        let tokens = self.model.decoder.generate(encoder_out, 448);
        // token → 文本
        let text = self.model.tokenizer.decode(&tokens);
        Ok(TranscriptSegment {
            text,
            start_time: 0.0,
            end_time: audio.len() as f32 / 16000.0,
            confidence: 0.95,
        })
    }
}

// Parakeet 实现（ONNX Runtime）
pub struct ParakeetEngine {
    session: ort::Session,
    tokenizer: SentencePieceTokenizer,
}

impl AsrEngine for ParakeetEngine {
    fn transcribe(&self, audio: &[f32]) -> Result<TranscriptSegment> {
        // ONNX 推理，利用硬件加速
        let inputs = ort::inputs![audio]?;
        let outputs = self.session.run(inputs)?;
        let logits = outputs["logits"].try_extract_tensor::<f32>()?;
        // TDT 解码
        let tokens = self.tdt_decode(logits)?;
        let text = self.tokenizer.decode(&tokens);
        Ok(TranscriptSegment { text, .. })
    }
}

3.4 GPU 加速策略

Meetily 针对不同平台采用了差异化的加速方案：

# Cargo.toml 中的条件编译
[target.'cfg(target_os = "macos")'.dependencies]
# Apple Silicon: 使用 Metal + CoreML
metal = "0.27"
coreml-rs = "0.4"

[target.'cfg(target_os = "windows")'.dependencies]
# Windows: NVIDIA CUDA 或 DirectML
cuda-rs = "0.8"
directml = "0.3"

[target.'cfg(target_os = "linux")'.dependencies]
# Linux: NVIDIA CUDA 或 Vulkan
cuda-rs = "0.8"
vulkan-rs = "0.5"

在 Apple Silicon 设备上，Meetily 通过 CoreML 将 Whisper 的编码器卸载到 Neural Engine，实现 2-3 倍的额外加速。在 NVIDIA 显卡上，Parakeet 的 ONNX 模型可以通过 CUDA 执行提供程序获得 5-8 倍的推理加速。

第四章：说话人分离（Speaker Diarization）——谁在说话？

4.1 说话人分离的核心挑战

会议转录的痛点不仅是"说了什么"，更是"谁说的"。一段典型的多人会议音频，需要解决：

1. VAD（Voice Activity Detection）：检测哪些时间段有人在说话
2. 说话人嵌入（Speaker Embedding）：提取每个说话人的声纹特征
3. 聚类（Clustering）：将同一说话人的片段归类
4. 重叠检测（Overlap Detection）：处理多人同时发言的情况

4.2 Meetily 的说话人分离流程

# 说话人分离的完整流程（概念性实现）
class SpeakerDiarizer:
    def __init__(self):
        self.vad = SileroVAD()           # 轻量级 VAD
        self.embedding = ECAPA_TDNN()     # 说话人嵌入模型
        self.clustering = SpectralClustering()

    def diarize(self, audio: np.ndarray) -> List[DiarizationSegment]:
        # 1. VAD：检测语音活动区域
        speech_segments = self.vad.detect(audio)
        # 输出: [(start_ms, end_ms), ...]

        # 2. 提取每个语音段的说话人嵌入
        embeddings = []
        for start, end in speech_segments:
            segment = audio[start:end]
            emb = self.embedding.extract(segment)  # [192] 向量
            embeddings.append(emb)

        # 3. 谱聚类：自动确定说话人数量
        embeddings_matrix = np.stack(embeddings)
        labels = self.clustering.fit_predict(embeddings_matrix)

        # 4. 生成带说话人标签的时间轴
        result = []
        for (start, end), label in zip(speech_segments, labels):
            result.append(DiarizationSegment(
                start_ms=start,
                end_ms=end,
                speaker_id=f"Speaker_{label}",
            ))
        return result

4.3 Meetily 的音频采集架构

Meetily 的一个技术亮点是同时采集麦克风和系统音频，这对会议转录至关重要：

// Rust 后端的音频采集模块
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};

pub struct AudioCapture {
    mic_stream: cpal::Stream,
    system_stream: cpal::Stream,
    mixer: AudioMixer,
}

impl AudioCapture {
    pub fn new() -> Result<Self> {
        let host = cpal::default_host();

        // 麦克风输入
        let mic_device = host.default_input_device()
            .expect("No input device available");
        let mic_config = mic_device.default_input_config()?;

        // 系统音频输出（loopback）
        let system_device = host.default_output_device()
            .expect("No output device available");
        let system_config = system_device.default_output_config()?;

        // 创建混音器
        let mixer = AudioMixer::new(
            mic_config.sample_rate().0,
            system_config.sample_rate().0,
        );

        Ok(Self { mic_stream, system_stream, mixer })
    }

    /// 智能混音：自动调节麦克风/系统音频比例
    /// 当用户说话时降低系统音量（ducking）
    pub fn mix_with_ducking(&self, mic: &[f32], system: &[f32]) -> Vec<f32> {
        let mic_energy = rms_energy(mic);
        let duck_factor = if mic_energy > 0.01 {
            0.3 // 用户说话时，系统音频降到 30%
        } else {
            1.0 // 静音时，系统音频满量
        };

        mic.iter()
            .zip(system.iter())
            .map(|(&m, &s)| m + s * duck_factor)
            .collect()
    }
}

这个 ducking 机制确保了当参会者发言时，来自 Zoom/Teams 的远端音频会自动降低音量，避免干扰本地语音识别。

第五章：AI 摘要生成——Ollama 驱动的本地 LLM

5.1 Ollama 集成架构

Meetily 使用 Ollama 作为默认的本地 LLM 推理引擎。Ollama 的优势在于：

• 一行命令启动本地 LLM 服务
• 支持 Llama 3.1、Mistral、Qwen 等主流模型
• 提供 OpenAI 兼容的 API 接口
• 自动管理模型下载和量化

// Meetily 的 LLM 摘要生成模块
use reqwest::Client;

pub struct SummaryGenerator {
    client: Client,
    endpoint: String,  // 默认 http://localhost:11434
    model: String,     // 默认 llama3.1:8b
}

impl SummaryGenerator {
    pub async fn generate_summary(
        &self,
        transcript: &str,
        prompt_type: SummaryType,
    ) -> Result<String> {
        let system_prompt = match prompt_type {
            SummaryType::Brief => {
                "你是一个专业的会议记录助手。请根据以下会议转录内容，生成简洁的会议摘要。\
                 包含：1) 讨论的主要议题 2) 关键决策 3) 待办事项。\
                 使用中文回复，格式清晰。"
            }
            SummaryType::Detailed => {
                "你是一个专业的会议分析师。请详细分析以下会议内容，生成深度分析报告。\
                 包含：1) 每个议题的详细讨论过程 2) 不同参会者的观点 3) 决策及其依据 \
                 4) 行动项和负责人 5) 遗留问题。使用中文回复。"
            }
            SummaryType::ActionItems => {
                "请从以下会议内容中提取所有行动项（Action Items）。\
                 格式：- [负责人] 具体任务 (截止时间)。如果没有明确截止时间标注'待定'。"
            }
        };

        let body = serde_json::json!({
            "model": self.model,
            "messages": [
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": format!("会议转录内容：\n\n{}", transcript)}
            ],
            "stream": false,
            "options": {
                "temperature": 0.3,
                "num_predict": 4096
            }
        });

        let response = self.client
            .post(format!("{}/api/chat", self.endpoint))
            .json(&body)
            .send()
            .await?;

        let result: OllamaResponse = response.json().await?;
        Ok(result.message.content)
    }
}

5.2 多 LLM 提供商支持

除了 Ollama，Meetily 还支持多种 LLM 提供商：

// 前端 LLM 提供商配置界面
interface LLMProvider {
  name: string;
  endpoint: string;
  apiKey?: string;
  models: string[];
}

const providers: LLMProvider[] = [
  {
    name: 'Ollama (本地推荐)',
    endpoint: 'http://localhost:11434',
    models: ['llama3.1:8b', 'mistral:7b', 'qwen2.5:14b'],
  },
  {
    name: 'Claude',
    endpoint: 'https://api.anthropic.com/v1',
    apiKey: 'sk-ant-...',  // 用户自行配置
    models: ['claude-3-5-sonnet-20241022'],
  },
  {
    name: 'Groq',
    endpoint: 'https://api.groq.com/openai/v1',
    apiKey: 'gsk_...',
    models: ['llama-3.1-70b-versatile'],
  },
  {
    name: 'OpenRouter',
    endpoint: 'https://openrouter.ai/api/v1',
    apiKey: 'sk-or-...',
    models: ['meta-llama/llama-3.1-70b-instruct'],
  },
  {
    name: '自定义 OpenAI 兼容',
    endpoint: 'http://your-server:8080/v1',
    apiKey: 'your-key',
    models: ['your-model'],
  },
];

这种灵活的架构让企业用户可以根据自身基础设施选择最合适的 LLM 后端。有 GPU 集群的企业可以用 Ollama 跑大模型，轻量级团队可以用 Groq 的免费 API，对隐私要求最高的可以用完全离线的 Ollama + Llama。

5.3 提示词工程

Meetily 的摘要质量很大程度上取决于提示词设计。以下是核心提示词模板：

const MEETING_SUMMARY_PROMPT: &str = r#"
## 角色
你是一个专业的会议记录分析师，擅长从原始转录中提取关键信息。

## 任务
根据以下会议转录内容，生成结构化的会议纪要。

## 要求
1. **会议概要**：2-3 句话概括会议主题和结论
2. **关键讨论点**：按议题分组，每个议题包含：
   - 议题名称
   - 讨论要点（2-4 条）
   - 不同观点（如有分歧）
3. **决策记录**：所有达成共识的决策，标注决策依据
4. **行动项**：每个行动项包含负责人、具体任务、截止时间
5. **遗留问题**：未解决需要后续跟进的问题

## 注意
- 如果转录中有不确定的内容，用 [?] 标注
- 不要编造转录中没有的信息
- 保持客观，不添加个人评价
- 使用中文回复

## 转录内容
{transcript}
"#;

第六章：性能基准与资源消耗

6.1 硬件需求

6.2 推理速度基准

在不同硬件上，Parakeet-TDT-0.6B 的转录速度：

6.3 内存占用

Meetily 运行时内存分布（典型场景）：

Tauri Shell + WebView:    ~60 MB
Next.js Frontend:         ~80 MB
Rust Backend:             ~40 MB
Whisper small 模型:       ~500 MB
Parakeet 0.6B 模型:       ~300 MB
Ollama (llama3.1:8b):     ~6 GB
音频缓冲区:               ~20 MB
─────────────────────────
总计（Parakeet + Ollama）: ~6.5 GB
总计（Whisper + Ollama）:  ~6.8 GB

第七章：与竞品的全面对比

7.1 功能对比矩阵

7.2 成本分析

以一个 20 人团队、每月 100 小时会议为例：

Otter.ai Business 方案:
- 月费: $30/人 × 20 = $600/月
- 年费: $7,200/年
- 隐性成本: DPA 合规审查、数据泄露保险

Meetily 部署方案:
- 软件费用: $0（开源免费）
- 硬件投入: 一台 $500 的 Mac Mini 作为 Ollama 服务器
- 维护成本: 每月 2-4 小时 IT 运维（首次部署后趋近于零）
- 年费: ~$500（一次性硬件）+ 人力成本

节省: $6,700+/年，且零隐私风险

第八章：部署实战

8.1 macOS 一键安装

# 方式 1：下载 DMG（推荐）
# 从 https://github.com/Zackriya-Solutions/meeting-minutes/releases 下载
# 双击 .dmg，拖入 Applications

# 方式 2：Homebrew
brew install --cask meetily

# 安装 Ollama（用于 AI 摘要）
curl -fsSL https://ollama.ai/install.sh | sh
ollama pull llama3.1:8b

8.2 Windows 安装

# 从 Releases 下载 x64-setup.exe 并运行
# 或使用 winget
winget install Meetily

# 安装 Ollama for Windows
# 从 https://ollama.ai/download 下载安装包
ollama pull llama3.1:8b

8.3 从源码构建（开发者）

# 克隆仓库
git clone https://github.com/Zackriya-Solutions/meetily.git
cd meetily

# 前端依赖
cd frontend
pnpm install

# 构建（自动检测 GPU 并启用加速）
# macOS
./build-gpu.sh

# Linux（需要 CUDA Toolkit）
CUDA_PATH=/usr/local/cuda ./build-gpu.sh

# Windows（需要 Visual Studio Build Tools）
./build-gpu.bat

# 开发模式
cd frontend
pnpm run tauri dev

8.4 企业级部署方案

对于需要团队共享的场景，推荐以下架构：

┌─────────────────────────────────────────────┐
│              企业内网部署方案                 │
│                                             │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
│  │ Meetily │  │ Meetily │  │ Meetily │    │
│  │ (员工A) │  │ (员工B) │  │ (员工C) │    │
│  └────┬────┘  └────┬────┘  └────┬────┘    │
│       │            │            │          │
│       └────────────┼────────────┘          │
│                    │                       │
│            ┌───────┴───────┐              │
│            │  Ollama 服务  │              │
│            │  (GPU 服务器) │              │
│            │  Llama 3.1 70B│              │
│            └───────────────┘              │
│                    │                       │
│            ┌───────┴───────┐              │
│            │  本地存储服务  │              │
│            │  (NAS/S3)     │              │
│            │  转录+摘要    │              │
│            └───────────────┘              │
└─────────────────────────────────────────────┘

每个员工本地运行 Meetily 客户端进行音频采集和实时转录，但将 LLM 摘要请求发送到内网的 Ollama 服务器。这样既保证了音频数据不出设备，又能让团队共享 GPU 资源。

第九章：开发者指南——如何扩展 Meetily

9.1 添加自定义 ASR 模型

Meetily 的 ASR 引擎采用了 trait 抽象，添加自定义模型非常简单：

// 实现自定义 ASR 引擎
pub struct CustomAsrEngine {
    model_path: PathBuf,
}

impl AsrEngine for CustomAsrEngine {
    fn transcribe(&self, audio: &[f32]) -> Result<TranscriptSegment> {
        // 1. 加载你的模型
        let model = load_custom_model(&self.model_path)?;

        // 2. 预处理音频
        let features = extract_features(audio, 16000)?;

        // 3. 推理
        let output = model.infer(&features)?;

        // 4. 后处理
        let text = decode_output(output);

        Ok(TranscriptSegment {
            text,
            start_time: 0.0,
            end_time: audio.len() as f32 / 16000.0,
            confidence: 0.9,
        })
    }

    fn is_realtime(&self) -> bool {
        true
    }

    fn model_name(&self) -> &str {
        "custom-model-v1"
    }
}

9.2 自定义摘要模板

// 添加自定义摘要模板
pub fn register_custom_template(name: &str, template: &str) {
    let mut templates = SUMMARY_TEMPLATES.write().unwrap();
    templates.insert(name.to_string(), template.to_string());
}

// 使用示例
register_custom_template("技术评审", r#"
## 技术评审纪要

### 评审主题
{topic}

### 技术方案分析
根据会议讨论，方案的技术可行性评估如下：
- 优势：{advantages}
- 风险：{risks}
- 改进建议：{suggestions}

### 评审结论
{conclusion}

### 后续行动
{action_items}
"#);

9.3 集成到现有工作流

Meetily 提供了命令行接口，方便集成到 CI/CD 或自动化工作流：

# 命令行转录
meetily transcribe --input meeting.mp3 --output transcript.txt --model parakeet

# 命令行摘要
meetily summarize --input transcript.txt --provider ollama --model llama3.1:8b \
  --template action-items --output summary.md

# 批量处理
for file in recordings/*.mp3; do
  meetily transcribe -i "$file" -o "transcripts/$(basename $file .mp3).txt"
  meetily summarize -i "transcripts/$(basename $file .mp3).txt" \
    -o "summaries/$(basename $file .mp3).md"
done

第十章：安全性深度分析

10.1 数据流安全审计

Meetily 的数据流路径可以被完整审计：

音频采集（本地设备）
    ↓ CPAL 库，音频数据仅在进程内存中
实时转录（本地推理）
    ↓ Whisper.cpp / Parakeet ONNX，无网络请求
文本输出（本地存储）
    ↓ SQLite 数据库，存储在用户目录下
AI 摘要（可选本地/远程）
    ↓ Ollama: 完全本地
    ↓ Claude/Groq: 仅发送转录文本，不发送原始音频

10.2 与云端工具的安全对比

Meetily 威胁模型：

攻击面 1：音频采集 → 仅本进程可访问，无网络暴露
攻击面 2：模型推理 → 纯本地计算，无数据外传
攻击面 3：数据存储 → SQLite 加密，用户掌控密钥
攻击面 4：LLM 摘要 → Ollama 模式零网络，API 模式仅文本

Otter.ai 威胁模型：

攻击面 1：音频传输 → 公网传输，TLS 加密但可被中间人
攻击面 2：云端存储 → 第三方服务器，供应商可访问
攻击面 3：模型处理 → 云端 GPU，数据可能被缓存/日志
攻击面 4：API 访问 → 多个微服务，攻击面大

10.3 合规性优势

对于受监管行业，Meetily 提供了天然的合规优势：

• GDPR：数据不出设备，无需签署 DPA（数据处理协议）
• HIPAA：医疗会议的 PHI（受保护健康信息）不离开本地
• SOX：财务会议的敏感信息完全本地化
• ITAR：国防相关讨论不涉及数据出境

第十一章：生态与社区

11.1 Meetily PRO

Meetily 采用开源核心 + 商业增强的模式：

• Community Edition：完全免费，MIT 协议，包含所有核心功能
• PRO 版本：增强精度、自定义摘要模板、PDF/DOCX 导出、自动会议检测、团队部署、优先支持

11.2 社区活跃度

截至 2026 年 7 月：

• GitHub Stars: 16,400+
• Forks: 1,400+
• Downloads: 279,000+
• Open Issues: 176
• Pull Requests: 77
• Discord 社区: 活跃讨论

11.3 Roadmap

根据官方信息，Meetily 的未来规划包括：

• 说话人分离功能完善（PRO 版本已部分支持）
• 会议内容聊天查询（Chat with Meetings）
• 日历集成（自动检测和加入会议）
• 更多语言支持
• 移动端应用（iOS/Android）
• MCP 协议集成（与 AI Agent 生态打通）

总结与展望

Meetily 代表了一种正在崛起的技术范式：隐私优先的本地 AI 应用。

在过去两年，AI 应用的主流叙事是"云端大模型 + API 调用"。但 Meetily 证明了另一种可能——通过精心的架构设计和模型选择，在消费级硬件上也能实现媲美云端的 AI 体验，同时彻底消除数据隐私风险。

从技术角度看，Meetily 的几个设计决策值得所有开发者学习：

1. Rust + Tauri 的技术选型：在性能敏感场景下，Rust 的零成本抽象和内存安全是 Python/Node.js 无法比拟的
2. 双 ASR 引擎架构：Whisper 和 Parakeet 的互补设计，让用户在精度和速度之间有选择权
3. Ollama 的 LLM 集成：利用 Ollama 的 OpenAI 兼容 API，一行代码切换本地/云端 LLM
4. 智能音频混音：同时采集麦克风和系统音频，配合 ducking 算法，解决了会议转录的核心痛点

随着本地 AI 推理技术的持续进步（Apple M4、NVIDIA Blackwell、量化技术演进），我们可以预见：未来 2-3 年内，大多数 AI 应用都将支持"本地优先"模式。Meetily 不仅是一个会议助手，更是这个趋势的先行者和标杆。

如果你的团队正在为会议数据的隐私合规而头疼，或者你只是想拥有一个不依赖任何云服务的 AI 会议助手，Meetily 是目前最成熟、最完整的选择。

项目地址：https://github.com/Zackriya-Solutions/meetily
官网：https://meetily.ai
License：MIT

本文基于 Meetily Community Edition v0.4.0 及公开技术文档撰写。技术数据来自项目 README 和社区基准测试。