先聊一个现象:现在市面上的 AI 编程助手基本都奔着云端去做,代码传上去、模型算完再传回来,简单是简单,可一旦碰到企业项目、私有仓库或离线环境,这条路就很难走。另一种思路是把 AI 编码代理能力全部塞进本地,让模型、代码索引、提示词管理都在自己电脑上跑,这就是本地优先(local-first)的玩法。PI-Desktop 做的就是这件事——一个基于 Electron + Rust 双引擎架构的 AI 编码代理桌面应用。它把 UI 交互和非核心逻辑丢给 Electron,把代码分析、语义检索、上下文组装这些吃性能的活交给 Rust,两边各干各擅长的,最终给你一个响应快、可离线、隐私不出去的编码助手。
这篇文章会从选型思路讲到具体实现,再落到打包分发,把我在实际搭建和调优过程中踩过的坑、验证过的方案一条条拆开讲。适合正在做 AI 编码工具、桌面端 AI 应用,或者对 Electron + Rust 混合架构感兴趣的开发者参考;哪怕你只是想给现有 Electron 应用加一个 Rust 本地引擎,也能从这里拿到可直接抄作业的链路设计。
1. 为什么是"本地优先":AI 编码代理的另一种活法
1.1 云端 AI 编码助手的隐性成本
大家习惯了 Cursor、Copilot 这类工具,觉得 AI 编码助手就应该是"选中代码、发到云端、等结果"。这种模式在个人开发者的场景下确实够用,但放到真实项目里会暴露几个问题。第一是代码隐私,公司代码库是企业最值钱的资产之一,你让开发者把核心业务代码传到第三方服务器,法务和架构师第一个不同意。第二是延迟,云端推理意味着每次对话都要经过网络往返,哪怕只有几百毫秒,在快速浏览和修改代码的流式体验里也非常难受。第三是成本,按 token 计费的云端模型,面对动辄几千文件的代码仓库,把整个上下文传上去,一次会话就可能烧掉不少钱。
本地优先的方案是把这三笔账直接省掉。模型跑在本地(哪怕是个量化小模型),索引构建在本地,代码分析和语义检索也在本地,所有数据不出设备。可能有人会质疑本地模型的能力不如云端大模型,这话没错,但 AI 编码代理的体验不能只看模型智商,还要看上下文工程。本地可以毫秒级读取整个仓库的符号表、调用关系、最近改动文件,这些信息对生成准确代码的帮助,有时候比单纯换一个大模型更明显。
1.2 本地优先的设计原则和取舍
本地优先不是"完全离线"的意思,而是一种架构上的倾向性:核心链路全部在本地闭环,只有确实需要更强模型时,才允许用户主动选择接入远程模型。这样设计有几个好处。
- 离线可用。断网环境下依然能完成补全、问答、重构建议等核心功能。
- 隐私可控。日志、索引、对话记录全部落在本机,用户删除即彻底销毁。
- 响应更快。本地推理加上本地索引,平均延迟能做到百毫秒级,比云端方案稳定得多。
- 成本可预期。没有按 token 计费的压力,长时间开着也不用担心账单。
当然,取舍也很明显。本地模型对硬件有要求,尤其是内存和显存;同时本地索引的构建和维护需要消耗 CPU 资源。所以 PI-Desktop 在设计时做了一个关键决定:把资源消耗大的模块用 Rust 编写,而不是让 Electron 主进程承担全部压力。这样即便索引构建时 CPU 飙升,Electron 渲染进程的 UI 也能保持流畅,不会出现界面卡死等待的窘境。
2. 双引擎架构的选型逻辑:Electron 与 Rust 怎么分家
2.1 为什么不用纯 Electron
最早我也想图省事,整个项目用 Electron + Node.js 一把梭。前端用 React 写聊天面板,后端用 Node 做文件读取、代码检索、调模型。前期开发确实快,但做到代码分析部分就卡住了。给一个大型仓库建符号索引,用 Node 逐文件扫描加正则匹配,内存和 CPU 占用直接起飞;而且 JavaScript 的字符串处理和并发模型在这种计算密集场景下极其别扭,异步回调一多,光排查内存泄漏就耗掉我整整两天。
问题的本质在于 Electron 的 UI 能力和计算能力不匹配。Electron 基于 Chromium,UI 渲染和前端生态是它的强项,但它的 JavaScript 运行时在处理大型结构化数据、底层文件系统操作和高并发 IO 时,性能和可控性都不够理想。尤其是做语义级代码分析时,需要精确解析几百种语言语法、构建 AST、计算代码相似度,这些任务更适合用编译型语言实现。
2.2 为什么不用纯 Tauri
那有人会问,Tauri 不是正好用 Rust 做后端、WebView 做 UI 吗?确实,Tauri 在架构上比"Electron + 独立 Rust 进程"更紧凑,打包体积也小得多。但实际评估后我放弃了纯 Tauri 方案,原因有三个。
一是生态成熟度。Electron 的桌面端生态太完整了,窗口管理、托盘、自动更新、崩溃上报、子进程管理等都有经过大规模验证的现成方案。Tauri 虽然发展很快,但很多边界场景仍然要靠自己造轮子,比如 Linux 下不同发行版的 WebView 兼容问题,调试起来非常痛苦。
二是插件与编辑器集成。PI-Desktop 需要内嵌一个代码查看和编辑组件,Monaco Editor(VS Code 的编辑器内核)在 Electron 里跑得非常顺,插件体系、主题、diff 视图都是现成的;但 Monaco 在 Tauri 的 WebView 里会有不少兼容性和性能问题。与其在 Tauri 里修补 WebView 的兼容性,不如直接选一个已经验证过的宿主环境。
三是解耦灵活性。PI-Desktop 的架构目标是"UI 可替换、引擎可独立升级"。用 Electron 做宿主、Rust 做独立本地引擎,两者之间通过本地 IPC 通信,这意味着引擎部分完全可以脱离 UI 单独测试、单独发布,甚至未来可以切换到其他 UI 框架。而 Tauri 把 Rust 和 UI 生命周期绑得比较紧,这种松耦合的思路实现起来会多一点别扭。
2.3 双引擎的分工边界:什么放 Electron,什么放 Rust
双引擎架构最核心的问题不是"用哪个框架",而是"边界划在哪里"。我总结了一套比较实用的分工原则:一切跟"用户直接看到"的交互放 Electron,一切"用户看不到但很吃算力"的调用放 Rust。
具体到 PI-Desktop 里,两边大概是这样分活的。
| 模块 | 归属引擎 | 原因 |
|---|---|---|
| 聊天面板、代码预览、设置页 | Electron | UI 生态成熟,开发效率高 |
| 窗口管理、托盘、自动更新 | Electron | 桌面端生态完善,方案稳定 |
| 本地模型调用(LLM 推理进程管理) | Rust | 需要精确控制子进程、显存与流式输出 |
| 代码仓库索引构建 | Rust | 计算密集,内存可控性要求高 |
| 符号表、AST 解析、代码语义检索 | Rust | 需要高性能和低延迟 |
| 提示词模板与上下文组装 | Rust | 涉及大量结构化文本处理,Rust 更稳 |
| 配置存储、日志落盘 | Electron | 简单键值存储,无需 Rust 介入 |
| 用户行为统计分析(本地) | Electron | 低频任务,避免跨进程调用成本 |
这样划分之后,Electron 主进程保持轻量,渲染进程只管展示和输入,Rust 引擎干重活。两边通过一条自定义的本地 IPC 通道通信,互相不阻塞。实际跑起来的效果是:即使后台正在全量索引一个十万文件的大仓库,聊天窗口依然可以顺滑地滚动和输入,这就是双引擎分工最大的收益。
3. 核心链路拆解:界面、代理、工具调用
3.1 Electron 主进程与渲染进程的职责划分
在 PI-Desktop 里,Electron 端不是简单的"一个窗口 + 一个主进程",我把它拆成了三层:主进程、渲染进程、预加载脚本。主进程负责窗口生命周期、程序菜单、全局快捷键,以及最重要的——管理 Rust 引擎子进程的启停和通信。渲染进程只做两件事:渲染聊天界面和代码展示,收集用户的输入事件。预加载脚本是安全边界,通过 contextBridge 暴露有限的 API 给渲染进程,避免渲染进程直接接触 Node 能力。
举个实际例子:用户在对话框输入"帮我找到所有没有处理错误的文件读取代码"。这条消息在渲染进程打包成 JSON,通过 window.api.sendMessage 发送到主进程,主进程转发给 Rust 引擎;Rust 引擎解析语义、检索索引、组装上下文、调用本地模型,最后把流式结果一段一段送回主进程,主进程再推给渲染进程逐字展示。整个链路里,渲染进程始终不知道 Rust 的存在,它只面对一个异步消息接口。
3.2 Rust 引擎:提示词、上下文管理与代码分析
Rust 引擎是整个 AI 编码代理的"大脑"。它的职责分三块:代码理解、上下文组装、模型代理。
代码理解部分我用 tree-sitter 做 AST 解析。tree-sitter 增量解析速度极快,适合在用户编辑文件时实时更新符号表,而不需要全量重扫。比如用户改了某个函数名,tree-sitter 可以在毫秒级识别出受影响的符号,并同步到本地索引。这一步用 Node 做会很吃力,但 Rust 做起来很顺手,因为 tree-sitter 本身就是 C 实现,Rust 通过 FFI 调用非常自然。
上下文组装是决定 AI 输出质量的关键。我的做法不是简单地把整个仓库塞给模型,而是分层组装:先根据用户问题做语义检索,找到最相关的几个文件;再提取这些文件的"骨架信息",包括函数列表、关键变量、依赖关系;最后把当前的编辑位置、光标上下文和最近的 git diff 一并打包成结构化的提示词。这个提示词组装过程用 Rust 的 serde_json 拼 JSON,再用格式化模板渲染成 LLM 需要的格式,效率非常高。
模型代理部分,Rust 负责管理本地模型子进程的生命周期。因为本地推理(比如 llama.cpp 或 Ollama 拉起的小模型)会创建独立的推理进程,Rust 可以精确控制 stdin/stdout 的流式读取,还能监控子进程的退出状态和资源占用,避免推理进程崩溃后无人回收。这里用 tokio 的 async 运行时管理并发任务,每个请求都是一个独立的 async task,互不阻塞。
3.3 本地索引与语义检索的方法
本地优先要解决的第一个问题就是"在大仓库里快速找到相关代码"。PI-Desktop 采用了两级索引方案。
第一级是符号索引。基于 tree-sitter 解析出的 AST,把所有函数、类、结构体、枚举、变量定义和引用位置记录下来,存在 SQLite 里。这一层的查询非常快,一个百万行的仓库,按名字查符号基本在 10ms 以内。第二级是语义索引。对代码块和注释做向量化,用本地 embedding 模型生成向量,存进向量索引。代码语义检索就靠这个向量库实现。
向量检索的选型上,我最终用了纯 Rust 方案而非引入外部数据库。原因简单:一是安装部署简单,不用让用户额外装一个 Elasticsearch 或 Milvus;二是 Rust 的向量计算库(比如 burn 的 embedding 支持和定制的 HNSW 实现)已经足够支撑百万级向量的近似检索;三是全部内嵌,方便后续做多平台分发。个人仓库级别的体量,毫秒级召回完全够用,没必要背上一个重型数据库的运维负担。
3.4 编辑器集成与流式输出
PI-Desktop 把 Monaco Editor 集成进来,主要用它做代码展示和 diff 预览。Monaco 有现成的主题系统,也支持最小化的只读模式,用来展示 AI 生成的代码片段和高亮差异非常合适。为了让 AI 输出流式展示,我不等模型生成完整内容再渲染,而是把 token 逐块推送到前端。Monaco 有一个 deltaDecorations API,可以根据增量更新精确标注需要改变的行,实测下来即便每秒渲染几十个 token,页面也不会有明显卡顿。
流式输出的链路时序是这样的:Rust 引擎从模型拿到增量 token,通过 IPC 推给 Electron 主进程,主进程用 webContents.send 推给渲染进程,渲染进程维护一个 pending markdown buffer,每收到一段就把 buffer 丢给 marked 解析再 Diff 更新 Monaco 模型。为了避免高频更新导致 UI 闪动,我在前端做了 30ms 的节流:合并短时间内到达的 token,批量渲染一次。
4. 实操:从零搭建 PI-Desktop 的核心骨架
4.1 项目初始化与目录结构
先说整体目录。PI-Desktop 用 npm workspace 管理 Electron 前端和 Rust 引擎两个部分,二者独立构建,最终打包时合并到一起。
pi-desktop/
├── app/ # Electron 前端
│ ├── main/ # 主进程代码
│ ├── preload/ # 预加载脚本
│ ├── renderer/ # 渲染进程(React + Monaco)
│ ├── package.json
│ └── electron-builder.yml
├── engine/ # Rust 引擎
│ ├── src/
│ │ ├── main.rs # 入口,初始化 tokio runtime
│ │ ├── ipc/ # 本地 IPC 协议
│ │ ├── indexer/ # 代码索引模块
│ │ ├── analyzer/ # AST 分析模块
│ │ ├── context/ # 上下文组装模块
│ │ └── model/ # 本地模型调度模块
│ ├── Cargo.toml
│ └── tests/
└── scripts/
├── build-engine.sh
└── dev.sh
这样一个目录的好处是职责清晰,前端和后端可以独立开发、独立测试。我平时开发时先用 cargo run 单独调试 Rust 引擎的索引和检索能力,确认逻辑无误后再联调 Electron 的 IPC。
4.2 Electron 端关键实现
Electron 端最需要小心的是预加载脚本和 IPC 通道的设计。预加载脚本的职责是安全地暴露接口,不要直接把 ipcRenderer 透传给渲染进程。我暴露的接口长这样:
// app/preload/index.js
const { contextBridge, ipcRenderer } = require('electron');
contextBridge.exposeInMainWorld('piDesktop', {
sendMessage: (payload) => ipcRenderer.invoke('engine:message', payload),
onToken: (callback) => {
const listener = (_event, token) => callback(token);
ipcRenderer.on('engine:token', listener);
return () => ipcRenderer.removeListener('engine:token', listener);
},
startAgent: (sessionId) => ipcRenderer.invoke('engine:start', sessionId),
stopAgent: () => ipcRenderer.invoke('engine:stop'),
});
主进程这边,关键是管理 Rust 子进程。我用 spawn 拉起编译好的引擎二进制,并通过 stdio 通信。但需要注意,用 spawn + stdin/stdout 处理长生命周期的子进程时,必须处理背压问题——如果 Rust 引擎产生的输出太快,而 Electron 主进程消费不及时,会导致子进程阻塞。我的方案是让 Rust 引擎把日志级别调低,只输出业务 JSON,且每条消息控制在一定大小以内;遇到超大 payload(比如索引进度快照),让 Rust 端主动分片发送。
// app/main/engine.js
const { spawn } = require('child_process');
function startEngine() {
const enginePath = path.join(process.resourcesPath, 'engine', 'pi-engine');
const proc = spawn(enginePath, [], {
cwd: app.getAppPath(),
stdio: ['pipe', 'pipe', 'pipe'],
});
let buffer = '';
proc.stdout.on('data', (chunk) => {
buffer += chunk.toString();
const lines = buffer.split('\n');
buffer = lines.pop();
for (const line of lines) {
if (!line.trim()) continue;
handleEngineMessage(line);
}
});
proc.on('exit', (code) => {
console.error(`engine exited with code ${code}`);
});
}
4.3 Rust 引擎与 async 并发处理
Rust 引擎的入口代码里,我使用 tokio 作为异步运行时。异步在这里非常关键,因为引擎要同时处理多个任务:接收 Electron 发来的消息、监控模型子进程输出、定期更新索引进度。如果用同步代码写,任何一个耗时操作都会阻塞整个 IPC 消息循环。
// engine/src/main.rs
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let (tx, mut rx) = tokio::sync::mpsc::channel::<EngineCommand>(1024);
tokio::spawn(async move {
while let Some(cmd) = rx.recv().await {
match cmd {
EngineCommand::Index { path, respond } => {
let result = index_repository(&path).await;
let _ = respond.send(result);
}
EngineCommand::Analyze { code, respond } => {
let ast = analyze_code(&code).await;
let _ = respond.send(ast);
}
EngineCommand::Generate { prompt, respond } => {
let stream = generate_with_model(&prompt).await;
// handle streaming...
}
}
}
});
// stdio line-based protocol with Electron main process
let stdin = tokio::io::stdin();
let mut lines = BufReader::new(stdin).lines();
while let Some(line) = lines.next_line().await? {
let cmd: EngineCommand = serde_json::from_str(&line)?;
tx.send(cmd).await?;
}
Ok(())
}
这里有个很容易踩的坑:Rust 的 trait 对象生命周期和 async 的组合。比如你想在 async 任务里缓存一个 trait object(比如某个模型加载器),但编译器会一直报
for<'lifetime>
相关的错误,本质上是生命周期约束和借用检查器在较劲。我的建议是不要试图在 async 块里直接持有复杂的借用状态,而是把状态拆成两种:一种是跨任务共享的,用 Arc<Mutex<...>>;另一种是任务内短生命周期持有的,直接 move 进去。这样虽然多写几行 Arc,但能绕开一堆生命周期地狱。
4.4 IPC 通信协议设计:JSON-RPC 还是自定义协议
Electron 主进程和 Rust 引擎之间的通信协议,我对比过两种方案:谷歌的 gRPC 和自定义的换行分隔 JSON 协议。gRPC 的优势是强类型、跨语言、支持流式,缺点是需要引入 protobuf 编译链,对打包体积和构建复杂度都是一种负担;自定义 JSON 协议虽然看起来原始,但胜在实现简单、调试直观,而且对 Electron 和 Rust 两边来说就是"读一行 JSON + 解析",没有任何额外依赖。
PI-Desktop 的协议格式是换行分隔的 JSON,每条消息一个 JSON 对象,以
\n
结尾。消息分两类:请求(request)和事件(event)。请求有 id 字段,响应通过 id 关联;事件没有 id,属于单向通知,比如索引进度、token 流等。这样既保持了简单性,也支持了流式输出。
{"id": 1, "method": "index", "params": {"path": "/home/user/project"}}
{"id": 2, "method": "search", "params": {"query": "find file read errors"}}
{"event": "indexing_progress", "data": {"current": 120, "total": 5000}}
{"event": "token", "data": {"session": "abc", "content": "你可能需要处理"}}
我特别想提醒一点:在高频流式输出时,不要让 Electron 每收到一个事件就立刻转发给渲染进程,否则 IPC 通道会被短消息淹没。建议在 Rust 端做小批量缓冲——比如积累 50ms 内的 token 再发一次,平均一次发送包含几十个 token,这样可以显著降低 IPC 频率,前端渲染体验反而更稳定。
5. 打包分发:Linux 实测与 fpm 那些坑
5.1 electron-builder 配置与 Rust 引擎的集成方式
打包是我在这个项目里花时间最多、也最痛苦的环节。electron-builder 支持把额外文件打进 resources 目录,我的做法是把编译好的 Rust 引擎二进制放到 engine/ 子目录,然后在运行时用 process.resourcesPath 拼接实际路径。
# app/electron-builder.yml
appId: dev.pidesktop.app
productName: PI-Desktop
directories:
output: release/
files:
- main/**
- preload/**
- renderer/dist/**
extraResources:
- from: ../engine/target/release/pi-engine
to: engine/
filter:
- "**/*"
linux:
target:
- AppImage
- deb
category: Development
maintainer: dev@pidesktop.dev
需要注意一个细节:Rust 编译出的二进制默认是动态链接 glibc 的,如果打出来的包在干净的发行版上运行会报
GLIBCXX_3.4.29 not found
之类的问题。解决方法是编译时加
-C target-feature=-crt-static
或者用 musl 目标做静态编译。我为了让包尽量通用,直接用
x86_64-unknown-linux-musl
target 编译,二进制体积会大一点,但换来的是不依赖系统的 glibc 版本,部署到不同发行版基本不会出幺蛾子。
5.2 Linux 打包实测:fpm 报错与修复
用 electron-builder 打 deb 包时,底层依赖 fpm(一个打包工具)。我在 Ubuntu 上第一次执行 build 就遇到了 fpm 报错。报错信息大概是:
fpm: command not found
原来 electron-builder 会通过 gem 安装 fpm,但系统里根本没有装 Ruby 环境。Google 一圈发现,electron-builder 的 fpm 依赖比较老旧,新版本 Ruby 经常出现兼容问题。最终我的解决办法是手动安装旧版 fpm:
gem install fpm -v 1.14.2
装完 1.14.2 之后,electron-builder 直接调系统 fpm 就不再报错了。另外一个坑是打 deb 时需要指定 maintainer 字段,否则 fpm 会报
Missing required maintainer field
,这个字段在配置里补齐即可。
还有一次遇到 fpm 报
ruby 3.0.0 is not supported
的错误,这个更麻烦。我当时的处理是安装
ruby2.7
并切换默认 Ruby 版本,然后再装 fpm。如果你用的不是 Ubuntu,而是 CentOS 或 Arch,步骤会有些差异,但核心思路一致——给 electron-builder 准备一个它能接受的 fpm 环境。
# 以 Ubuntu 为例
sudo apt install ruby2.7 ruby2.7-dev
sudo update-alternatives --set ruby /usr/bin/ruby2.7
sudo gem install fpm -v 1.14.2
实际上,electron-builder 内置了一个 fpm 下载逻辑,你也可以通过环境变量
USE_SYSTEM_FPM=true
强制它使用系统安装的 fpm,这一步对很多 CI 环境非常有用。
5.3 体积优化与启动速度调优
Electron 应用最大的槽点就是包体大。经过一番优化,我最终把安装包压到了 90MB 左右。具体做了这几件事:
- 压缩 Monaco Editor 的语言包,只保留用户常用的 10 种语言(JavaScript/TypeScript/Python/Go/Rust/Java/C++/C#/Shell/JSON)。
- 移除 Electron 自带的 Chromium 中不需要的组件,比如 PDF viewer 和 Widevine DRM。
- Rust 引擎用 musl 静态编译并且开了 lto = "thin" 优化,减小二进制体积。
- 前端资源用 gzip 预压缩,electron-builder 打包时可以直接带上 .gz 文件。
启动速度方面,我做了一个"Rust 引擎预启动"方案。Electron app 的 ready 事件触发后,马上 spawn Rust 引擎进程,同时并行初始化窗口;等引擎启动完成,IPC 已经就绪,用户也不会感知到额外等待。这里需要注意 Rust 引擎的冷启动时间,如果索引库很大,启动时加载索引可能要几百毫秒,我加了一个轻量版索引缓存——把最近常用的仓库索引头信息序列化到本地文件,下次启动时先按缓存加载,后台再异步校验更新。实测下来启动到可交互状态的时间从 1.8s 降到了 0.9s 左右。
6. 常见问题速查与经验总结
6.1 高频问题与排查思路
在实际开发和用户反馈中,我整理了几个高频问题,附上排查方法,方便大家少走弯路。
| 现象 | 可能原因 | 解决方案 |
|---|---|---|
| 打包后 Rust 二进制找不到 | 路径拼接错误或未拷贝到 resources |
检查 electron-builder 的 extraResources 配置,用
process.resourcesPath
拼接路径
|
| Linux 运行提示缺少 .so 依赖 | glibc 版本不兼容 | 改用 musl 目标静态编译 Rust 引擎 |
| fpm 打包报错 | fpm 版本与 Ruby 不兼容 |
安装 fpm 1.14.2,设置
USE_SYSTEM_FPM=true
|
| IPC 消息延迟高 | 高频小消息淹没通道 | 在 Rust 端做 50ms 批量缓冲,减少发送次数 |
| 索引构建时 UI 卡顿 | Rust 引擎 CPU 占用过高 | 用 tokio 的 spawn_blocking 处理 CPU 密集任务,控制并行度 |
| 本地模型推理输出中断 | 子进程未监控/回收 | 在 Rust 端捕获子进程 exit 事件,实现自动重启策略 |
| 内嵌 Monaco 时中文输入法卡顿 | 渲染进程负载过高 |
对编辑器渲染区域做虚拟滚动,并开启
disableHtmlSyntaxValidation
|
6.2 一些优化心得:索引、IPC 与提示词管理的经验
先聊索引。不要一上来就全量索引,应该先做"按需索引"。PI-Desktop 的策略是:用户第一次打开项目时,先快速扫描目录结构,建立文件清单和粗略的符号表,这个过程很快,秒级完成;然后异步地做深度 AST 分析,一次一个文件,优先级从打开频率高的文件开始。这样用户还没感受到等待,最常用的代码就已经能被检索到了。
再说 IPC。双引擎架构的成败全看 IPC 设计。如果你传输的是大块代码文本,建议先做压缩再传输。Rust 端用 flate2 压缩,Electron 端用 Node 的 zlib 解压,实测同一条消息的传输时间能降低 60% 以上。当然,这个优化只针对在 500KB 以上的大消息;小消息压缩反而有额外开销,需要根据实际负载做取舍。
最后是提示词管理。AI 编码代理的提示词不是写一次就完了,它是持续演化的。我把提示词模板拆成多个模块,像"当前文件上下文"、"符号定义"、"最近的 diff"、"用户指令",每个模块都是独立的模板片段,最后按配置动态拼接。这样用户可以在设置页勾选"是否包含当前文件的依赖关系"等选项,Rust 端再根据配置组装最终提示词。这套机制让 PI-Desktop 在不同项目类型下都能有不错的适配性,不用为每一个项目单独调一套提示词。
6.3 还有几点想提醒你的
如果你准备从零搭一个类似的 Electron + Rust 架构应用,有几点建议:
- 不要把 Electron 主进程当成垃圾桶,什么逻辑都往里塞。主进程一堵,整个应用的所有窗口都跟着卡。尽量让主进程只做转发和窗口管理。
- Rust 引擎尽量做成无状态的服务。每个请求带上完整的上下文标识,不要让引擎内部维护会话状态,这样即使引擎崩溃重启,Electron 端也能轻松恢复。
- 日志系统要尽早建设。Electron 端和 Rust 端的日志分开落文件,每条日志带上时间戳、级别和来源模块。排查跨语言问题的时候,两份日志一对比,问题立刻现形。
- 自动化测试时,Rust 引擎可以单独跑,用 cargo test 测索引和上下文组装;Electron 端用 Playwright 跑 E2E,但 E2E 里不要真的去调模型,mock 掉 IPC 返回结果,速度会快得多。
我个人在这些地方的体会是:双引擎架构带来的额外复杂度,在项目早期会让人觉得"不如纯 Electron 或纯 Tauri 省事",但当应用慢慢变大、用户开始拿它处理真正的大型项目时,你会感谢当初把计算密集的部分隔离在 Rust 里。那种用户一边全量索引一边流畅提问的场景,就是对这个架构最好的回报。最后再分享一个小技巧:在 Rust 端压测索引性能时,用 release 模式 + LTO 编译,性能差距和 debug 模式能差十倍以上,别拿 debug 构建的数据吓自己。
206



被折叠的 条评论
为什么被折叠?



