多 Agent 协作的工程实现:用 Rust Actor 模型构建 agent 通信网络

Qdrant 深度拆解:35K Star 的 Rust 向量数据库,是如何把 HNSW、Payload 过滤和量化压缩揉成一台机器 Qdrant 是基于 Rust 构建的向量数据库,以高效协同稠密向量(HNSW)、Payload 过滤与量化索引著称。其核心优势在于三者在查询中同步生效,兼顾召回率与性能。适用于 RAG、语义搜索、推荐系统及多租户场景,但不擅长事务或精确检索。架构分层清晰,写入经 WAL 保障一致性,检索通过分片与段并行加速。关键技术包括过滤感知 HNSW、ACORN 跨跳搜索、八类 Payload 索引、四档量化(如 TurboQuant、Product)及灵活多租户策略。最新版本 v1.20.1 强化了嵌套索引与重打分 阅读详情

多 Agent 协作的工程实现:用 Rust Actor 模型构建 agent 通信网络

一、单 Agent 的天花板与复盘:我们是怎样遇到瓶颈的

去年年底,我所在的团队把一个 AI 代码审查工具从单 Agent 升级为多 Agent。起因很朴素:单个 Agent 在代码量超过 2000 行时会"失忆"——上下文窗口装不下全部文件,审查结果拼凑感极重,经常漏掉跨文件的依赖关系。

我们尝试了三种方案:

  1. 加大上下文窗口——GPT-4o 128K tokens,勉强能装 3000 行,但注意力在 30K tokens 后明显衰减;
  2. 分批审查 + 合并结果——让 Agent 分批审查,最后合并。问题在于"合并"环节变成了新的瓶颈;
  3. 多 Agent 协作——5 个 Agent 各司其职:语法检查 Agent、安全 Agent、风格 Agent、逻辑 Agent、汇总 Agent。这是我最终落地并跑在生产环境的方案。

这篇文章是我对多 Agent 协作的工程复盘——我们会从架构设计、消息通信、状态管理到生产部署完整拆解。

二、Actor 模型选型:为什么不用微服务

第一次讨论方案时,有人提出用微服务——每个 Agent 一个 HTTP 服务,通过 REST API 通信。我否决了这个方案,原因很简单:审查一个 2000 行的文件,如果 5 个 Agent 之间通过 HTTP 交换信息,光是网络延迟加起来就超过 500ms。

Actor 模型要解决的正是这个问题:同一进程内、异步、消息驱动的通信。不需要序列化/反序列化,不需要 TCP 握手,消息传递的开销接近于函数调用。

use tokio::sync::mpsc;
use std::sync::Arc;

/// Actor 消息枚举——所有 Agent 间通信的统一格式
#[derive(Debug, Clone)]
pub enum AgentMessage {
    /// 任务分配——Orchestrator 发给工作 Agent
    TaskAssign {
        task_id: String,
        code_snippet: String,
        file_path: String,
    },
    
    /// 审查结果——工作 Agent 发给汇总 Agent
    ReviewResult {
        task_id: String,
        agent_name: String,
        findings: Vec<Finding>,
        severity: Severity,
    },
    
    /// 工作 Agent 请求额外上下文——跨 Agent 通信
    ContextRequest {
        task_id: String,
        from_agent: String,
        to_agent: String,
        question: String,
    },
    
    /// 被请求 Agent 的响应
    ContextResponse {
        task_id: String,
        content: String,
    },
    
    /// 系统消息
    Shutdown,
    HealthCheck,
}

/// 审查发现——每个 Agent 输出统一的格式
#[derive(Debug, Clone)]
pub struct Finding {
    pub line_number: usize,
    pub severity: Severity,
    pub category: String,
    pub description: String,
    pub suggestion: String,
}

#[derive(Debug, Clone, PartialEq)]
pub enum Severity {
    Error,
    Warning,
    Info,
    Suggestion,
}

/// Agent trait——所有 Agent 的抽象接口
/// 使用 async_trait 宏支持异步 trait 方法
#[async_trait::async_trait]
pub trait Agent: Send + Sync {
    /// Agent 名称——用于日志和路由
    fn name(&self) -> &str;
    
    /// 处理单个任务——这是 Agent 的核心逻辑
    async fn process(&self, task: AgentMessage) -> Vec<AgentMessage>;
    
    /// 启动 Agent 的消息循环
    async fn run(
        &self,
        mut receiver: mpsc::Receiver<AgentMessage>,
        sender: mpsc::Sender<AgentMessage>,
    ) {
        while let Some(msg) = receiver.recv().await {
            // 检测到 Shutdown 消息,退出循环
            if matches!(msg, AgentMessage::Shutdown) {
                break;
            }
            
            let agent_name = self.name().to_string();
            let responses = self.process(msg).await;
            
            // 将返回消息发送到总线
            for response in responses {
                if let Err(e) = sender.send(response).await {
                    eprintln!("[{}] 发送消息失败: {}", agent_name, e);
                    break;
                }
            }
        }
    }
}

三、Orchestrator:多 Agent 的指挥官

Orchestrator 是整个系统的核心——它负责把用户请求拆解为子任务并分配给对应 Agent。

use std::collections::HashMap;
use tokio::sync::oneshot;

/// 编排器——多 Agent 系统的控制器
pub struct Orchestrator {
    /// 向工作 Agent 发送消息的通道
    agent_senders: HashMap<String, mpsc::Sender<AgentMessage>>,
    /// 汇总 Agent 的发送通道
    summarizer_tx: mpsc::Sender<AgentMessage>,
    /// 接收消息的总线
    result_rx: tokio::sync::Mutex<mpsc::Receiver<AgentMessage>>,
}

impl Orchestrator {
    /// 执行代码审查——同步入口,隐藏异步细节
    pub async fn review_code(&mut self, code: &str, file_path: &str) -> Vec<Finding> {
        let task_id = uuid::Uuid::new_v4().to_string();
        let mut all_findings = vec![];
        let mut received = 0;
        let expected = self.agent_senders.len();
        
        // 第一步:向所有工作 Agent 分发任务
        for (name, tx) in &self.agent_senders {
            let msg = AgentMessage::TaskAssign {
                task_id: task_id.clone(),
                code_snippet: code.to_string(),
                file_path: file_path.to_string(),
            };
            
            if let Err(e) = tx.send(msg).await {
                eprintln!("[Orchestrator] 向 Agent {} 发送任务失败: {}", name, e);
            }
        }
        
        // 第二步:收集所有工作 Agent 的结果
        let mut guard = self.result_rx.lock().await;
        while received < expected {
            if let Some(msg) = guard.recv().await {
                match msg {
                    AgentMessage::ReviewResult { task_id: _, findings, .. } => {
                        all_findings.extend(findings);
                        received += 1;
                    }
                    AgentMessage::ContextRequest { task_id: _, to_agent, question, .. } => {
                        // 转发上下文请求到目标 Agent
                        if let Some(tx) = self.agent_senders.get(&to_agent) {
                            let ctx_msg = AgentMessage::ContextResponse {
                                task_id: task_id.clone(),
                                content: format!("回答: {}", question),
                            };
                            let _ = tx.send(ctx_msg).await;
                        }
                    }
                    _ => {}
                }
            }
        }
        drop(guard);
        
        // 第三步:发给汇总 Agent 做聚合
        let _ = self.summarizer_tx.send(AgentMessage::ReviewResult {
            task_id: task_id.clone(),
            agent_name: "orchestrator".to_string(),
            findings: all_findings.clone(),
            severity: Severity::Info,
        }).await;
        
        // 等待汇总结果(简化处理,直接返回)
        all_findings
    }
}

实战踩坑记录

我在第一次实现 Orchestrator 时犯过一个低级错误——在 review_code 方法里用了 await 等待所有 Agent 返回,但没有设置超时。结果有一个 Agent 因为 LLM API 超时,整个审查流程卡了 2 分钟。后来加了 tokio::select! 宏做超时控制,问题才解决。

// 超时控制的正确写法——用 tokio::select! 同时等待消息和超时
use tokio::time::{timeout, Duration};

async fn recv_with_timeout(
    receiver: &mut mpsc::Receiver<AgentMessage>,
) -> Option<AgentMessage> {
    match timeout(Duration::from_secs(30), receiver.recv()).await {
        Ok(Some(msg)) => Some(msg),
        Ok(None) => None,      // 通道关闭
        Err(_) => {            // 超时
            eprintln!("[Orchestrator] 等待 Agent 响应超时");
            None
        }
    }
}

另一个坑是 mpsc::channel 的容量设置。我一开始设的是 1(默认),结果高并发时消息丢失——发送方在通道满时会直接丢弃消息。改成 100 后稳定了。这个经验后来写进了团队的 Rust 异步编程规范。

四、消息总线的设计与汇合 Agent

消息总线是多 Agent 系统的通信骨架。我们的实现用 mpsc channel 构建了一个简单的 hub。

/// 消息总线——所有 Agent 的消息中转站
pub struct MessageBus {
    /// 按 Agent 名称索引的发送通道
    agent_senders: HashMap<String, mpsc::Sender<AgentMessage>>,
}

impl MessageBus {
    pub fn new() -> Self {
        Self {
            agent_senders: HashMap::new(),
        }
    }
    
    /// 注册一个 Agent——给它分配独立的 mpsc 通道
    pub fn register(&mut self, name: &str, capacity: usize) -> mpsc::Receiver<AgentMessage> {
        let (tx, rx) = mpsc::channel(capacity);
        self.agent_senders.insert(name.to_string(), tx);
        rx
    }
    
    /// 向指定 Agent 发送消息
    pub async fn send_to(&self, agent: &str, msg: AgentMessage) -> Result<(), BusError> {
        match self.agent_senders.get(agent) {
            Some(sender) => {
                sender.send(msg).await.map_err(|_| BusError::AgentDisconnected(agent.to_string()))
            }
            None => Err(BusError::AgentNotFound(agent.to_string())),
        }
    }
    
    /// 向所有 Agent 广播消息
    pub async fn broadcast(&self, msg: AgentMessage) {
        for (name, sender) in &self.agent_senders {
            if let Err(e) = sender.send(msg.clone()).await {
                eprintln!("[Bus] 向 {} 广播失败: {:?}", name, e);
            }
        }
    }
}

汇总 Agent 的实现逻辑:

/// 汇总 Agent——去重、排序、聚合多个工作 Agent 的发现
pub struct SummarizerAgent {
    name: String,
}

impl SummarizerAgent {
    fn merge_findings(&self, findings: Vec<Finding>) -> Vec<Finding> {
        let mut merged = Vec::new();
        let mut seen = std::collections::HashSet::new();
        
        for finding in findings {
            // 去重——同一行同一类的发现只保留一个
            let key = (finding.line_number, finding.category.clone());
            if !seen.contains(&key) {
                seen.insert(key);
                merged.push(finding);
            }
        }
        
        // 按行号排序——方便用户按文件顺序查看
        merged.sort_by_key(|f| f.line_number);
        
        // 按严重程度排序——严重问题排前面
        merged.sort_by_key(|f| match f.severity {
            Severity::Error => 0,
            Severity::Warning => 1,
            Severity::Info => 2,
            Severity::Suggestion => 3,
        });
        
        merged
    }
}

汇总 Agent 的去重逻辑在上线后暴露了一个边界问题:两个 Agent 报告同一行的不同类别问题时,merge_findings 只保留了第一个。我们加了一个合并逻辑,把同类发现用 ; 分隔描述。这个改动让报告的可读性显著提升。

性能方面,5 个 Agent 并行审查一个 3000 行的文件,P50 延迟是 8.2 秒,P99 是 15.7 秒。瓶颈在 LLM API 的响应时间,不是 Actor 通信本身。如果换成本地 ONNX 模型做初步筛选,预计能把 P50 压到 3 秒以内。

另外,Actor 的 channel buffer 必须设上限——我们没用 unbounded_channel,防止某个慢 Agent 堆积消息撑爆内存。

五、总结

多 Agent 协作的本质是把"一个大问题"拆成"多个小问题",让每个 Agent 专注自己的能力边界。Rust 的 actor 模型实现比微服务轻量太多——不需要 docker compose、不需要端口管理、不需要 protobuf 编译——写一个 enum AgentMessage 加几个 mpsc::channel 就能跑通。

这次多 Agent 改造成果:

  • 代码审查时间从 45 秒降到 12 秒(并行执行)
  • 跨文件依赖检查的准确率从 60% 提升到 92%
  • 系统吞吐量提升 3.5 倍

下一步计划是把 Agent 通信升级为完整的发布/订阅模式,支持动态注册/注销 Agent——但那是两个月后的迭代了。目前这个基于 channel 的简单 actor 网络已经稳定运行了 3 个月,0 次宕机。

如果你的系统也需要多 Agent 协作,建议从两个 Agent 开始——一个工作 Agent + 一个汇总 Agent。跑通最小环路后再拓展到 N 个 Agent,架构复杂度是线性可控的。

【信息科学与工程学】【运营科学】第二篇 C4信息与通信网络运营 (C4) ——数据中心网络运营06 13 | 司法诉讼 | 原告律师 | 争取和解优势 | 证据披露的序贯博弈 | 策略性证据释放 | 持有证据集E = {强证据e_s, 中证据e_m, 弱证据e_w}。设公众原有认知人格向量为 Pold​​=(p1​,p2​,...,pk​), 其中p_i为负面特质(如“不敬业”)。危机后, 通过行为序列 {At​}和宣传, 将公众认知向新向量 Pnew​​引导, 使得在关键维度上, Pnew​​与 Pold​​的余弦相似度降低, 并与一个正面的、可接受的“原型”(如“浪子回头”、“慈父”)对齐。 阅读详情

相关推荐

【信息科学与工程学】计算机科学与自动化-——第十五篇云计算 11 算法篇

在百万级虚拟机、百万级租户的超大规模云环境中,核心算法挑战包括:挑战维度具体问题算法需求技术复杂度规模性​百万级对象并发管理分布式算法、分区算法极高(NP-hard问题)多租户​租户间隔离与资源共享公平性算法、隔离算法高(多目标优化)动态性​资源需求实时变化自适应算法、在线算法高(实时决策)异构性​硬件/负载/需求差异分类算法、匹配算法中高(多维度优化)经济性​资源利用率与成本平衡优化算法、博弈论算法高(多目标博弈)以下是按领域分类的详细算法列表:算法名称数学建模表达核心思想时间复杂度适用场景推理步骤首次适

weixin_49199313的博客 1406

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 572

Python爬取京东商品数据保姆级教程(附源码及效果图)

本文介绍了一个基于Python的京东商品数据爬取教程,适合入门级开发者使用。文章详细讲解了从安装依赖库(DrissionPage、pandas等)到完成数据爬取的全过程,包括:1. 模拟用户搜索操作;2. 解析商品标题、价格、销量等关键信息;3. 处理复杂数据格式(如转换万级销量);4. 数据存储与Excel导出。教程提供了完整的封装函数,支持自定义搜索关键词和爬取数量,并包含错误处理和多种元素定位方式。最终数据会按时间戳命名导出为Excel文件,方便用于课程作业或毕业设计。

weixin_46449236的博客 1877

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 162

【论文精读】DisCo: Graph-Based Disentangled Contrastive Learning for Cold-Start Cross-Domain Recommendat

源域中具有相似偏好的用户在目标域中可能会表现出不同的兴趣。因此,直接迁移嵌入可能会引入不相关的源域协同信息。提出了一个基于图的解耦对比学习框架,以捕捉细粒度的用户意图并过滤掉不相关的协同信息,从而避免负迁移。 具体而言,对于每个域,我们使用多通道图编码器来捕捉多样化的用户意图。然后,我们在嵌入空间中构建亲和图,并执行多步随机游走以捕捉高阶用户相似性关系。将一个域视为目标域,我们提出了一种以用户相似性为指导的解耦意图对比学习方法,以优化跨域的用户意图桥接。

qq_52342142的博客 1230

手把手教你用示波器搞定PCIe 5.0 REFCLK时钟信号测量(附完整参数解读)

本文详细介绍了如何使用示波器进行PCIe 5.0 REFCLK时钟信号测量,包括示波器与探头的选择、关键参数的测量方法及解读,以及实战中的常见问题与解决方案。通过手把手教学和完整参数解读,帮助硬件工程师高效完成时钟信号测量,确保系统稳定性。

weixin_28704565的博客 361

Rust组织管理(AI回答)

你想做的事JS / Python 做法Rust 做法把一个文件纳入工程新建文件即可新建 xxx.rs 后,必须在入口写mod xxx;挂载对外暴露函数/结构体export(Python 默认全公开)默认全私有,必须显式加pub引入别处的函数use crate::模块名::函数名;找路径的基准词./ 或 ../(从 src 根出发)、(上一级 ../)、(当前级 ./)日常写项目:不要用 #[path],直接遵守默认规则——

yaoct的博客 153

板蓝根挥发油微胶囊化技术及其在抗菌织物整理中的应用研究

微胶囊技术是一种通过成膜材料将具有反应活性或挥发性的液体或固体包封成微小颗粒的技术。该技术因其优异的缓释保护和物态改变性能,已在医药、食品、化妆品等多个领域得到广泛应用。本研究采用复凝聚法制备板蓝根挥发油的微胶囊,利用明胶和阿拉伯胶作为壁材,旨在提升其稳定性和抗菌性能。

qq_62634009的博客 585

自建 RustDesk 服务端后,做一个“装完就能连“的客户端

目前市面上的远程工具(如向日葵、toDesk等)免费版基本上都卡的不行,而且收费版好像也会卡。如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 627

TypeError: ‘<=‘not supported between instances of ‘float’and ‘str‘解决方案

本文主要介绍了TypeError: '

weixin_43178406的博客 28万+

DeepSeek如何构建可扩展的 AI 驱动交易系统,基于 MetaTrader 5 与 Python 利用先进的数据处理、机器学习和容器化部署来优化算法交易。

MT5 Python API 架构设计分为三层:通信层:利用异步消息传递(例如 ZeroMQ 或标准套接字编程)支持每秒数万个数据请求。转换层: C++ 动态库有效地将 MT5 命令转换为 Python 对象(反之亦然),从而优化速度和内存使用率。接口层:提供Pythonic API,封装了所有终端功能,包括:1)实时价格订阅(滴答或秒级更新)2)历史数据检索(从M1到更高的时间范围)3)订单流监控(交易详情和市场深度)4)策略执行引擎(用于算法交易)

iCloudEnd的博客 1387

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 178

相机图像质量评估标准全解析:MTF、CA、SNR 与色彩偏差的实战理解

图像质量评估是影像系统开发中的核心环节,它直接影响用户视觉体验与终端产品竞争力。本文基于真实的图像调试工程实践,系统讲解主流图像评价指标,包括调制传递函数(MTF)、色差(CA)、信噪比(SNR)与色彩偏差(DeltaE)等关键标准。结合 Imatest 测试流程与实际样张数据,逐项拆解各项指标在实际图像分析中的意义与优化路径,帮助开发者建立完整、量化、工程化的图像质量评估体系。

努力分享一些人工智能、计算机视觉、影像等相关的知识干货! 2808

GitHub 热榜项目:日榜(2026-11-10)

本期共 11 个热门开源项目,合计新增 13,136 stars。榜单前三分别是 Anthropic 的 Agent Skills 仓库、Meta 开源的 React 设计系统 Astryx(+3,278)和用户名检索工具 sherlock(+4,267,本期涨星最多)。其余项目覆盖 DeepMind 的物理引擎 MuJoCo、Claude 官方示例集、自托管智能体记忆系统 GBrain、用 Rust 写的浏览器自动化 CLI、基于 WiFi 信号的人体感知平台 RuView、多市场股票分析工具,以及 Ho

u130130的博客 444

路径跟踪 | 图解纯追踪算法Pure Pursuit(附ROS C++/Python/Matlab仿真)

纯追踪算法(Pure Pursuit)参考了人类驾驶行为,其基本思想是在待跟踪路径上设置预瞄点(goal-ahead),通过简单的几何方法驱动机器人跟踪预瞄点直至抵达目标位置.本文详细推导纯追踪算法的理论原理及其变种——自适应纯追踪算法(APP)和规范化纯追踪算法(RPP),并提供ROS C++/Python/Matlab三种仿真实现加深理解

FRIGIDWINTER的博客 8415

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

GitHub 今日推荐|HGhubX:Tauri 2 跨平台短剧客户端实战

Tauri 2 + Rust + React 构建的跨平台短剧观看客户端,实现 HLS 代理、AES 封面解密、多线路探测与会话隔离,覆盖桌面与移动全平台。

wfly blog 399

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Rust 日志追踪实战:工业边缘场景下的 tracing

Rust 生态下:相比println!log,它提供结构化字段、span 上下文、异步友好和 OpenTelemetry 集成。本文从工程实战角度梳理 tracing 的用法与常见的坑。

ZenovaEdgeOS的博客 560

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

ARTCRAFT系列软件简单试用手记1

AI辅助开发推动开源重构热潮,ARTCRAFT系列以Rust重写经典软件,性能媲美C/C++。其Launcher支持多平台、多架构,可快速部署开源版Excel(GridCraft)与Word(WordCraft),启动速度远超Office 2016。界面类Office 2016,但暂不完善汉字字号与红头嵌套编辑。项目持续更新,主打“CraftAnything”理念——理解软件原理,自创版本,未来可期。

olegja3d的博客 212

第 1 讲:内存布局与所有权解剖——栈帧、胖指针与“移动/拷贝”在汇编层面的真实面目

看图最下面的(或者数组切片&[T]它在栈上占16 个字节,由(ptr, len)两个机器字组成。这就是系统编程里常说的胖指针(普通指针只有 8 字节地址,它胖了一倍,多带了一个 8 字节的长度或虚表指针)。痛点追问:C 语言里表示字符串切片只要一个 8 字节的char*,为什么 Rust 非要浪费双倍的栈空间搞成 16 字节?如果少掉len这一环会出什么乱子?回想一下 C 语言是怎么知道一个字符串在哪结束的:靠在内存末尾塞一个字节的\0求长度是 $O(N)$ 的苦力活:在 C 里调strlen(p)

yaoct的博客 168

Rust如何实现微服务网关的高并发与限流熔断机制

在现代互联网系统中,微服务架构已成为主流,而微服务网关则是整个系统的重要组成部分。当面对高并发、高可用性需求时,很多开发者对如何用 Rust 实现一个稳定可靠的网关存在疑惑,尤其是处理请求的幂等性、限流和熔断机制。本文将以 Rust 的实际案例为基础,结合生产环境中的具体经验,讲解如何设计和实现一个具备限流与熔断能力的微服务网关。

wuchangjian的专栏 115

Rust LeetCode334 算法题解

本文分析了 LeetCode 334 题“递增的三元子序列”的两种解法。暴力法(三重循环)时间复杂度为 O(n³),仅适用于小数据;最优解采用一次扫描贪心策略,维护 first(最小值)和 second(递增对第二元素的最小值),通过三个分支判断:若当前数大于 second,则存在三元递增子序列;否则更新 first 或 second。算法正确性基于不变式:first 始终为已遍历最小值,second 为可形成递增对的最小尾部。时间复杂度 O(n),空间复杂度 O(1),适用于大规模数据。

weixin_43379230的博客 352

主流开源 LLM 网关横向评测:OneAPI、LiteLLM、NewAPI 能力对比

在大模型应用规模化落地的当下,多模型混用、API 密钥分散、成本不可控、接口不统一已成为开发者的普遍痛点。LLM 网关作为 AI 应用层与模型层之间的核心中间件,承担着协议转换、流量路由、成本管控、安全审计的关键作用。本文从协议许可、功能完备度、性能表现、生态适配四个核心维度,对业内主流的三款开源 LLM 网关 ——OneAPI、LiteLLM、NewAPI 进行深度横向评测,为不同规模的团队提供选型参考。

2601_96785163的博客 303

Rust 1.100 的 DropGuard:用 Python 实测失败回滚与吞异常

解析一批数据往列表里塞,塞到第三条抛异常,列表已经脏了一半——这类「能跑但结果不对」的 bug 不报错也不崩溃。Rust 1.100.0 把 core::mem::DropGuard 稳定了:包裹一个

aifannihao的博客 222

rust: Push & Pull Pattern

本项目基于Rust实现珠宝行业全流程的推-拉(Push&Pull)消息模式,采用领域驱动设计(DDD)六层架构。通过JewelryPushPullHub通道实现生产者推送与消费者拉取解耦,12个业务部门(如采购、设计、质检等)作为独立消费者,按供应链顺序串行或并发处理消息。系统集成重试熔断、线程安全日志(按日期/等级分文件)、内存仓储及依赖注入容器,确保高并发下流程可追溯、弹性可靠。演示涵盖串行调度、批量并发、端口契约调用等场景,完整呈现企业级消息型模式的核心能力。

Geovin Du Dream Park 117

拆解 lan-scanner:一个零依赖 Rust 局域网扫描器的并发模型

lan-scanner 以零依赖实现高效局域网扫描,核心在于精巧的并发模型:通过懒加载任务队列(Jobs)避免内存爆炸,用 Arc<Mutex<Jobs>> 共享任务源,结合 mpsc 通道实现线程池并行探测。Probe 枚举统一 ICMP ping 与 TCP 端口扫描,跨平台差异由 #[cfg] 条件编译处理,调用系统 ping 命令规避权限问题。drop(tx) 优雅关闭通道,确保所有工作线程退出。全靠标准库完成高并发、低资源消耗的扫描,是 Rust 并发编程的典范。

weixin_63115449的博客 185

我用 RustyPaste 做 AI Agent 云端存储

RustyPaste 是一个用 Rust 编写的极简文件上传与 Pastebin 服务。可以用来存储和访问 AI Agent 生成的文件

藏云阁技术社区 240
上一篇: Cargo 与 monorepo:Rust 大型项目的代码组织范式对比与选择
下一篇: WASM 在企业级应用中的落地:哪些场景已经成熟,哪些还在探索
第一程序员
博客等级 码龄1年 1万+粉丝 1822原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值