<![CDATA[OneTwoOne]]> https://cn121.com/ zh-cn llm-cookbook - 面向开发者的 LLM 入门教程 https://cn121.com/llm/datawhalechina-llm-cookbook.html 面向开发者的大模型手册 - LLM Cookbook

项目简介

本项目是一个面向开发者的大模型手册，针对国内开发者的实际需求，主打 LLM 全方位入门实践。本项目基于吴恩达老师大模型系列课程内容，对原课程内容进行筛选、翻译、复现和调优，覆盖从 Prompt Engineering 到 RAG 开发、模型微调的全部流程，用最适合国内学习者的方式，指导国内开发者如何学习、入门 LLM 相关项目。

针对不同内容的特点，我们对共计 11 门吴恩达老师的大模型课程进行了翻译复现，并结合国内学习者的实际情况，对不同课程进行了分级和排序，初学者可以先系统学习我们的必修类课程，掌握入门 LLM 所有方向都需要掌握的基础技能和概念，再选择性地学习我们的选修类课程，在自己感兴趣的方向上不断探索和学习。

如果有你非常喜欢但我们还没有进行复现的吴恩达老师大模型课程，我们欢迎每一位开发者参考我们已有课程的格式和写法来对课程进行复现并提交 PR，在 PR 审核通过后，我们会根据课程内容将课程进行分级合并。欢迎每一位开发者的贡献！

在线阅读地址：面向开发者的 LLM 入门课程 - 在线阅读

PDF 下载地址：面向开发者的 LLM 入门教程 - PDF

英文原版地址：吴恩达关于大模型的系列课程

项目意义

LLM 正在逐步改变人们的生活，而对于开发者，如何基于 LLM 提供的 API 快速、便捷地开发一些具备更强能力、集成 LLM 的应用，来便捷地实现一些更新颖、更实用的能力，是一个急需学习的重要能力。

由吴恩达老师与 OpenAI 合作推出的大模型系列教程，从大模型时代开发者的基础技能出发，深入浅出地介绍了如何基于大模型 API、LangChain 架构快速开发结合大模型强大能力的应用。其中，《Prompt Engineering for Developers》教程面向入门 LLM 的开发者，深入浅出地介绍了对于开发者，如何构造 Prompt 并基于 OpenAI 提供的 API 实现包括总结、推断、转换等多种常用功能，是入门 LLM 开发的经典教程；《Building Systems with the ChatGPT API》教程面向想要基于 LLM 开发应用程序的开发者，简洁有效而又系统全面地介绍了如何基于 ChatGPT API 打造完整的对话系统；《LangChain for LLM Application Development》教程结合经典大模型开源框架 LangChain，介绍了如何基于 LangChain 框架开发具备实用功能、能力全面的应用程序，《LangChain Chat With Your Data》教程则在此基础上进一步介绍了如何使用 LangChain 架构结合个人私有数据开发个性化大模型应用；《Building Generative AI Applications with Gradio》、《Evaluating and Debugging Generative AI》教程分别介绍了两个实用工具 Gradio 与 W&B，指导开发者如何结合这两个工具来打造、评估生成式 AI 应用。

上述教程非常适用于开发者学习以开启基于 LLM 实际搭建应用程序之路。因此，我们将该系列课程翻译为中文，并复现其范例代码，也为其中一个视频增加了中文字幕，支持国内中文学习者直接使用，以帮助中文学习者更好地学习 LLM 开发；我们也同时实现了效果大致相当的中文 Prompt，支持学习者感受中文语境下 LLM 的学习使用，对比掌握多语言语境下的 Prompt 设计与 LLM 开发。未来，我们也将加入更多 Prompt 高级技巧，以丰富本课程内容，帮助开发者掌握更多、更巧妙的 Prompt 技能。

项目受众

所有具备基础 Python 能力，想要入门 LLM 的开发者。

项目亮点

《ChatGPT Prompt Engineering for Developers》、《Building Systems with the ChatGPT API》等教程作为由吴恩达老师与 OpenAI 联合推出的官方教程，在可预见的未来会成为 LLM 的重要入门教程，但是目前还只支持英文版且国内访问受限，打造中文版且国内流畅访问的教程具有重要意义；同时，GPT 对中文、英文具有不同的理解能力，本教程在多次对比、实验之后确定了效果大致相当的中文 Prompt，支持学习者研究如何提升 ChatGPT 在中文语境下的理解与生成能力。

学习指南

本教程适用于所有具备基础 Python 能力，想要入门 LLM 的开发者。

如果你想要开始学习本教程，你需要提前具备：

  1. 至少一个 LLM API（最好是 OpenAI，如果是其他 API，你可能需要参考 其他教程 对 API 调用代码进行修改）
  2. 能够使用 Python Jupyter Notebook

本教程共包括 11 门课程，分为必修类、选修类两个类别。必修类课程是我们认为最适合初学者学习以入门 LLM 的课程，包括了入门 LLM 所有方向都需要掌握的基础技能和概念，我们也针对必修类课程制作了适合阅读的在线阅读和 PDF 版本，在学习必修类课程时，我们建议学习者按照我们列出的顺序进行学习；选修类课程是在必修类课程上的拓展延伸，包括了 RAG 开发、模型微调、模型评估等多个方面，适合学习者在掌握了必修类课程之后选择自己感兴趣的方向和课程进行学习。

必修类课程包括：

  1. 面向开发者的 Prompt Engineering。基于吴恩达老师《ChatGPT Prompt Engineering for Developers》课程打造，面向入门 LLM 的开发者，深入浅出地介绍了对于开发者，如何构造 Prompt 并基于 OpenAI 提供的 API 实现包括总结、推断、转换等多种常用功能，是入门 LLM 开发的第一步。
  2. 搭建基于 ChatGPT 的问答系统。基于吴恩达老师《Building Systems with the ChatGPT API》课程打造，指导开发者如何基于 ChatGPT 提供的 API 开发一个完整的、全面的智能问答系统。通过代码实践，实现了基于 ChatGPT 开发问答系统的全流程，介绍了基于大模型开发的新范式，是大模型开发的实践基础。
  3. 使用 LangChain 开发应用程序。基于吴恩达老师《LangChain for LLM Application Development》课程打造，对 LangChain 展开深入介绍，帮助学习者了解如何使用 LangChain，并基于 LangChain 开发完整的、具备强大能力的应用程序。
  4. 使用 LangChain 访问个人数据。基于吴恩达老师《LangChain Chat with Your Data》课程打造，深入拓展 LangChain 提供的个人数据访问能力，指导开发者如何使用 LangChain 开发能够访问用户个人数据、提供个性化服务的大模型应用。

选修类课程包括：

  1. 使用 Gradio 搭建生成式 AI 应用。基于吴恩达老师《Building Generative AI Applications with Gradio》课程打造，指导开发者如何使用 Gradio 通过 Python 接口程序快速、高效地为生成式 AI 构建用户界面。
  2. 评估改进生成式 AI。基于吴恩达老师《Evaluating and Debugging Generative AI》课程打造，结合 wandb，提供一套系统化的方法和工具，帮助开发者有效地跟踪和调试生成式 AI 模型。
  3. 微调大语言模型。基于吴恩达老师《Finetuning Large Language Model》课程打造，结合 lamini 框架，讲述如何便捷高效地在本地基于个人数据微调开源大语言模型。
  4. 大模型与语义检索。基于吴恩达老师《Large Language Models with Semantic Search》课程打造，针对检索增强生成，讲述了多种高级检索技巧以实现更准确、高效的检索增强 LLM 生成效果。
  5. 基于 Chroma 的高级检索。基于吴恩达老师《Advanced Retrieval for AI with Chroma》课程打造，旨在介绍基于 Chroma 的高级检索技术，提升检索结果的准确性。
  6. 搭建和评估高级 RAG 应用。基于吴恩达老师《Building and Evaluating Advanced RAG Applications》课程打造，介绍构建和实现高质量 RAG 系统所需的关键技术和评估框架。
  7. LangChain 的 Functions、Tools 和 Agents。基于吴恩达老师《Functions, Tools and Agents with LangChain》课程打造，介绍如何基于 LangChain 的新语法构建 Agent。
  8. Prompt 高级技巧。包括 CoT、自我一致性等多种 Prompt 高级技巧的基础理论与代码实现。

其他资料包括：

双语字幕视频地址：吴恩达 x OpenAI 的 Prompt Engineering 课程专业翻译版

中英双语字幕下载：《ChatGPT 提示工程》非官方版中英双语字幕

视频讲解：面向开发者的 Prompt Engineering 讲解（数字游民大会）

目录结构说明：

content：基于原课程复现的双语版代码，可运行的 Notebook，更新频率最高，更新速度最快。

docs：必修类课程文字教程版在线阅读源码，适合阅读的 Markdown。

figures：图片文件。

致谢

核心贡献者

其他

  1. 特别感谢 @Sm1les、@LSGOMYP 对本项目的帮助与支持；
  2. 感谢 GithubDaily 提供的双语字幕；
  3. 如果有任何想法可以联系我们 Datawhale 也欢迎大家多多提出 Issues；
  4. 特别感谢以下为教程做出贡献的同学！

Made with contrib.rocks.

Star History

关注我们

扫描下方二维码关注公众号：Datawhale

Datawhale 是一个专注于数据科学与 AI 领域的开源组织，汇集了众多领域院校和知名企业的优秀学习者，聚合了一群有开源精神和探索精神的团队成员。微信搜索公众号 Datawhale 可以加入我们。

LICENSE


本作品采用知识共享署名 - 非商业性使用 - 相同方式共享 4.0 国际许可协议进行许可。

]]> Tue, 15 Sep 2026 17:20:23 +0800 OTO https://cn121.com/llm/datawhalechina-llm-cookbook.html letta - 有状态代理的平台：具有高级内存的人工智能 https://cn121.com/llm/letta-ai-letta.html Letta

Build stateful agents with memory that can learn and improve over time.

Letta (f.k.a. MemGPT) is actively developed. The current source code lives in letta-ai/letta-code, which includes the agent harness, interactive terminal UI, App Server, channels, and the runtime used by the desktop and web apps.

Get started

Install Letta from npm:

npm install -g @letta-ai/letta-code

Launch the interactive terminal UI:

letta

Run the App Server for local or self-hosted agents:

letta server

You can also use Letta through:

See the Letta documentation for current installation, development, and deployment instructions.

Historical source

The archive branch contains the retired Letta V1 API server. Existing tags and releases remain available for reproducibility, but active projects should use the current source.

]]> Tue, 15 Sep 2026 17:20:17 +0800 OTO https://cn121.com/llm/letta-ai-letta.html llm-action - 本项目旨在分享大模型相关技术原理以及实战经验（大模型 https://cn121.com/llm/liguodongiot-llm-action.html

LLM训练

LLM训练实战

下面汇总了我在大模型实践中训练相关的所有教程。从6B到65B，从全量微调到高效微调（LoRA，QLoRA，P-Tuning v2），再到RLHF（基于人工反馈的强化学习）。

LLM 预训练/SFT/RLHF... 参数 教程 代码
Alpaca full fine-turning 7B 从0到1复现斯坦福羊驼（Stanford Alpaca 7B） 配套代码
Alpaca(LLaMA) LoRA 7B~65B 1.足够惊艳，使用Alpaca-Lora基于LLaMA(7B)二十分钟完成微调，效果比肩斯坦福羊驼
2. 使用 LoRA 技术对 LLaMA 65B 大模型进行微调及推理		 配套代码
BELLE(LLaMA/Bloom) full fine-turning 7B 1.基于LLaMA-7B/Bloomz-7B1-mt复现开源中文对话大模型BELLE及GPTQ量化
2. BELLE(LLaMA-7B/Bloomz-7B1-mt)大模型使用GPTQ量化后推理性能测试		 N/A
ChatGLM LoRA 6B 从0到1基于ChatGLM-6B使用LoRA进行参数高效微调 配套代码
ChatGLM full fine-turning/P-Tuning v2 6B 使用DeepSpeed/P-Tuning v2对ChatGLM-6B进行微调 配套代码
Vicuna(LLaMA) full fine-turning 7B 大模型也内卷，Vicuna训练及推理指南，效果碾压斯坦福羊驼 N/A
OPT RLHF 0.1B~66B 1.一键式 RLHF 训练 DeepSpeed Chat（一）：理论篇 
2. 一键式 RLHF 训练 DeepSpeed Chat（二）：实践篇		 配套代码
MiniGPT-4(LLaMA) full fine-turning 7B 大杀器，多模态大模型MiniGPT-4入坑指南 N/A
Chinese-LLaMA-Alpaca(LLaMA) LoRA（预训练+微调） 7B 中文LLaMA&Alpaca大语言模型词表扩充+预训练+指令精调 配套代码
LLaMA QLoRA 7B/65B 高效微调技术QLoRA实战，基于LLaMA-65B微调仅需48G显存，真香 配套代码
LLaMA GaLore 60M/7B 突破内存瓶颈，使用 GaLore 一张4090消费级显卡也能预训练LLaMA-7B 配套代码

⬆ 一键返回目录

LLM微调技术原理

对于普通大众来说，进行大模型的预训练或者全量微调遥不可及。由此，催生了各种参数高效微调技术，让科研人员或者普通开发者有机会尝试微调大模型。

因此，该技术值得我们进行深入分析其背后的机理，本系列大体分七篇文章进行讲解。

LLM微调实战

下面给大家分享大模型参数高效微调技术实战，该系列主要针对 HuggingFace PEFT 框架支持的一些高效微调技术进行讲解。

教程 代码 框架
大模型参数高效微调技术实战（一）-PEFT概述及环境搭建 N/A HuggingFace PEFT
大模型参数高效微调技术实战（二）-Prompt Tuning 配套代码 HuggingFace PEFT
大模型参数高效微调技术实战（三）-P-Tuning 配套代码 HuggingFace PEFT
大模型参数高效微调技术实战（四）-Prefix Tuning / P-Tuning v2 配套代码 HuggingFace PEFT
大模型参数高效微调技术实战（五）-LoRA 配套代码 HuggingFace PEFT
大模型参数高效微调技术实战（六）-IA3 配套代码 HuggingFace PEFT
大模型微调实战（七）-基于LoRA微调多模态大模型 配套代码 HuggingFace PEFT
大模型微调实战（八）-使用INT8/FP4/NF4微调大模型 配套代码 PEFT、bitsandbytes

⬆ 一键返回目录

LLM分布式训练并行技术

近年来，随着Transformer、MOE架构的提出，使得深度学习模型轻松突破上万亿规模参数，传统的单机单卡模式已经无法满足超大模型进行训练的要求。因此，我们需要基于单机多卡、甚至是多机多卡进行分布式大模型的训练。

而利用AI集群，使深度学习算法更好地从大量数据中高效地训练出性能优良的大模型是分布式机器学习的首要目标。为了实现该目标，一般需要根据硬件资源与数据/模型规模的匹配情况，考虑对计算任务、训练数据和模型进行划分，从而进行分布式训练。因此，分布式训练相关技术值得我们进行深入分析其背后的机理。

下面主要对大模型进行分布式训练的并行技术进行讲解，本系列大体分九篇文章进行讲解。

⬆ 一键返回目录

分布式AI框架

  • PyTorch
    • PyTorch 单机多卡训练
    • PyTorch 多机多卡训练
  • Megatron-LM
  • DeepSpeed
    • DeepSpeed 单机多卡训练
    • DeepSpeed 多机多卡训练
  • Megatron-DeepSpeed
    • 基于 Megatron-DeepSpeed 从 0 到1 完成 LLaMA 预训练
    • 基于 Megatron-DeepSpeed 从 0 到1 完成 Bloom 预训练
  • Nanotron：一个用于预训练 Transformer 模型的库，其设计目标是易用、快速且可扩展。
  • Pai-Megatron-Patch：基于阿里云智算服务PAI-灵骏平台的大模型最佳实践解决方案配套工具。是各类开源大模型和Megatron训练加速引擎之间的“桥梁”，为用户提供用Megatron训练开源大模型的易用性以及LLM算法场景定制化的灵活性。 同时它可以帮助大模型开发者快速上手PAI灵骏产品，完成大模型的高效分布式训练，有监督指令微调，模型离线推理验证等完整大模型开发链路。

分布式训练网络通信

待更新...

LLM训练优化技术

  • FlashAttention V1、V2
  • 混合精度训练
  • 重计算
  • MQA / GQA
  • 梯度累积

LLM对齐技术

  • PPO（近端策略优化）
  • DPO
  • ORPO

⬆ 一键返回目录

LLM推理

推理引擎

迷你LLM推理引擎（非常适合源码学习）：

  • Nano-vLLM源码注释：从头开始构建的轻量级 vLLM 实现。
  • Mini-SGLang：一个轻量但高性能的大型语言模型推理框架，SGLang 的紧凑实现。

生产级LLM推理引擎：

其他推理引擎：

  • LMDeploy
  • LightLLM：纯Python开发的大语言模型推理和服务框架
  • MNN-LLM：基于MNN引擎开发的大型语言模型运行时解决方案
  • 赤兔
  • mllm：端侧多模态LLM推理引擎

推理服务

LLM推理优化技术

LLM压缩

近年来，随着Transformer、MOE架构的提出，使得深度学习模型轻松突破上万亿规模参数，从而导致模型变得越来越大，因此，我们需要一些大模型压缩技术来降低模型部署的成本，并提升模型的推理性能。 模型压缩主要分为如下几类：

  • 模型剪枝（Pruning）
  • 知识蒸馏（Knowledge Distillation）
  • 模型量化（Quantization）
  • 低秩分解（Low-Rank Factorization）

LLM量化

本系列将针对一些常见大模型量化方案（GPTQ、LLM.int8()、SmoothQuant、AWQ等）进行讲述。

LLM稀疏化

目前，大多数针对大模型模型的压缩技术都专注于模型量化领域，即降低单个权重的数值表示的精度。另一种模型压缩方法模型剪枝的研究相对较少，即删除网络元素，包括从单个权重（非结构化剪枝）到更高粒度的组件，如权重矩阵的整行/列（结构化剪枝）。

本系列将针对一些常见大模型稀疏化方案（LLM-Pruner、SliceGPT、SparseGPT、Wanda等）进行讲述。

结构化剪枝：

  • LLM-Pruner(LLM-Pruner: On the Structural Pruning of Large Language Models)
  • LLM-Shearing(Sheared LLaMA: Accelerating Language Model Pre-training via Structured Pruning)
  • SliceGPT: Compress Large Language Models by Deleting Rows and Columns
  • LoSparse

非结构化剪枝：

  • SparseGPT(SparseGPT: Massive Language Models Can be Accurately Pruned in One-Shot)
  • LoRAPrune(LoRAPrune: Pruning Meets Low-Rank Parameter-Efficient Fine-Tuning)
  • Wanda(A Simple and Effective Pruning Approach for Large Language Models)
  • Flash-LLM(Flash-LLM: Enabling Cost-Effective and Highly-Efficient Large Generative Model Inference with Unstructured Sparsity)

LLM知识蒸馏

Standard KD:

使学生模型学习教师模型(LLM)所拥有的常见知识，如输出分布和特征信息，这种方法类似于传统的KD。

  • MINILLM
  • GKD

EA-based KD:

不仅仅是将LLM的常见知识转移到学生模型中，还涵盖了蒸馏它们独特的涌现能力。具体来说，EA-based KD又分为了上下文学习（ICL）、思维链（CoT）和指令跟随（IF）。

In-Context Learning：

  • In-Context Learning distillation

Chain-of-Thought：

  • MT-COT
  • Fine-tune-CoT
  • DISCO
  • SCOTT
  • SOCRATIC CoT

Instruction Following：

  • Lion

低秩分解

低秩分解旨在通过将给定的权重矩阵分解成两个或多个较小维度的矩阵，从而对其进行近似。低秩分解背后的核心思想是找到一个大的权重矩阵W的分解，得到两个矩阵U和V，使得W≈U V，其中U是一个m×k矩阵，V是一个k×n矩阵，其中k远小于m和n。U和V的乘积近似于原始的权重矩阵，从而大幅减少了参数数量和计算开销。

在LLM研究的模型压缩领域，研究人员通常将多种技术与低秩分解相结合，包括修剪、量化等。

  • ZeroQuant-FP（低秩分解+量化）
  • LoRAPrune（低秩分解+剪枝）

LLM测评

LLM效果评测

测评集

  • C-Eval：全面的中文基础模型评估套件，涵盖了52个不同学科的13948个多项选择题，分为四个难度级别。
  • CMMLU：一个综合性的中文评估基准，专门用于评估语言模型在中文语境下的知识和推理能力。CMMLU涵盖了从基础学科到高级专业水平的67个主题。它包括：需要计算和推理的自然科学，需要知识的人文科学和社会科学,以及需要生活常识的中国驾驶规则等。此外，CMMLU中的许多任务具有中国特定的答案，可能在其他地区或语言中并不普遍适用。因此是一个完全中国化的中文测试基准。
  • LVEval：一个具备5个长度等级（16k、32k、64k、128k和256k）、最大文本测试长度达到256k的长文本评测基准。LV-Eval的平均文本长度达到102,380字，最小/最大文本长度为11,896/387,406字。LV-Eval主要有两类评测任务——单跳QA和多跳QA，共包含11个涵盖中英文的评测数据子集。LV-Eval设计时引入3个关键技术：干扰事实插入（Confusiong Facts Insertion，CFI）提高挑战性，关键词和短语替换（Keyword and Phrase Replacement，KPR）减少信息泄漏，以及基于关键词召回的评测指标（Answer Keywords，AK，指代结合答案关键词和字词黑名单的评价指标）提高评测数值客观性。
  • IFEval: Instruction Following Eval/Paper：专注评估大模型遵循指令的能力,包含关键词检测、标点控制、输出格式要求等25种任务。
  • SuperCLUE：一个综合性大模型评测基准，本次评测主要聚焦于大模型的四个能力象限，包括语言理解与生成、专业技能与知识、Agent智能体和安全性，进而细化为12项基础能力。
  • AGIEval：用于评估基础模型在与人类认知和解决问题相关的任务中的能力。该基准源自 20 项面向普通考生的官方、公开、高标准的入学和资格考试，例如：普通大学入学考试（例如：中国高考（Gaokao）和美国 SAT）、法学院入学考试、数学竞赛、律师资格考试、国家公务员考试。
  • LongBench：一个双语（中英文）多任务基准数据集，旨在评估大语言模型的长上下文理解能力。它包含21个任务，涵盖单文档问答、多文档问答、摘要、小样本学习、合成任务和代码补全等。数据集平均任务长度范围为5k到15k，共包含4750个测试数据。LongBench 采用全自动评估方法，旨在以最低的成本衡量和评估模型理解长上下文的能力。

Coding：

  • Terminal-Bench v2：一套命令行基准测试套件，用于评估 AI 代理在 89 个真实世界的多步骤终端任务中的表现。这些任务涵盖编译、调试到系统管理等多个方面，并在隔离的容器环境中运行，配有严格的验证机制。
  • SWE-bench：一个用于评估大型语言模型在真实世界软件问题上表现的基准测试，这些问题收集自GitHub。 给定一个代码库和一个问题,语言模型的任务是生成一个补丁来解决描述的问题。

Agent：

  • Claw-Eval：Claw-Eval 是一个用来评估大语言模型作为智能体的评估工具。所有任务均经过人工验证。

Storage：

  • MLPerf Storage Benchmark：用于评估机器学习训练场景下存储系统性能的开源基准测试套件。核心目标是衡量存储系统能否以足够快的速度向计算GPU提供训练数据，从而避免昂贵的GPU算力闲置。

测评工具

  • OpenCompass：司南 2.0 大模型评测体系。
  • EvalScope：魔搭社区官方推出的模型评测与性能基准测试框架，专为多样化的模型评估需求而设计。它支持广泛的模型类型，包括但不限于大语言模型、多模态模型、Embedding 模型、Reranker 模型和 CLIP 模型。EvalScope还适用于多种评测场景，如端到端RAG评测、竞技场模式和模型推理性能压测等，其内置多个常用测试基准和评测指标，如MMLU、CMMLU、C-Eval、GSM8K等。

LLM推理性能压测

指标 描述 Aggregations
Time to First Token Time between when a request is sent and when its first response is received, one value per request in benchmark Avg, min, max, p99, p90, p75
Time to Second Token Time between when the first streaming response is received and when the second streaming response is received, one value per request in benchmark Avg, min, max, p99, p90, p75
Inter Token Latency Time between intermediate responses for a single request divided by the number of generated tokens of the latter response, one value per response per request in benchmark Avg, min, max, p99, p90, p75
Request Latency Time between when a request is sent and when its final response is received, one value per request in benchmark Avg, min, max, p99, p90, p75
Output Sequence Length Total number of output tokens of a request, one value per request in benchmark Avg, min, max, p99, p90, p75
Input Sequence Length Total number of input tokens of a request, one value per request in benchmark Avg, min, max, p99, p90, p75
Output Token Throughput Total number of output tokens from benchmark divided by benchmark duration None–one value per benchmark
Request Throughput Number of final responses from benchmark divided by benchmark duration None–one value per benchmark

LLM数据工程

LLM Data Engineering

预训练语料处理技术

  • 数据收集
  • 数据处理

README 内容已截断, 请前往 GitHub 查看完整内容。

]]> Tue, 15 Sep 2026 17:20:10 +0800 OTO https://cn121.com/llm/liguodongiot-llm-action.html promptfoo - 测试您的提示 https://cn121.com/automation/promptfoo-promptfoo.html Promptfoo: LLM evals & red teaming

promptfoo is a CLI and library for evaluating and red-teaming LLM apps. Stop the trial-and-error approach - start shipping secure, reliable AI apps.

Website · Getting Started · Red Teaming · Documentation · Discord

Promptfoo is now part of OpenAI. Promptfoo remains open source and MIT licensed. Read the company update.

Quick Start

Requires Node.js >=22.22.0 for npm and npx usage. Node.js 24 LTS is recommended; see the runtime support guide.

npm install -g promptfoo
promptfoo init --example getting-started

Also available via brew install promptfoo and pip install promptfoo. You can also use npx promptfoo@latest to run any command without installing.

Most LLM providers require an API key. Set yours as an environment variable:

export OPENAI_API_KEY=sk-abc123

Once you're in the example directory, run an eval and view results:

cd getting-started
promptfoo eval
promptfoo view

See Getting Started (evals) or Red Teaming (vulnerability scanning) for more.

What can you do with Promptfoo?

  • Test your prompts and models with automated evaluations
  • Secure your LLM apps with red teaming and vulnerability scanning
  • Compare models side-by-side (OpenAI, Anthropic, Azure, Bedrock, Ollama, and more)
  • Automate checks in CI/CD
  • Review pull requests for LLM-related security and compliance issues with code scanning
  • Share results with your team

Here's what it looks like in action:

It works on the command line too:

It also can generate security vulnerability reports:

Why Promptfoo?

  • Developer-first: Fast, with features like live reload and caching
  • Private: LLM evals run 100% locally - your prompts never leave your machine
  • Flexible: Works with any LLM API or programming language
  • Battle-tested: Powers LLM apps serving 10M+ users in production
  • Data-driven: Make decisions based on metrics, not gut feel
  • Open source: MIT licensed, with an active community

Learn More

Contributing

We welcome contributions! Check out our contributing guide to get started.

Join our Discord community for help and discussion.

]]> Tue, 15 Sep 2026 17:20:03 +0800 OTO https://cn121.com/automation/promptfoo-promptfoo.html toon - 面🎒 向令牌的对象表示法（ TOON ） – LLM https://cn121.com/cli/toon-format-toon.html Token-Oriented Object Notation (TOON)

Token-Oriented Object Notation is a compact, human-readable encoding of the JSON data model that minimizes tokens and makes structure easy for models to follow.

TOON combines YAML's indentation-based structure for nested objects with CSV-style tabular forms for uniform data. Its sweet spot is uniform objects – same fields across items, whether in an array or keyed by ID – reaching CSV-like compactness while adding explicit structure that helps LLMs parse and validate data reliably. For deeply nested or non-uniform data, JSON may be more efficient.

Think of it as a translation layer: use JSON programmatically, and encode it as TOON for LLM input – a drop-in, lossless representation of the JSON you already have.

[!TIP]
The TOON format is stable, but also an idea in progress. Nothing's set in stone – help shape where it goes by contributing to the spec or sharing feedback.

Why TOON?

LLM tokens cost money – and JSON spends a lot of them on structure. A weather forecast in TOON:

location:
  city: Berlin
  country: DE
  units: metric
alerts[2]: frost,wind
forecast[3]{day,temp{min,max},condition,rainChance}:
  Mon,-2,4,snow,80
  Tue,1,7,cloudy,20
  Wed,3,11,sunny,5

The same data as JSON – ~117 tokens against TOON's ~66:

{
  "location": {
    "city": "Berlin",
    "country": "DE",
    "units": "metric"
  },
  "alerts": [
    "frost",
    "wind"
  ],
  "forecast": [
    {
      "day": "Mon",
      "temp": {
        "min": -2,
        "max": 4
      },
      "condition": "snow",
      "rainChance": 80
    },
    {
      "day": "Tue",
      "temp": {
        "min": 1,
        "max": 7
      },
      "condition": "cloudy",
      "rainChance": 20
    },
    {
      "day": "Wed",
      "temp": {
        "min": 3,
        "max": 11
      },
      "condition": "sunny",
      "rainChance": 5
    }
  ]
}

Three things are happening at once in the TOON above. Two are forms – one rendering of a value, picked automatically from the data's shape – and the third is a header feature:

  • alerts[2]: frost,wind is inline form: a primitive array on its header line.
  • forecast[3]{day,…}: is tabular form: the field list is declared once in the header, then one row per element.
  • temp{min,max} inside that header is a nested field group: the uniform nested temp objects fold into the header while rows stay flat.

The third form is keyed tabular, for objects whose values are uniform objects – config maps, feature flags, records by ID. The colon after the length ([2:]) marks it, and each row carries its own key:

JSONTOON
```json { "environments": { "production": { "region": "eu-central-1", "replicas": 6, "debug": false }, "staging": { "region": "eu-central-1", "replicas": 2, "debug": true } } } ``` ```toon environments[2:]{region,replicas,debug}: production: eu-central-1,6,false staging: eu-central-1,2,true ```

Anything that fits none of these – mixed types, non-uniform objects – falls back to the fourth form, list form: one - item per element, or a bare - for an empty object. Those four cover the shapes; the Format Overview covers the rest.

[!TIP]
Try it on your own data – no install required:

cat data.json | npx @toon-format/cli --stats

It prints the TOON alongside what the conversion saved – on the weather forecast above, that's:

ℹ Token estimates: ~117 (JSON) → ~66 (TOON)
✔ Saved ~51 tokens (-43.6%)

Key Features

  • 📊 Token-Efficient & Accurate: Matches JSON's retrieval accuracy while using 42.6% fewer tokens – see Benchmarks.
  • 🔁 JSON Data Model: Encodes the same objects, arrays, and primitives as JSON with deterministic, lossless round-trips.
  • 🛤️ LLM-Friendly Guardrails: [N] declares how many rows, {fields} how wide – so truncated or malformed output can't slip through.
  • 📐 Minimal Syntax: Uses indentation instead of braces and minimizes quoting, giving YAML-like readability with CSV-style compactness.
  • 🧺 Tabular Forms: Uniform objects – in an array or under keys – declare the field list once, then stream one row each.
  • 🌐 Multi-Language Ecosystem: Official implementations, plus dozens of community ports, all targeting one spec with a shared conformance test suite.

When Not to Use TOON

TOON excels with arrays of uniform objects. Reach for something else when:

  • Structures are deeply nested or non-uniform (tabular eligibility ≈ 0%) – compact JSON often wins outright.
  • Arrays are semi-uniform (~40–60% eligibility) – savings shrink; stay on JSON if your pipeline already speaks it.
  • Data is purely tabular – CSV is smaller. TOON's ~5–10% overhead buys declared lengths, field lists, and delimiter scoping, which is a reliability trade, not a size one.
  • Latency dominates – some deployments (notably local or quantized models) process compact JSON faster despite the higher token count. Measure TTFT and total time on your own setup.

Benchmarks below quantify the token and accuracy trade-offs; latency is the one you have to measure yourself.

Benchmarks

Two tracks, so every comparison is like-for-like:

  • Mixed-Structure Track: Nested and semi-uniform datasets (TOON vs JSON, YAML, XML). CSV is excluded – it cannot represent these structures without lossy flattening.
  • Flat-Only Track: Flat, fully tabular-eligible datasets, where CSV is a fair competitor.

Retrieval Accuracy

Benchmarks test LLM comprehension across different input formats using 244 data retrieval questions on 4 models.

Show Dataset Catalog

Dataset Catalog

Dataset Rows Structure CSV Support Eligibility
Uniform employee records 100 uniform ✓ 100%
E-commerce orders with nested structures 50 nested ✗ 33%
Time-series analytics data 60 uniform ✓ 100%
Top 100 GitHub repositories 100 uniform ✓ 100%
Semi-uniform event logs 75 semi-uniform ✗ 50%
Deeply nested configuration 1 deep ✗ 0%
Valid complete dataset (control) 20 uniform ✓ 100%
Array truncated: 3 rows removed from end 20 uniform ✓ 100%
Extra rows added beyond declared length 20 uniform ✓ 100%
Inconsistent field count (missing salary in row 10) 20 uniform ✓ 100%
Missing required fields (no email in multiple rows) 20 uniform ✓ 100%
Feature flags keyed by name 40 uniform ✗ 100%
Contacts with nested address and plan groups 50 nested ✗ 100%

Structure classes:

  • uniform: All objects have identical fields with primitive values
  • semi-uniform: Mix of uniform and non-uniform structures
  • nested: Objects with nested structures (nested objects or arrays)
  • deep: Highly nested with minimal tabular eligibility

CSV Support: ✓ (supported), ✗ (not supported – would require lossy flattening)

Eligibility: Percentage of arrays and keyed maps that qualify for TOON's tabular forms (uniform records whose fields are primitives or uniform nested objects folded into nested field groups)

Efficiency Ranking (Accuracy per 1K Tokens)

Each format ranked by efficiency (accuracy percentage per 1,000 tokens):

TOON           ████████████████████   29.2 acc%/1K tok  │  72.2%  ±2.8 acc  │  2,474 tokens
JSON compact   ████████████████░░░░   23.8 acc%/1K tok  │  69.0%  ±2.9 acc  │  2,892 tokens
YAML           ██████████████░░░░░░   20.1 acc%/1K tok  │  70.1%  ±2.9 acc  │  3,487 tokens
JSON           ███████████░░░░░░░░░   16.6 acc%/1K tok  │  71.4%  ±2.8 acc  │  4,308 tokens
XML            ██████████░░░░░░░░░░   14.4 acc%/1K tok  │  70.7%  ±2.9 acc  │  4,909 tokens

Efficiency score = (Accuracy % ÷ Tokens) × 1,000. Higher is better.

[!TIP]
TOON achieves 72.2% accuracy (vs JSON's 71.4%) while using 42.6% fewer tokens.

[!NOTE]
CSV is excluded from the ranking as it only supports 109 of 244 questions (flat tabular data only). While CSV is highly token-efficient for simple tabular data, it cannot represent nested structures that other formats handle.

Accuracy on Flat Datasets

Every format answers the same 109 flat-dataset questions per model, so CSV can be compared on equal footing here.

Format Accuracy Correct/Total Avg Tokens
toon 63.1% ±4.5 275/436 1,994
csv 62.2% ±4.5 271/436 1,851
json-pretty 60.3% ±4.6 263/436 3,950
xml 60.1% ±4.6 262/436 4,516
yaml 59.9% ±4.6 261/436 3,270
json-compact 58.0% ±4.6 253/436 2,718

Per-Model Accuracy

Accuracy across 4 LLMs on 244 data retrieval questions:

claude-haiku-4-5-20251001
→ TOON           █████████████░░░░░░░    65.6% ±5.9 (160/244)
  JSON           █████████████░░░░░░░    63.5% ±6.0 (155/244)
  XML            ████████████░░░░░░░░    62.3% ±6.0 (152/244)
  YAML           ████████████░░░░░░░░    62.3% ±6.0 (152/244)
  JSON compact   ████████████░░░░░░░░    61.9% ±6.0 (151/244)
  CSV            ██████████░░░░░░░░░░    49.5% ±9.2 (54/109)

gemini-3.6-flash
→ TOON           ██████████████░░░░░░    69.3% ±5.8 (169/244)
  JSON           ██████████████░░░░░░    68.4% ±5.8 (167/244)
  YAML           ██████████████░░░░░░    67.6% ±5.8 (165/244)
  XML            █████████████░░░░░░░    65.2% ±5.9 (159/244)
  JSON compact   █████████████░░░░░░░    63.5% ±6.0 (155/244)
  CSV            ████████████░░░░░░░░    57.8% ±9.1 (63/109)

gpt-5.4-nano
  XML            ████████████░░░░░░░░    59.4% ±6.1 (145/244)
  JSON           ███████████░░░░░░░░░    57.4% ±6.2 (140/244)
→ TOON           ███████████░░░░░░░░░    57.0% ±6.2 (139/244)
  JSON compact   ███████████░░░░░░░░░    54.9% ±6.2 (134/244)
  YAML           ███████████░░░░░░░░░    54.5% ±6.2 (133/244)
  CSV            █████████░░░░░░░░░░░    46.8% ±9.2 (51/109)

grok-4.5
→ TOON           ███████████████████░    97.1% ±2.2 (237/244)
  JSON           ███████████████████░    96.3% ±2.5 (235/244)
  XML            ███████████████████░    95.9% ±2.6 (234/244)
  YAML           ███████████████████░    95.9% ±2.6 (234/244)
  JSON compact   ███████████████████░    95.5% ±2.7 (233/244)
  CSV            ███████████████████░    94.5% ±4.5 (103/109)

[!NOTE]
Accuracy figures include Wilson 95% confidence intervals (±); when two formats' intervals overlap, the difference between them is not statistically meaningful. CSV answers only the 109 flat-dataset questions, so its per-model cells cover a smaller, easier population than the other formats.

Performance by dataset and question type

Performance by Question Type

Question Type TOON JSON XML YAML JSON compact CSV
Field Retrieval 97.8% 99.2% 99.2% 99.7% 98.9% 100.0%
Aggregation 48.4% 48.4% 46.0% 46.0% 45.2% 32.8%
Filtering 38.0% 41.1% 37.5% 40.1% 38.0% 33.3%
Structure Awareness 90.3% 84.0% 84.0% 79.2% 78.5% 82.8%
Structural Validation 100.0% 50.0% 80.0% 50.0% 45.0% 80.0%

Performance by Dataset

Uniform employee records
Format Accuracy Tokens Correct/Total
csv 64.6% 2,336 106/164
toon 62.8% 2,537 103/164
json-compact 62.2% 3,919 102/164
yaml 64.0% 4,982 105/164
json-pretty 62.2% 6,326 102/164
xml 61.0% 7,286 100/164
E-commerce orders with nested structures
Format Accuracy Tokens Correct/Total
json-compact 70.7% 6,875 116/164
toon 71.3% 7,344 117/164
yaml 72.0% 8,456 118/164
json-pretty 71.3% 10,842 117/164
xml 74.4% 12,180 122/164
Time-series analytics data
Format Accuracy Tokens Correct/Total
csv 64.2% 1,408 77/120
toon 63.3% 1,595 76/120
json-compact 59.2% 2,351 71/120
yaml 62.5% 2,951 75/120
json-pretty 65.0% 3,678 78/120
xml 62.5% 4,386 75/120
Top 100 GitHub repositories
Format Accuracy Tokens Correct/Total
toon 57.6% 9,017 76/132
csv 54.5% 8,726 72/132
json-compact 53.8% 11,650 71/132
yaml 53.8% 13,350 71/132
json-pretty 55.3% 15,350 73/132
xml 53.8% 17,304 71/132
Semi-uniform event logs
Format Accuracy Tokens Correct/Total
json-compact 56.7% 4,793 68/120
toon 60.8% 5,814 73/120
json-pretty 60.0% 6,759 72/120
yaml 55.0% 5,798 66/120
xml 50.8% 7,668 61/120
Deeply nested configuration
Format Accuracy Tokens Correct/Total
json-compact 91.4% 562 106/116
yaml 93.1% 675 108/116
toon 91.4% 669 106/116
json-pretty 94.8% 918 110/116
xml 94.0% 1,007 109/116
Valid complete dataset (control)
Format Accuracy Tokens Correct/Total
toon 100.0% 566 4/4
json-compact 100.0% 772 4/4
yaml 100.0% 984 4/4
json-pretty 100.0% 1,259 4/4
xml 0.0% 1,441 0/4
csv 0.0% 473 0/4
Array truncated: 3 rows removed from end
Format Accuracy Tokens Correct/Total
csv 100.0% 408 4/4
toon 100.0% 498 4/4
xml 100.0% 1,229 4/4
json-pretty 0.0% 1,075 0/4
yaml 0.0% 841 0/4
json-compact 0.0% 660 0/4
Extra rows added beyond declared length
Format Accuracy Tokens Correct/Total
csv 100.0% 547 4/4
toon 100.0% 644 4/4
xml 100.0% 1,663 4/4
json-pretty 0.0% 1,452 0/4
yaml 0.0% 1,135 0/4
json-compact 0.0% 893 0/4
Inconsistent field count (missing salary in row 10)
Format Accuracy Tokens Correct/Total
csv 100.0% 470 4/4
toon 100.0% 563 4/4
json-compact 75.0% 767 3/4
xml 100.0% 1,432 4/4
yaml 75.0% 977 3/4
json-pretty 75.0% 1,251 3/4
Missing required fields (no email in multiple rows)
Format Accuracy Tokens Correct/Total
csv 100.0% 442 4/4
toon 100.0% 535 4/4
xml 100.0% 1,386 4/4
yaml 75.0% 941 3/4
json-pretty 75.0% 1,207 3/4
json-compact 50.0% 732 2/4
Feature flags keyed by name
Format Accuracy Tokens Correct/Total
toon 97.1% 931 66/68
json-compact 94.1% 1,264 64/68
yaml 92.6% 1,443 63/68
json-pretty 95.6% 1,873 65/68
xml 95.6% 2,306 65/68
Contacts with nested address and plan groups
Format Accuracy Tokens Correct/Total
toon 94.4% 1,444 68/72
json-compact 91.7% 2,357 66/72
yaml 94.4% 2,797 68/72
json-pretty 97.2% 4,014 70/72
xml 98.6% 4,534 71/72

Run Configuration

  • Models tested: claude-haiku-4-5-20251001, gemini-3.6-flash, gpt-5.4-nano, grok-4.5
  • Formats compared: TOON, JSON, XML, YAML, JSON compact, CSV
  • Token counting: Using gpt-tokenizer with o200k_base encoding (GPT-5 tokenizer). Other providers tokenize differently, so absolute counts are tokenizer-specific; relative differences between formats hold directionally.
  • Reasoning: Disabled via the AI SDK's universal reasoning: 'none' (Gemini 3 floors at minimal thinking, grok-4.5 at low)
  • Temperature: Not set (models use their defaults)
  • Total evaluations: 244 questions × 6 formats × 4 models = 5,856 LLM calls

What the datasets contain, how the questions are generated, and how answers are validated is documented in the benchmark README.

Token Efficiency

Token counts are measured using the GPT-5 o200k_base tokenizer via gpt-tokenizer. Savings are calculated against formatted JSON (2-space indentation) as the primary baseline, with additional comparisons to compact JSON (minified), YAML, and XML. Actual savings vary by model and tokenizer.

The benchmarks test datasets across different structural patterns (uniform, semi-uniform, nested, deeply nested) to show where TOON excels and where other formats may be better.

Mixed-Structure Track

Datasets with nested or semi-uniform structures. CSV excluded as it cannot properly represent these structures.

🛒 E-commerce orders with nested structures  ┊  Tabular: 33%
   │
   TOON                █████████████░░░░░░░    72,832 tokens
   ├─ vs JSON          (−32.9%)               108,611 tokens
   ├─ vs JSON compact  (+5.6%)                 68,944 tokens
   ├─ vs YAML          (−14.0%)                84,701 tokens
   └─ vs XML           (−40.4%)               122,119 tokens

🧾 Semi-uniform event logs  ┊  Tabular: 50%
   │
   TOON                █████████████████░░░   154,084 tokens
   ├─ vs JSON          (−15.0%)               181,201 tokens
   ├─ vs JSON compact  (+19.9%)               128,529 tokens
   ├─ vs YAML          (−0.8%)                155,397 tokens
   └─ vs XML           (−25.2%)               205,859 tokens

🧩 Deeply nested configuration  ┊  Tabular: 0%
   │
   TOON                █████████████░░░░░░░       589 tokens
   ├─ vs JSON          (−34.9%)                   905 tokens
   ├─ vs JSON compact  (+6.7%)                    552 tokens
   ├─ vs YAML          (−11.0%)                   662 tokens
   └─ vs XML           (−40.9%)                   997 tokens

📊 Feature flags keyed by name  ┊  Tabular: 100%
   │
   TOON                █████████░░░░░░░░░░░    10,503 tokens
   ├─ vs JSON          (−54.6%)                23,141 tokens
   ├─ vs JSON compact  (−32.8%)                15,635 tokens
   ├─ vs YAML          (−41.3%)                17,905 tokens
   └─ vs XML           (−63.3%)                28,655 tokens

📊 Contacts with nested address and plan groups  ┊  Tabular: 100%
   │
   TOON                ███████░░░░░░░░░░░░░    26,726 tokens
   ├─ vs JSON          (−66.5%)                79,779 tokens
   ├─ vs JSON compact  (−42.9%)                46,791 tokens
   ├─ vs YAML          (−51.8%)                55,475 tokens
   └─ vs XML           (−70.4%)                90,306 tokens

──────────────────────────────────── Total ────────────────────────────────────
   TOON                █████████████░░░░░░░   264,734 tokens
   ├─ vs JSON          (−32.7%)               393,637 tokens
   ├─ vs JSON compact  (+1.6%)                260,451 tokens
   ├─ vs YAML          (−15.7%)               314,140 tokens
   └─ vs XML           (−40.9%)               447,936 tokens

Flat-Only Track

Datasets with flat, fully tabular-eligible data where CSV is applicable.

👥 Uniform employee records  ┊  Tabular: 100%
   │
   CSV                 ███████████████████░    47,153 tokens
   TOON                ████████████████████    49,978 tokens   (+6.0% vs CSV)
   ├─ vs JSON          (−60.7%)               127,061 tokens
   ├─ vs JSON compact  (−36.8%)                79,057 tokens
   ├─ vs YAML          (−50.0%)               100,054 tokens
   └─ vs XML           (−65.9%)               146,605 tokens

📈 Time-series analytics data  ┊  Tabular: 100%
   │
   CSV                 ██████████████████░░     8,383 tokens
   TOON                ████████████████████     9,115 tokens   (+8.7% vs CSV)
   ├─ vs JSON          (−59.0%)                22,245 tokens
   ├─ vs JSON compact  (−35.9%)                14,211 tokens
   ├─ vs YAML          (−49.0%)                17,858 tokens
   └─ vs XML           (−65.8%)                26,616 tokens

⭐ Top 100 GitHub repositories  ┊  Tabular: 100%
   │
   CSV                 ███████████████████░     8,711 tokens
   TOON                ████████████████████     8,937 tokens   (+2.6% vs CSV)
   ├─ vs JSON          (−41.7%)                15,337 tokens
   ├─ vs JSON compact  (−23.2%)                11,640 tokens
   ├─ vs YAML          (−33.0%)                13,337 tokens
   └─ vs XML           (−48.3%)                17,294 tokens

──────────────────────────────────── Total ────────────────────────────────────
   CSV                 ███████████████████░    64,247 tokens
   TOON                ████████████████████    68,030 tokens   (+5.9% vs CSV)
   ├─ vs JSON          (−58.7%)               164,643 tokens
   ├─ vs JSON compact  (−35.2%)               104,908 tokens
   ├─ vs YAML          (−48.2%)               131,249 tokens
   └─ vs XML           (−64.3%)               190,515 tokens

Token counts use gpt-tokenizer with o200k_base encoding (GPT-5 tokenizer). Other providers tokenize differently, so absolute counts are tokenizer-specific; relative differences between formats hold directionally.

Show detailed examples

📈 Time-series analytics data

Savings: 13,130 tokens (59.0% reduction vs JSON)

JSON (22,245 tokens):

{
  "metrics": [
    {
      "date": "2025-01-01",
      "views": 6138,
      "clicks": 174,
      "conversions": 12,
      "revenue": 2712.49,
      "bounceRate": 0.35
    },
    {
      "date": "2025-01-02",
      "views": 4616,
      "clicks": 274,
      "conversions": 34,
      "revenue": 9156.29,
      "bounceRate": 0.56
    },
    {
      "date": "2025-01-03",
      "views": 4460,
      "clicks": 143,
      "conversions": 8,
      "revenue": 1317.98,
      "bounceRate": 0.59
    },
    {
      "date": "2025-01-04",
      "views": 4740,
      "clicks": 125,
      "conversions": 13,
      "revenue": 2934.77,
      "bounceRate": 0.37
    },
    {
      "date": "2025-01-05",
      "views": 6428,
      "clicks": 369,
      "conversions": 19,
      "revenue": 1317.24,
      "bounceRate": 0.3
    }
  ]
}

TOON (9,115 tokens):

metrics[5]{date,views,clicks,conversions,revenue,bounceRate}:
  2025-01-01,6138,174,12,2712.49,0.35
  2025-01-02,4616,274,34,9156.29,0.56
  2025-01-03,4460,143,8,1317.98,0.59
  2025-01-04,4740,125,13,2934.77,0.37
  2025-01-05,6428,369,19,1317.24,0.3

⭐ Top 100 GitHub repositories

Savings: 6,400 tokens (41.7% reduction vs JSON)

JSON (15,337 tokens):

{
  "repositories": [
    {
      "id": 132750724,
      "name": "build-your-own-x",
      "repo": "codecrafters-io/build-your-own-x",
      "description": "Master programming by recreating your favorite technologies from scratch.",
      "createdAt": "2018-05-09T12:03:18Z",
      "updatedAt": "2026-07-23T18:57:15Z",
      "pushedAt": "2026-07-14T19:25:58Z",
      "stars": 530712,
      "watchers": 6778,
      "forks": 50205,
      "defaultBranch": "master"
    },
    {
      "id": 21737465,
      "name": "awesome",
      "repo": "sindresorhus/awesome",
      "description": "😎 Awesome lists about all kinds of interesting topics",
      "createdAt": "2014-07-11T13:42:37Z",
      "updatedAt": "2026-07-23T18:57:24Z",
      "pushedAt": "2026-06-30T18:21:16Z",
      "stars": 488074,
      "watchers": 8292,
      "forks": 36010,
      "defaultBranch": "main"
    },
    {
      "id": 28457823,
      "name": "freeCodeCamp",
      "repo": "freeCodeCamp/freeCodeCamp",
      "description": "freeCodeCamp.org's open-source codebase and curriculum. Learn math, programming,…",
      "createdAt": "2014-12-24T17:49:19Z",
      "updatedAt": "2026-07-22T07:01:33Z",
      "pushedAt": "2026-07-21T18:00:51Z",
      "stars": 452380,
      "watchers": 8590,
      "forks": 45624,
      "defaultBranch": "main"
    }
  ]
}

TOON (8,937 tokens):

repositories[3]{id,name,repo,description,createdAt,updatedAt,pushedAt,stars,watchers,forks,defaultBranch}:
  132750724,build-your-own-x,codecrafters-io/build-your-own-x,Master programming by recreating your favorite technologies from scratch.,"2018-05-09T12:03:18Z","2026-07-23T18:57:15Z","2026-07-14T19:25:58Z",530712,6778,50205,master
  21737465,awesome,sindresorhus/awesome,😎 Awesome lists about all kinds of interesting topics,"2014-07-11T13:42:37Z","2026-07-23T18:57:24Z","2026-06-30T18:21:16Z",488074,8292,36010,main
  28457823,freeCodeCamp,freeCodeCamp/freeCodeCamp,"freeCodeCamp.org's open-source codebase and curriculum. Learn math, programming,…","2014-12-24T17:49:19Z","2026-07-22T07:01:33Z","2026-07-21T18:00:51Z",452380,8590,45624,main

Installation & Quick Start

# npm
npm install @toon-format/toon

# pnpm
pnpm add @toon-format/toon

# yarn
yarn add @toon-format/toon

To keep the CLI around instead of invoking it through npx, install it globally:

npm install -g @toon-format/cli

Example usage:

import { encode } from '@toon-format/toon'

const data = {
  users: [
    { id: 1, name: 'Ada', role: 'admin' },
    { id: 2, name: 'Bob', role: 'user' }
  ]
}

console.log(encode(data))
// users[2]{id,name,role}:
//   1,Ada,admin
//   2,Bob,user

Streaming large datasets:

import { encodeLines } from '@toon-format/toon'

const largeData = await fetchThousandsOfRecords()

// Memory-efficient streaming for large data
for (const line of encodeLines(largeData)) {
  process.stdout.write(`${line}\n`)
}

[!TIP]
For streaming decode APIs, see decodeFromLines() and decodeStream().

Transforming values with replacer:

import { encode } from '@toon-format/toon'

README 内容已截断, 请前往 GitHub 查看完整内容。

]]> Tue, 15 Sep 2026 17:19:56 +0800 OTO https://cn121.com/cli/toon-format-toon.html haystack - 用于构建上下文工程 https://cn121.com/llm/deepset-ai-haystack.html

持续集成/持续交付
文档
包裹
元数据

🎉🎊✨   Haystack 3.0 已发布！   ✨🎊🎉

在这里阅读公告！

🥳 🎈 🎆 🪅 🎇 🍾 🥂 🎁 🌈

Haystack 是一个开源的 AI 编排框架，用于在 Python 中构建可投入生产的 LLM 应用。

设计模块化管道和代理工作流程，并对检索、路由、记忆和生成进行明确控制。构建可扩展的 RAG 系统、多模态应用、语义搜索、问答系统和自主代理，所有这些都在一个透明的架构中，让您可以进行实验、深度定制并自信部署。

安装

获取 Haystack 的最简单方法是通过 pip：

pip install haystack-ai

安装夜间预发布版本以尝试最新功能：

pip install --pre haystack-ai

Haystack 支持多种安装方式，包括 Docker 镜像。有关详细指南，请参阅 文档。

文档

如果你是这个项目的新手，请查看 "Haystack 是什么？"，然后浏览 "入门指南"，并在几分钟内构建你的第一个 LLM 应用程序。继续通过 教程 学习。对于更高级的使用场景，或者仅仅是为了获取一些灵感，你可以在 Cookbook 中浏览我们的 Haystack 配方。

在任何时候，点击 文档 以了解更多关于 Haystack 的信息，它能为你做什么，以及背后的技术。

功能

为生产环境构建的智能代理 通过生命周期钩子（before_llm、before_tool、on_exit 等）扩展代理行为以实现安全控制和自定义逻辑，并开箱即用地跟踪 step_count、token_usage 和工具调用，用于监控和成本控制。通过 Agent Pack 现成代理快速上手（例如，一个深度研究代理，或一个高级 RAG 代理），或者通过 SkillToolset 给你的代理渐进式技能发现，使技能描述仅在需要时进入上下文。

为上下文工程而构建 设计灵活的系统，明确控制信息在达到模型之前如何被检索、排序、过滤、组合、结构化和路由。定义管道和代理工作流，使检索、记忆、工具和生成过程透明且可追踪。

原生异步支持 一个 Pipeline 可以同步或异步运行，并逐个令牌流式处理。Agent 可以并行运行工具调用。

模块化且可定制 使用内置组件进行检索、索引、工具调用、记忆及评估，或者创建自己的组件。添加循环、分支和条件逻辑，以精确控制上下文在管道和代理工作流中的流动方式。

模型和供应商无关 与 OpenAI、Mistral、Anthropic、Cohere、Hugging Face、Google、Azure OpenAI、AWS Bedrock、本地模型及其他众多平台集成。无需重写系统即可更换模型或基础设施组件。

可扩展的生态系统 通过一致的接口构建并共享自定义组件，使社区和第三方能够轻松扩展 Haystack 并为开放生态系统做出贡献。

[!提示]

您想将 Haystack 流水线部署并作为 REST API 还是 MCP 服务器 提供服务？Hayhooks 为您提供了一种简单的方法，可以将流水线和代理与自定义逻辑结合，并通过 HTTP 端点或 MCP 进行暴露。它还支持兼容 OpenAI 的聊天完成端点，并可与 open-webui 等聊天界面一起使用。

Haystack Enterprise：支持与平台

通过 Haystack Enterprise Starter 获得 Haystack 团队的专家支持，使用企业级模板更快地构建，并通过云端和本地环境的部署指南安全地扩展。在公告文章中了解更多信息。

👉 获取 Haystack 企业入门版

需要Haystack托管生产配置吗？Haystack企业平台帮助您构建、测试、部署和运营Haystack流水线，并具备内置的可观察性、协作、治理和访问控制功能。它可作为托管云服务或自托管解决方案提供。

👉 了解更多关于 Haystack 企业平台 的信息，或 免费试用

遥测

Haystack 收集管道组件的匿名使用统计数据。每次这些组件初始化时，我们都会收到事件。这样，我们就能知道哪些组件对我们的社区最相关。

阅读更多关于 Haystack 中遥测的信息，或了解如何在 Haystack 文档 中选择退出。

🖖 社区

如果您有功能请求或错误报告，请随时在 GitHub 上提交 issue。我们会定期查看这些，因此您可以期待快速的回复。如果您想讨论某个主题或获得有关如何使 Haystack 在您的项目中发挥作用的一般建议，您可以在 GitHub Discussions 或我们的 Discord 频道 中发起一个讨论。我们也会查看 𝕏 (Twitter) 和 Stack Overflow。

为《干草堆》贡献

我们非常欢迎社区的贡献——无论是快速修正一个拼写错误，还是添加一个全新的功能！你不需要成为 Haystack 专家也能提供有意义的改进。想了解如何开始，请先查看我们的贡献者指南。

您可以通过以下几种方式为Haystack做出贡献：

[!提示]
👉 查看所有开放贡献的问题列表

使用 Haystack 的组织

Haystack 被成千上万的团队用于在各行业构建生产级 AI 系统，包括：

你也在使用 Haystack 吗？开一个 PR 或 告诉我们你的故事

]]> Tue, 15 Sep 2026 04:39:12 +0800 OTO https://cn121.com/llm/deepset-ai-haystack.html TencentDB-Agent-Memory - TencentDB Agent Memory是AI https://cn121.com/wiki/tencentcloud-tencentdb-agent-memory.html

让 Agent 沉淀经验，让人专注创造。

安装 · 支持的 Agent · 项目简介 · 团队玩法 · 技术实现 · Benchmark · Roadmap

English · 简体中文

最新： Team Memory Beta 版本正在快速迭代，简单安装就能玩。

安装

一次拉起完整三件套（memory-core + memory-hub + proxy）：

git clone https://github.com/Tencent/TencentDB-Agent-Memory.git
cd TencentDB-Agent-Memory/deploy/global-images
cp .env.example .env
$EDITOR .env       # 填入两组 LLM 参数（memory 组 + proxy 组）
./start-all.sh     # 一键起；结束会打印 claude 可直接复制的一行命令

打开 Panel：http://localhost:8125。

完整安装文档（Memory Hub 单独部署 / Proxy + Claude Code / CodeBuddy 用法 / 停止清理 / 端口 说明等）见 INSTALL_CN.md（English: INSTALL.md）。 MongoDB 存储后端为试验特性（默认关闭），见 INSTALL_CN.md · MongoDB 存储后端。

从旧版本迁移数据

如果你已经在用旧版（v1.x / v0.x），希望把存量数据迁到 v2.0.0+，我们提供了一个数据迁移工具： 用法和参数详见 数据迁移工具（v2 → v3）。全新安装可跳过。

所有 Agent 共享同一个 Memory Server

一套 Proxy，协议不变，零代码接入——把 Agent 的 base URL 指向 Proxy 即可，不需要插件、Hook 或 MCP Server。


DeepSeek Harness
Claude Code
Codex
CodeBuddy

WorkBuddy
Hermes
OpenClaw		 更多框架适配中...

各客户端具体配置步骤见 INSTALL_CN.md。

没看到你常用的 Agent？通用接入指南 可以试试自己动手适配——也欢迎直接提 PR 为它加上原生支持，参见 CONTRIBUTING_CN.md。

TencentDB Agent Memory 是什么？

我们从一个很实际的问题出发：怎样减少使用 Agent 时的重复工作？

项目背景讲过了，不该换个 Session 再讲。文档读过了，不该每个 Agent 从第一页重读。一套做法已经跑通，不该下次再摸索一遍。

所以这里的 Memory 不只是“记住对话”。凡是能让下一个 Agent 少走弯路的信息，都应该被保存、组织并复用。

已有信息 → 可复用记忆资产 → 更少 Turns → 更少返工 → 更稳定的结果和更高的效率

让经验沉淀、流动，然后被下一位 Agent 直接继承

面向 Agent 团队的 Memory Hub，让经验完成一个完整循环：工作中产生资产，资产在团队中流动，新成员进来直接读档。

  1. 自动沉淀资产：从对话和任务中生成 Chat Memory 与 Skill，把文档和代码变成 Wiki 与 CodeGraph，再统一管理、审核和路由。
  2. 可迁移、兼容多Agent：记忆资产与 Agent 框架解耦，可以跨框架迁移，也可以由 Team 内的多个 Agent、多个成员共享和维护。
  3. 冷启动友好：导入已有文档、代码库和 Agent 对话 Session，新 Agent Team 从现有经验开始工作，不必先从头学习一遍。

🧠 一个能记住人和事的大脑

  • Chat Memory 保留偏好、事实、决策和交互历史。
  • 每个 Agent 创建时自动获得独立记忆，下次对话不必从自我介绍开始。
  • L0 Conversation → L1 Atom → L2 Scenario → L3 Persona，从原始对话逐层沉淀。

“别重构旧鉴权模块，移动端还在用。”——这种代价很高的上下文，不应该靠人每次提醒。

⚡ 一个会积累经验的 Skill 库

  • Agent 做完复杂工作后，可以从对话和工具调用中提炼和管理可复用 Skill。并在需要时导入到指定Agent的上下文。
  • Skill 不只是一段 Prompt：它有版本、资源文件、触发边界、执行步骤和验证规则。
  • 个人 Skill 默认私有；审核后可分享给团队，再配装给其他 Agent。

排障、Review、上线检查——练会一次，全队可用。

📖 一张同时看懂文档和代码的知识地图

  • Wiki 把产品文档、设计方案和运维手册生成结构化页面与链接图谱。(灵感来源于 Karpathy 的 LLM 知识库)

  • CodeGraph 索引代码符号、文件、调用关系和影响路径。

  • Agent 可以搜索、阅读、查 callers / callees，也可以在改代码前先做 impact analysis。

Wiki 不让 Agent 先读完所有文件目录再开工。CodeGraph 不只告诉它“代码在这”，还告诉它“改了可能影响哪”。

🛡️ 一个由人掌握的团队记忆面板

  • 在 Memory Hub 里创建 Team 和 Agent，审核、分享并配装记忆资产。
  • 统一管理 Owner、版本、状态、可见性、使用次数与 Agent 绑定。
  • private 严格属于 Owner；team 面向全队；restricted 通过 User / Role / Agent ACL 精确授权。
  • 角色分两层：全局 System Admin 管理用户与团队（建团队、录入成员），也可使用 Wiki、CodeGraph、Skill 等资产管理功能；Team 内角色 分为 Admin（团队管理员）和 Member（普通成员），负责团队内的资产协作与权限控制。资产归属通过 Owner 标记，Owner 自动获得对应资产的管理权限。

冷启动：先读档，再开工

多数 Agent 的第一件工作，是重新学习你的项目，TencentDB Agent Memory 把你已经付过的学习成本变成存档：

具体来说，这些已有资产可以直接在面板导入和自动被处理：

  • 代码库：导入已有代码库，CodeGraph 自动索引符号、文件、调用关系与影响路径。
  • 文档与文件：导入相关文档和文件，Wiki 自动生成结构化页面与链接图谱。
  • 对话 Session：导入过去和 Agent 的对话 Session，Skill 与 Chat Memory 自动提取可复用 Skill 与记忆资产。

不再重新训练每一个 Agent。给它读档。

一种玩法：给一个人的公司组一支会成长的 Agent 队伍

打开 Memory Hub，建一个 Team：

Tiny but Serious Inc.
├── 👤 You · 定目标 / 做判断
├── 🔭 Scout · 查资料 / 找机会
├── 🛠 Builder · 写代码 / 做产品
├── 🧪 Reviewer · 测试 / 挑毛病
└── 🧠 Agent Memory · 让经验留在队伍里

你不是在开四个彼此失联的聊天窗口，而是在组一支角色不同、能够继承团队经验的 Agent 小队。

先招人，然后配装备

🔭 Scout
   ├── 用户访谈 Chat Memory
   ├── 市场研究 Wiki
   └── 竞品分析 Skill

🛠 Builder
   ├── 产品 Wiki
   ├── 项目 CodeGraph
   └── Feature Delivery Skill

🧪 Reviewer
   ├── 历史事故 Chat Memory
   ├── 项目 CodeGraph
   └── Release Checklist Skill

不同角色，不同 Loadout。少给噪音，多给它完成工作真正需要的记忆。

公司可以很小，经验可以一直复利。

记忆资产，不是聊天记录仓库

RAG 解决“能查到什么”。Team Memory 还要解决“谁可以用、哪个版本有效、应该给哪个 Agent”。

聊天历史 普通 RAG TencentDB Agent Memory
跨会话理解用户 △ △ ✅ Chat Memory
沉淀可执行经验 — — ✅ Skill
文档结构与关系 — △ 切片检索 ✅ Wiki + Link Graph
代码调用与影响范围 — △ 文本命中 ✅ CodeGraph
Owner / 版本 / 状态 — — ✅
团队分享与 Agent 配装 — — ✅
私有 / 团队 / ACL — △ ✅

Memory Hub 不是展板，是操作台

玩法 在 Hub 里做什么
组队 建立 Team，加入人和 Agent，确定共享边界
资产背包 打开、搜索、审核和管理 Chat Memory、Skill、Wiki 与 CodeGraph
Agent Loadout 给不同 Agent 绑定不同记忆，调整优先级与使用方式
Knowledge 工坊 构建 Wiki 和 CodeGraph，查看处理状态和资产信息
权限控制 在私有、团队与 ACL 授权之间切换，必要时收回共享

点开一条资产，关心的不只是“它写了什么”，还有“它从哪来、是哪个版本、分给了谁、最近是否被使用”。

给每次 Loop 加一条经验值

这里的 Memory 不负责替 Agent 跑 Loop，它负责让下一轮继承上一轮的成果：有价值的交互留在 Chat Memory，跑通的做法可以提炼为 Skill，文档和代码变化则通过 Wiki ingest 与 CodeGraph sync 更新。

没有 Memory，Loop 可能只是更快地重复。能继承记忆，每一轮才有机会比上一轮更好。

一支 Agent 团队，共享经验，不共享隐私

新 Chat Memory 和 Skill 默认私有。分享是一个明确动作，不是默认泄漏。

可见性 语义
private 只有 Owner 可读，团队管理员也不例外
team 团队成员可读，Owner / Admin 负责管理
restricted 通过 User / Role / Agent ACL 精确授权
agent 用于同团队 Agent 的定向装配

你可以把“发布 Skill”给 Release Agent，把“架构 Wiki”给所有开发 Agent，把 CodeGraph 给 Coder 和 Reviewer。

技术实现

TencentDB Agent Memory 不追求“存下所有东西”，而是解决三个问题：什么值得留下、谁可以使用、下一次怎样少拿但拿对。

1. 记忆不是平铺记录，而是逐层生长

对话首先作为 L0 保存，再由异步 Pipeline 提炼为不同粒度的记忆：

层级 保存什么 主要用途
L0 Conversation 原始对话与完整上下文 核对原话、时间和来源
L1 Atom 从对话提取的事实、偏好、约束与事件 精确召回可执行信息
L2 Scenario 围绕项目或场景组织的知识块 快速恢复一个工作场景
L3 Core / Persona 长期画像、稳定模式与高层认知 让 Agent 迅速进入用户和团队语境

生成和召回都分层：平时用 L2 / L3 快速进入语境，需要具体事实时通过 BM25、向量检索与 RRF 回到 L1 / L0。结果还会经过条数、字符预算和超时限制，避免记忆反过来占满上下文。

2. 记忆不是全局 Prompt，而是 Agent 的 Loadout

Chat Memory、Skill、Wiki 和 CodeGraph 都被统一登记为 Memory Asset。Memory Hub 通过 Fixed Binding + ACL 决定某个 Agent 能带走哪些资产：先按 Team、User、Agent 和可见性缩小权限范围，再按当前问题召回。

因此团队可以共享经验，却不必共享全部隐私；换 Agent 或换框架，也只需重新装配，不必重新训练。

3. 知识不整库注入，而是按需调用

文档被整理为可搜索、可沿链接下钻的 Wiki；代码库被索引为包含文件、符号和调用关系的 CodeGraph。Agent 先通过 /v3/tools/list 发现能力，再用 /v3/tools/call 读取相关页面、源码或影响路径。

这让文档和代码也成为记忆，但它们平时只是可用的工具，只有真正需要时才进入上下文。

Benchmark

Benchmark 无 TencentDB Agent Memory 启用后 相对提升
PersonaMem 48% 76% +59%

PersonaMem 检验Agent 能否在长期交互后正确理解和运用用户信息。

注意事项

  • Wiki 和 CodeGraph 异步构建，需要等待一定时间处理才能 ready。
  • CodeGraph 当前首先支持公开 HTTPS 仓库；私有仓库和 SSH 凭证接入仍在完善。
  • Hub 已支持人工绑定资产；全自动记忆路由仍在迭代。

相关文档

Agent Memory 还没有标准答案。Bug、文档、Benchmark、新框架适配，或者一个你觉得更好玩的 Memory Hub 用法，都欢迎。

Roadmap

当前版本 v2.0.0。下个版本（v2.0.1）的重点：零配置冷启动、更快的 Wiki 生成、用户 / 团队自定义 Prompt、Skill 导出，以及 Codex（IDE Plan 模式）接入。

👉 完整计划见 ROADMAP_CN.md（English: ROADMAP.md）。

致谢

TencentDB Agent Memory 的设计站在开源社区的肩膀上：

  • CodeGraph：我们的 CodeGraph 资产模块复用了该项目的代码。其"预索引的代码图谱"的设计，是我们该模块实现的基础。
  • Hermes Agent（Nous Research）：我们的 Skill 资产管理复用了 Hermes Agent 中部分 Skill 相关代码，并在此基础上做了进一步优化。
  • Andrej Karpathy 的 "LLM Wiki"：将文档视为由 LLM 增量维护、可持续复利的知识产物的思路，直接影响了我们 Wiki 层的构建与维护方式。

在此向以上项目的作者与贡献者致以谢意。

社区与贡献

我们欢迎一切形式的贡献——Bug 反馈、功能建议、文档勘误、Benchmark 复现、生态集成，或者一个 Pull Request 都可以。Agent 记忆这件事远未有定论，希望和大家一起把它做出来。

  • 🐞 发现 Bug 或有疑问？ 欢迎到 GitHub Issues 提交，我们会在 24 小时内响应。
  • 💡 有想法想交流？ 欢迎在 GitHub Discussions 发起讨论。
  • 🛠️ 想贡献代码？ 请先阅读 CONTRIBUTING.md。

  • 💬 想加入交流群？ 扫码加入 Agent Memory 微信社群，与早期开发者直接对话。

让团队走过的路，成为下一个 Agent 的起点.

Star 趋势

MIT © TencentDB Agent Memory Team

]]> Tue, 15 Sep 2026 04:39:06 +0800 OTO https://cn121.com/wiki/tencentcloud-tencentdb-agent-memory.html ai - TypeScript的AI工具包 https://cn121.com/llm/vercel-ai.html 人工智能 SDK

人工智能 SDK 是一个与提供商无关的 TypeScript 工具包，旨在帮助您使用流行的 UI 框架（如 Next.js、React、Svelte、Vue、Angular）以及 Node.js 等运行时构建人工智能驱动的应用程序和代理。

要了解有关如何使用人工智能 SDK 的更多信息，请查看我们的 API 参考 和 文档。

安装

您需要在本地开发机器上安装 Node.js 22 及 npm（或其他包管理器）。

npm install ai

编码代理技能

如果您使用诸如 Claude Code 或 Cursor 这样的编码代理，我们强烈建议将 AI SDK 技能添加到您的代码库中：

npx skills add vercel/ai

统一提供者架构

AI SDK 提供了一个 统一 API，可以与模型提供者进行交互，例如 OpenAI、Anthropic、Google 以及 更多。

默认情况下，AI SDK 使用 Vercel AI 网关，让您开箱即可访问所有主要提供者。只需为任何支持的模型传入模型字符串:

const result = await generateText({
  model: 'anthropic/claude-opus-4.6', // or 'openai/gpt-5.4', 'google/gemini-3-flash', etc.
  prompt: 'Hello!',
});

你也可以使用他们的 SDK 包直接连接到供应商：

npm install @ai-sdk/openai @ai-sdk/anthropic @ai-sdk/google
import { anthropic } from '@ai-sdk/anthropic';

const result = await generateText({
  model: anthropic('claude-opus-4-6'), // or openai('gpt-5.4'), google('gemini-3-flash'), etc.
  prompt: 'Hello!',
});

使用

生成文本

import { generateText } from 'ai';

const { text } = await generateText({
  model: 'openai/gpt-5.4', // use Vercel AI Gateway
  prompt: 'What is an agent?',
});

生成结构化数据

import { generateText, Output } from 'ai';
import { z } from 'zod';

const { output } = await generateText({
  model: 'openai/gpt-5.4',
  output: Output.object({
    schema: z.object({
      recipe: z.object({
        name: z.string(),
        ingredients: z.array(
          z.object({ name: z.string(), amount: z.string() }),
        ),
        steps: z.array(z.string()),
      }),
    }),
  }),
  prompt: 'Generate a lasagna recipe.',
});

代理人

import { ToolLoopAgent } from 'ai';

const sandboxAgent = new ToolLoopAgent({
  model: 'openai/gpt-5.4',
  system: 'You are an agent with access to a shell environment.',
  tools: {
    shell: openai.tools.localShell({
      execute: async ({ action }) => {
        const [cmd, ...args] = action.command;
        const sandbox = await getSandbox(); // Vercel Sandbox
        const command = await sandbox.runCommand({ cmd, args });
        return { output: await command.stdout() };
      },
    }),
  },
});

UI 集成

AI SDK UI 模块提供了一组钩子，帮助你构建聊天机器人和生成式用户界面。这些钩子与框架无关，因此可以在 Next.js、React、Svelte 和 Vue 中使用。

你需要为你的框架安装该包，例如：

npm install @ai-sdk/react

代理 @/agent/image-generation-agent.ts

import { openai } from '@ai-sdk/openai';
import { ToolLoopAgent, InferAgentUIMessage } from 'ai';

export const imageGenerationAgent = new ToolLoopAgent({
  model: 'openai/gpt-5.4',
  tools: {
    generateImage: openai.tools.imageGeneration({
      partialImages: 3,
    }),
  },
});

export type ImageGenerationAgentMessage = InferAgentUIMessage<
  typeof imageGenerationAgent
>;

路由（Next.js 应用路由器）@/app/api/chat/route.ts

import { imageGenerationAgent } from '@/agent/image-generation-agent';
import { createAgentUIStreamResponse } from 'ai';

export async function POST(req: Request) {
  const { messages } = await req.json();

  return createAgentUIStreamResponse({
    agent: imageGenerationAgent,
    messages,
  });
}

工具的 UI 组件 @/component/image-generation-view.tsx

import { openai } from '@ai-sdk/openai';
import { UIToolInvocation } from 'ai';

export default function ImageGenerationView({
  invocation,
}: {
  invocation: UIToolInvocation<ReturnType<typeof openai.tools.imageGeneration>>;
}) {
  switch (invocation.state) {
    case 'input-available':
      return <div>Generating image...</div>;
    case 'output-available':
      return ;
  }
}

页面 @/app/page.tsx

'use client';

import { ImageGenerationAgentMessage } from '@/agent/image-generation-agent';
import ImageGenerationView from '@/component/image-generation-view';
import { useChat } from '@ai-sdk/react';

export default function Page() {
  const { messages, status, sendMessage } =
    useChat<ImageGenerationAgentMessage>();

  const [input, setInput] = useState('');
  const handleSubmit = e => {
    e.preventDefault();
    sendMessage({ text: input });
    setInput('');
  };

  return (
    <div>
      {messages.map(message => (
        <div key={message.id}>
          <strong>{`${message.role}: `}</strong>
          {message.parts.map((part, index) => {
            switch (part.type) {
              case 'text':
                return <div key={index}>{part.text}</div>;
              case 'tool-generateImage':
                return <ImageGenerationView key={index} invocation={part} />;
            }
          })}
        </div>
      ))}

      <form onSubmit={handleSubmit}>
        <input
          value={input}
          onChange={e => setInput(e.target.value)}
          disabled={status !== 'ready'}
        />
      </form>
    </div>
  );
}

模板

我们已经创建了包含针对不同用例、提供商和框架的 AI SDK 集成的模板。你可以使用这些模板来开始你的 AI 驱动应用程序。

社区

AI SDK 社区可以在 Vercel 社区 上找到，你可以在这里提问、提出想法，并与其他人分享你的项目。

参与贡献

非常欢迎并高度赞赏对 AI SDK 的贡献。然而，在你直接开始之前，我们希望你先查看我们的贡献指南，以确保你参与 AI SDK 贡献时有顺畅的体验。

作者

此库由 Vercel 和 Next.js 团队成员创建，并得到 开源社区 的贡献。

]]> Tue, 15 Sep 2026 04:38:59 +0800 OTO https://cn121.com/llm/vercel-ai.html agenticSeek - 完全本地化的Manus AI https://cn121.com/llm/fosowl-agenticseek.html AgenticSeek：私有、本地的 Manus 替代方案

一个100%本地运行的 Manus AI 替代品，支持语音的 AI 助手，可自主浏览网页、编写代码、规划任务，所有数据仅保存在你的设备上。专为本地推理模型设计，完全在你的硬件上运行，确保隐私无忧，无需云端依赖。

为什么选择 AgenticSeek？

  • 🔒 完全本地 & 私有 —— 所有内容都在你的电脑上运行，无云端、无数据共享。你的文件、对话和搜索都保持私密。

  • 🌐 智能网页浏览 —— AgenticSeek 可自主浏览互联网：搜索、阅读、提取信息、填写网页表单，全程免手动。

  • 💻 自动化编程助手 —— 需要代码？它能编写、调试并运行 Python、C、Go、Java 等程序，无需监督。

  • 🧠 智能代理选择 —— 你提问，它自动判断最合适的代理来完成任务。就像有一支专家团队随时待命。

  • 📋 规划并执行复杂任务 —— 从旅行规划到复杂项目，可将大任务拆分为步骤，调用多个 AI 代理协作完成。

  • 🎙️ 语音支持 —— 干净、快速、未来感的语音与语音转文本功能，让你像科幻电影中的 AI 一样与它对话。（开发中）

演示

你能搜索 agenticSeek 项目，了解需要哪些技能，然后打开 CV_candidates.zip 并告诉我哪些最匹配该项目吗？

https://github.com/user-attachments/assets/b8ca60e9-7b3b-4533-840e-08f9ac426316

免责声明：本演示及出现的所有文件（如 CV_candidates.zip）均为虚构。我们不是公司，只寻求开源贡献者而非候选人。

🛠⚠️️ 项目正在积极开发中

🙏 本项目起初只是一个副业，没有路线图也没有资金支持。它意外地登上了 GitHub Trending。非常感谢大家的贡献、反馈与耐心。

前置条件

开始前，请确保已安装以下软件：

  • Git: 用于克隆仓库。下载 Git
  • Python 3.10.x: 强烈推荐使用 Python 3.10.x 版本。使用其他版本可能导致依赖错误。下载 Python 3.10（选择 3.10.x 版本）。
  • Docker Engine & Docker Compose: 用于运行捆绑服务如 SearxNG。
    • 安装 Docker Desktop（包含 Docker Compose V2）：Windows | Mac | Linux
    • 或者在 Linux 上分别安装 Docker Engine 和 Docker Compose：Docker Engine | Docker Compose（确保安装 Compose V2，例如 sudo apt-get install docker-compose-plugin）。

1. 克隆仓库并设置

git clone https://github.com/Fosowl/agenticSeek.git
cd agenticSeek
mv .env.example .env

2. 修改 .env 文件内容

SEARXNG_BASE_URL="http://searxng:8080" # 取值取决于后端在哪里运行 — 参见下方的 SEARXNG 说明
SEARXNG_PORT=8080
REDIS_BASE_URL="redis://redis:6379/0"
WORK_DIR="/Users/mlg/Documents/workspace_for_ai"
OLLAMA_PORT="11434"
LM_STUDIO_PORT="1234"
CUSTOM_ADDITIONAL_LLM_PORT="11435"
OPENAI_API_KEY='optional'
DEEPSEEK_API_KEY='optional'
OPENROUTER_API_KEY='optional'
TOGETHER_API_KEY='optional'
GOOGLE_API_KEY='optional'
ANTHROPIC_API_KEY='optional'

根据需要更新 .env 文件：

  • SEARXNG_PORT: Docker 将 SearXNG 发布到主机上的端口。如果您机器上的端口 8080 已被占用，请设置为其他端口（例如 8001）。在 Docker 内部，容器始终监听 8080 — 该变量永远不会改变这一点。
  • SEARXNG_BASE_URL: 后端用来访问 SearXNG 的地址。它在 .env 中设置（而不是在 config.ini 中），并且只取决于后端在哪里运行：
AgenticSeek 的运行方式 SEARXNG_BASE_URL
Web 界面 — 后端在 Docker 中（./start_services.sh full） http://searxng:8080 — 始终是端口 8080，即使您修改了 SEARXNG_PORT
CLI 模式 — 后端在主机上（uv run cli.py） http://localhost:8080 — 如果您修改了 SEARXNG_PORT，请改用该端口（例如 http://localhost:8001）。http://searxng:... 在这里不可用：该主机名只存在于 Docker 内部

要在浏览器中检查 SearXNG，请始终使用主机端口：http://localhost:<SEARXNG_PORT>。修改 .env 后请重启后端 — 该文件只在进程启动时读取。

  • REDIS_BASE_URL: 保持不变
  • WORK_DIR: 本地工作目录路径。AgenticSeek 可读取和操作这些文件。
  • OLLAMA_PORT: Ollama 服务端口号。
  • LM_STUDIO_PORT: LM Studio 服务端口号。
  • CUSTOM_ADDITIONAL_LLM_PORT: 任何额外自定义 LLM 服务的端口。

API 密钥对于选择本地运行 LLM 的用户完全可选，这也是本项目的主要目的。如果硬件足够，请留空。

3. 启动 Docker

确保 Docker 已安装并在系统上运行。可以使用以下命令启动 Docker：

  • Linux/macOS:
    打开终端运行：

    sudo systemctl start docker

    或者如果已安装，从应用程序菜单启动 Docker Desktop。

  • Windows:
    从开始菜单启动 Docker Desktop。

可以通过执行以下命令验证 Docker 是否运行：

docker info

如果看到 Docker 安装信息，则表示运行正常。

请参阅下面的本地提供商列表了解摘要。

下一步：本地运行 AgenticSeek

如果遇到问题，请参阅故障排除部分。 如果硬件无法本地运行 LLM，请参阅使用 API 运行设置。 有关详细 config.ini 说明，请参阅配置部分。

在您的机器上本地运行 LLM 的设置

硬件要求：

要本地运行 LLM，您需要足够的硬件。至少需要能够运行 Magistral、Qwen 或 Deepseek 14B 的 GPU。有关详细的模型/性能建议，请参阅 FAQ。

设置您的本地提供商

启动您的本地提供商，例如使用 ollama：

ollama serve

请参阅下面的本地支持提供商列表。

更新 config.ini

更改 config.ini 文件，将 provider_name 设置为支持的提供商，provider_model 设置为您的提供商支持的 LLM。我们推荐推理模型，如 Magistral 或 Deepseek。

有关所需硬件，请参阅 README 末尾的 FAQ。

[MAIN]
is_local = True # 无论您是本地运行还是使用远程提供商。
provider_name = ollama # 或 lm-studio、openai 等。
provider_model = deepseek-r1:14b # 选择适合您硬件的模型
provider_server_address = 127.0.0.1:11434
agent_name = Jarvis # 您的 AI 名称
recover_last_session = True # 是否恢复上一个会话
save_session = True # 是否记住当前会话
speak = False # 文本转语音
listen = False # 语音转文本，仅限 CLI，实验性
jarvis_personality = False # 是否使用更"Jarvis"风格的性格（实验性）
languages = en zh # 语言列表，文本转语音将默认使用列表中的第一种语言
[BROWSER]
headless_browser = True # 除非在主机上使用 CLI，否则保持不变。
stealth_mode = True # 使用不可检测的 selenium 减少浏览器检测

警告：

  • config.ini 文件格式不支持注释。 不要直接复制粘贴示例配置，因为注释会导致错误。相反，手动修改 config.ini 文件，使用您所需的设置，排除任何注释。

  • 如果使用 LM-studio 运行 LLM，请不要将 provider_name 设置为 openai。将其设置为 lm-studio。

  • 某些提供商（例如：lm-studio）要求您在 IP 前加上 http://。例如 http://127.0.0.1:1234

本地提供商列表

提供商 本地？ 描述
ollama 是 使用 ollama 作为 LLM 提供商轻松本地运行 LLM
lm-studio 是 使用 LM studio 本地运行 LLM（将 provider_name 设置为 lm-studio）
openai 是 使用 openai 兼容 API（例如：llama.cpp 服务器）

下一步：启动服务并运行 AgenticSeek

如果遇到问题，请参阅故障排除部分。 如果硬件无法本地运行 LLM，请参阅使用 API 运行设置。 有关详细 config.ini 说明，请参阅配置部分。

使用 API 运行设置

此设置使用外部、基于云的 LLM 提供商。您需要从所选服务获取 API 密钥。

1. 选择 API 提供商并获取 API 密钥：

请参阅下面的API 提供商列表。访问他们的网站注册并获取 API 密钥。

2. 将您的 API 密钥设置为环境变量：

  • Linux/macOS:
    打开终端并使用 export 命令。最好将其添加到 shell 的配置文件中（例如 ~/.bashrc、~/.zshrc）以保持持久性。 
    export PROVIDER_API_KEY="your_api_key_here" 
# 将 PROVIDER_API_KEY 替换为特定的变量名，例如 OPENAI_API_KEY、GOOGLE_API_KEY

    TogetherAI 示例：

    export TOGETHER_API_KEY="xxxxxxxxxxxxxxxxxxxxxx"

  • Windows:

    • 命令提示符（当前会话临时）： 
      set PROVIDER_API_KEY=your_api_key_here
    • PowerShell（当前会话临时）： 
      $env:PROVIDER_API_KEY="your_api_key_here"
    • 永久性： 在 Windows 搜索栏中搜索"环境变量"，点击"编辑系统环境变量"，然后点击"环境变量..."按钮。添加一个新的用户变量，使用适当的名称（例如 OPENAI_API_KEY）和您的密钥作为值。

    (有关更多详细信息，请参阅 FAQ：如何设置 API 密钥？)。

3. 更新 config.ini：

[MAIN]
is_local = False
provider_name = openai # 或 google、deepseek、togetherAI、huggingface
provider_model = gpt-3.5-turbo # 或 gemini-1.5-flash、deepseek-chat、mistralai/Mixtral-8x7B-Instruct-v0.1 等。
provider_server_address = # 当 is_local = False 时，对于大多数 API 通常被忽略或可以留空
# ... 其他设置 ...

警告： 确保 config.ini 值中没有尾随空格。

API 提供商列表

提供商 provider_name 本地？ 描述 API 密钥链接（示例）
OpenAI openai 否 通过 OpenAI 的 API 使用 ChatGPT 模型。 platform.openai.com/signup
Google Gemini google 否 通过 Google AI Studio 使用 Google Gemini 模型。 aistudio.google.com/keys
Deepseek deepseek 否 通过他们的 API 使用 Deepseek 模型。 platform.deepseek.com
Hugging Face huggingface 否 使用 Hugging Face Inference API 中的模型。 huggingface.co/settings/tokens
TogetherAI togetherAI 否 通过 TogetherAI API 使用各种开源模型。 api.together.ai/settings/api-keys
OpenRouter openrouter No 通过 OpenRouter 使用各种开源模型 https://openrouter.ai/
MiniMax minimax 否 使用 MiniMax 模型（如 MiniMax-M3、MiniMax-M2.7）。 platform.minimax.io

注意：

  • 我们不建议将 gpt-4o 或其他 OpenAI 模型用于复杂的网页浏览和任务规划，因为当前的提示优化针对 Deepseek 等模型。
  • 编码/bash 任务可能会遇到 Gemini 的问题，因为它可能不严格遵循针对 Deepseek 优化的格式化提示。
  • 当 is_local = False 时，config.ini 中的 provider_server_address 通常不使用，因为 API 端点通常在相应提供商的库中硬编码。

下一步：启动服务并运行 AgenticSeek

如果遇到问题，请参阅已知问题部分

有关详细配置文件说明，请参阅配置部分。

启动服务并运行

默认情况下，AgenticSeek 完全在 Docker 中运行。

选项 1: 在 Docker 中运行，使用 Web 界面：

启动所需服务。这将启动 docker-compose.yml 中的所有服务，包括：

  • searxng
  • redis（searxng 所需）
  • frontend
  • backend（如果使用 Web 界面时使用 full）
./start_services.sh full # MacOS
start start_services.cmd full # Windows

警告： 此步骤将下载并加载所有 Docker 镜像，可能需要长达 30 分钟。启动服务后，请等待后端服务完全运行（您应该在日志中看到 backend: "GET /health HTTP/1.1" 200 OK）后再发送任何消息。首次运行时，后端服务可能需要 5 分钟才能启动。

转到 http://localhost:3000/，您应该会看到 Web 界面。

服务启动故障排除： 如果这些脚本失败，请确保 Docker Engine 正在运行并且 Docker Compose（V2，docker compose）已正确安装。检查终端输出中的错误消息。请参阅 FAQ：帮助！运行 AgenticSeek 或其脚本时出现错误。

选项 2: CLI 模式：

要使用 CLI 界面运行，您必须在主机上安装软件包：

./install.sh
./install.bat # windows

然后您必须将 .env 文件（不是 config.ini）中的 SEARXNG_BASE_URL 更改为主机映射地址，因为在 CLI 模式下后端运行在您的机器上、Docker 之外：

SEARXNG_BASE_URL="http://localhost:8080"

如果您在 .env 中修改了 SEARXNG_PORT，请在这里改用该端口（例如 http://localhost:8001）。编辑 .env 后请重启 cli.py — 该值在启动时读取。

启动所需服务。这将启动 docker-compose.yml 中的一些服务，包括：

  • searxng
  • redis（searxng 所需）
  • frontend
./start_services.sh # MacOS
start start_services.cmd # Windows

运行：uv run: uv run python -m ensurepip 以确保 uv 已启用 pip。

使用 CLI：uv run cli.py

使用方法

确保服务已通过 ./start_services.sh full 启动并运行，然后转到 localhost:3000 使用 Web 界面。

您也可以通过设置 listen = True 来使用语音转文本。仅限 CLI 模式。

要退出，只需说/输入 goodbye。

以下是一些使用示例：

用 python 写一个贪吃蛇游戏！

搜索法国雷恩的最佳咖啡馆，并将三家及其地址保存到 rennes_cafes.txt。

写一个 Go 程序计算阶乘，保存为 factorial.go 到你的工作区

在 summer_pictures 文件夹中查找所有 JPG 文件，用今天日期重命名，并将重命名文件列表保存到 photos_list.txt

在线搜索 2024 年热门科幻电影，挑选三部今晚观看，保存到 movie_night.txt。

搜索 2025 年最新 AI 新闻文章，选三篇，写 Python 脚本抓取标题和摘要，脚本保存为 news_scraper.py，摘要保存到 ai_news.txt（/home/projects）

周五，搜索免费股票价格 API，用 supersuper7434567@gmail.com 注册，然后写 Python 脚本每日获取特斯拉股价，结果保存到 stock_prices.csv

请注意，表单填写功能仍为实验性，可能失败。

输入查询后，AgenticSeek 将分配最佳代理执行任务。

由于这是早期原型，代理路由系统可能无法总是根据您的查询分配正确的代理。

因此，您应该非常明确地表达您想要什么以及 AI 可能如何进行，例如如果您希望它进行网页搜索，不要说：

你知道哪些适合独自旅行的国家吗？

而应说：

进行网页搜索，找出最适合独自旅行的国家

在自己的服务器上运行 LLM 的设置

如果您有功能强大的计算机或可以使用的服务器，但想从笔记本电脑使用它，您可以选择使用我们的自定义 llm 服务器在远程服务器上运行 LLM。

在将运行 AI 模型的"服务器"上，获取 IP 地址

ip a | grep "inet " | grep -v 127.0.0.1 | awk '{print $2}' | cut -d/ -f1 # 本地 IP
curl https://ipinfo.io/ip # 公共 IP

注意：对于 Windows 或 macOS，分别使用 ipconfig 或 ifconfig 查找 IP 地址。

克隆仓库并进入 server/ 文件夹。

git clone --depth 1 https://github.com/Fosowl/agenticSeek.git
cd agenticSeek/llm_server/

安装服务器特定要求：

pip3 install -r requirements.txt

运行服务器脚本。

python3 app.py --provider ollama --port 3333

您可以选择使用 ollama 和 llamacpp 作为 LLM 服务。

现在在您的个人计算机上：

更改 config.ini 文件，将 provider_name 设置为 server，provider_model 设置为 deepseek-r1:xxb。 将 provider_server_address 设置为将运行模型的机器的 IP 地址。

[MAIN]
is_local = False
provider_name = server
provider_model = deepseek-r1:70b
provider_server_address = http://x.x.x.x:3333

下一步：启动服务并运行 AgenticSeek

语音转文本

警告：目前语音转文本仅适用于 CLI 模式。

请注意，目前语音转文本仅适用于英语。

语音转文本功能默认禁用。要启用它，请在 config.ini 文件中将 listen 选项设置为 True：

listen = True

启用后，语音转文本功能会监听触发关键字，即代理的名称，然后开始处理您的输入。您可以通过更新 config.ini 文件中的 agent_name 值来自定义代理的名称：

agent_name = Friday

为了获得最佳识别效果，我们建议使用常见的英文名称，如 "John" 或 "Emma" 作为代理名称。

一旦您看到转录开始出现，请大声说出代理的名称以唤醒它（例如，"Friday"）。

清晰地说出您的查询。

用确认短语结束您的请求，以指示系统继续。确认短语的示例包括：

"do it", "go ahead", "execute", "run", "start", "thanks", "would ya", "please", "okay?", "proceed", "continue", "go on", "do that", "go it", "do you understand?"

配置

配置示例：

[MAIN]
is_local = True
provider_name = ollama
provider_model = deepseek-r1:32b
provider_server_address = http://127.0.0.1:11434 # Ollama 示例；LM-Studio 使用 http://127.0.0.1:1234
agent_name = Friday
recover_last_session = False
save_session = False
speak = False
listen = False

jarvis_personality = False
languages = en zh # TTS 和潜在路由的语言列表。
[BROWSER]
headless_browser = False
stealth_mode = False

config.ini 设置说明：

  • [MAIN] 部分：
    • is_local: 如果使用本地 LLM 提供商（Ollama、LM-Studio、本地 OpenAI 兼容服务器）或自托管服务器选项，则为 True。如果使用基于云的 API（OpenAI、Google 等），则为 False。
    • provider_name: 指定 LLM 提供商。
      • 本地选项：ollama、lm-studio、openai（用于本地 OpenAI 兼容服务器）、server（用于自托管服务器设置）。
      • API 选项：openai、google、deepseek、huggingface、togetherAI。
    • provider_model: 所选提供商的特定模型名称或 ID（例如，Ollama 的 deepseekcoder:6.7b，OpenAI API 的 gpt-3.5-turbo，TogetherAI 的 mistralai/Mixtral-8x7B-Instruct-v0.1）。
    • provider_server_address: 您的 LLM 提供商的地址。
      • 对于本地提供商：例如，Ollama 的 http://127.0.0.1:11434，LM-Studio 的 http://127.0.0.1:1234。
      • 对于 server 提供商类型：您的自托管 LLM 服务器的地址（例如 http://your_server_ip:3333）。
      • 对于云 API（is_local = False）：这通常被忽略或可以留空，因为 API 端点通常由客户端库处理。
    • agent_name: AI 助手的名称（例如 Friday）。如果启用，用作语音转文本的触发词。
    • recover_last_session: True 尝试恢复上一个会话的状态，False 重新开始。
    • save_session: True 保存当前会话的状态以供潜在恢复，False 否则。
    • speak: True 启用文本转语音语音输出，False 禁用。
    • listen: True 启用语音转文本语音输入（仅限 CLI 模式），False 禁用。
    • work_dir: 关键： AgenticSeek 将读取/写入文件的目录。确保此路径在您的系统上有效且可访问。
    • jarvis_personality: True 使用更"Jarvis-like"的系统提示（实验性），False 使用标准提示。
    • languages: 逗号分隔的语言列表（例如 en, zh, fr）。用于 TTS 语音选择（默认为第一个），并可以协助 LLM 路由器。为避免路由器效率低下，避免使用过多或非常相似的语言。
  • [BROWSER] 部分：
    • headless_browser: True 在没有可见窗口的情况下运行自动化浏览器（推荐用于 Web 界面或非交互式使用）。False 显示浏览器窗口（对于 CLI 模式或调试有用）。
    • stealth_mode: True 启用使浏览器自动化更难检测的措施。可能需要手动安装浏览器扩展，如 anticaptcha。

本节总结了支持的 LLM 提供商类型。在 config.ini 中配置它们。

本地提供商（在您自己的硬件上运行）：

config.ini 中的提供商名称 is_local 描述 设置部分
ollama True 使用 Ollama 轻松提供本地 LLM。 在您的机器上本地运行 LLM 的设置
lm-studio True 使用 LM-Studio 提供本地 LLM。 在您的机器上本地运行 LLM 的设置
openai（用于本地服务器） True 连接到暴露 OpenAI 兼容 API 的本地服务器（例如，llama.cpp）。 在您的机器上本地运行 LLM 的设置
server False 连接到在另一台机器上运行的 AgenticSeek 自托管 LLM 服务器。 在自己的服务器上运行 LLM 的设置

API 提供商（基于云）：

config.ini 中的提供商名称 is_local 描述 设置部分
openai False 使用 OpenAI 的官方 API（例如，GPT-3.5、GPT-4）。 使用 API 运行设置
google False 通过 API 使用 Google 的 Gemini 模型。 使用 API 运行设置
deepseek False 使用 Deepseek 的官方 API。 使用 API 运行设置
huggingface False 使用 Hugging Face Inference API。 使用 API 运行设置
togetherAI False 使用 TogetherAI 的 API 获取各种开放模型。 使用 API 运行设置

故障排除

如果遇到问题，本节提供指导。

已知问题

ChromeDriver 问题

错误示例： SessionNotCreatedException: Message: session not created: This version of ChromeDriver only supports Chrome version XXX

根本原因

ChromeDriver 版本不兼容发生在：

  1. 您安装的 ChromeDriver 版本与 Chrome 浏览器版本不匹配
  2. 在 Docker 环境中，undetected_chromedriver 可能会下载自己的 ChromeDriver 版本，绕过挂载的二进制文件

解决步骤

1. 检查您的 Chrome 版本

打开 Google Chrome → 设置 > 关于 Chrome 查找您的版本（例如，"版本 134.0.6998.88"）

2. 下载匹配的 ChromeDriver

对于 Chrome 115 及更新版本： 使用 Chrome for Testing API

  • 访问 Chrome for Testing 可用性仪表板
  • 找到您的 Chrome 版本或最接近的可用匹配
  • 为您的操作系统下载 ChromeDriver（Docker 环境使用 Linux64）

对于旧版 Chrome： 使用 旧版 ChromeDriver 下载

3. 安装 ChromeDriver（选择一种方法）

方法 A：项目根目录（Docker 推荐）

# 将下载的 chromedriver 二进制文件放在项目根目录
cp path/to/downloaded/chromedriver ./chromedriver
chmod +x ./chromedriver  # 在 Linux/macOS 上使其可执行

方法 B：系统 PATH

# Linux/macOS
sudo mv chromedriver /usr/local/bin/
sudo chmod +x /usr/local/bin/chromedriver

# Windows：将 chromedriver.exe 放在 PATH 中的文件夹中

4. 验证安装

# 测试 ChromeDriver 版本
./chromedriver --version
# 或者在 PATH 中：
chromedriver --version

Docker 特定说明

⚠️ Docker 用户重要：

  • Docker 卷挂载方法可能不适用于隐身模式（undetected_chromedriver）
  • 解决方案： 将 ChromeDriver 放在项目根目录中作为 ./chromedriver
  • 应用程序将自动检测并使用此二进制文件
  • 您应该在日志中看到："Using ChromeDriver from project root: ./chromedriver"

故障排除提示

  1. 仍然遇到版本不匹配？

    • 验证 ChromeDriver 是否可执行：ls -la ./chromedriver
    • 检查 ChromeDriver 版本：./chromedriver --version
    • 确保它与您的 Chrome 浏览器版本匹配

  2. Docker 容器问题？

    • 检查后端日志：docker logs backend
    • 查找消息："Using ChromeDriver from project root"
    • 如果未找到，请验证文件是否存在且可执行

  3. Chrome for Testing 版本

    • 尽可能使用完全匹配的版本
    • 对于版本 134.0.6998.88，使用 ChromeDriver 134.0.6998.165（最接近的可用版本）
    • 主要版本号必须匹配（134 = 134）

版本兼容性矩阵

Chrome 版本 ChromeDriver 版本 状态
134.0.6998.x 134.0.6998.165 ✅ 可用
133.0.6943.x 133.0.6943.141 ✅ 可用
132.0.6834.x 132.0.6834.159 ✅ 可用

有关最新兼容性，请查看 Chrome for Testing 仪表板

Exception: Failed to initialize browser: Message: session not created: This version of ChromeDriver only supports Chrome version 113 Current browser version is 134.0.6998.89 with binary path

如果您的浏览器和 chromedriver 版本不匹配，会发生这种情况。

您需要导航到下载最新版本：

https://developer.chrome.com/docs/chromedriver/downloads

如果您使用 Chrome 版本 115 或更新版本，请转到：

https://googlechromelabs.github.io/chrome-for-testing/

并下载与您的操作系统匹配的 chromedriver 版本。

如果此部分不完整，请提出问题。

连接适配器问题

Exception: Provider lm-studio failed: HTTP request failed: No connection adapters were found for '127.0.0.1:1234/v1/chat/completions'`（注意：端口可能不同）
  • 原因： config.ini 中 lm-studio（或其他类似的本地 OpenAI 兼容服务器）的 provider_server_address 缺少 http:// 前缀或指向错误的端口。
  • 解决方案：
    • 确保地址包含 http://。LM-Studio 通常默认为 http://127.0.0.1:1234。
    • 正确的 config.ini：provider_server_address = http://127.0.0.1:1234（或您的实际 LM-Studio 服务器端口）。

SearxNG 基本 URL 未提供

raise ValueError("SearxNG base URL must be provided either as an argument or via the SEARXNG_BASE_URL environment variable.")
ValueError: SearxNG base U

README 内容已截断, 请前往 GitHub 查看完整内容。

]]> Tue, 15 Sep 2026 04:38:53 +0800 OTO https://cn121.com/llm/fosowl-agenticseek.html qwen-code - 位于您终端的开源AI编码代理 https://cn121.com/cli/qwenlm-qwen-code.html

适用于您的终端、编辑器、桌面、浏览器和聊天的开源 AI 编码代理。

为什么选择 Qwen Code？

  • 开箱即用的智能代理 — 自动记忆、自动技能、子代理、代理团队和 MCP。动态工作流，无需设置。
  • 开源，内外兼顾 — 框架和 Qwen 模型都是开源的。它们共同进化。无供应商锁定。
  • 多协议 — 支持 OpenAI、Anthropic、Gemini 和 Qwen API。任何第三方提供者或本地模型（Ollama / vLLM）。运行时切换。
  • 超越终端 — IDE 插件、桌面应用、网页界面、SDK 和聊天集成（Telegram / 钉钉 / 微信 / 飞书）。

[!提示]
Qwen Code 正在主动自我迭代 — 使用自身的代理和模型提交问题、提交 PR、审查代码并运行测试。由社区驱动，由 AI 推动。

安装

Linux / macOS：

curl -fsSL https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh | bash

Windows：

irm https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.ps1 | iex

安装后请重启终端以确保环境变量生效。

NPM / Homebrew

NPM（需要 Node.js 22）：

npm install -g @qwen-code/qwen-code@latest

Homebrew（macOS / Linux）：

酿造安装 qwen-code

快速开始

在您的项目中打开终端并启动 Qwen 代码：

cd /path/to/your-project
qwen

在会话中，运行 /auth 来配置您的提供者和 API 密钥。然后尝试：

Explain this repository and show me where to start.

请参阅认证指南和设置参考了解详细设置。

查看终端界面

如何使用 Qwen 代码

选择适合您工作流程的界面：

界面 入门指南
终端 在你的项目中运行 qwen — 参见 快速开始。
桌面 下载 Qwen Code Desktop，适用于 macOS、Windows 和 Linux。
网页 运行 qwen serve --open 在浏览器中打开 Web UI。(实验性)
编辑器 设置 VS Code、Zed 或 JetBrains。
聊天 连接 Telegram、钉钉、微信 或 飞书，然后运行 qwen channel start。

用于自动化和自定义集成：

  • 无头模式 — 在脚本、CI/CD 或批处理任务中运行 qwen -p "..."。
  • SDK — 使用 TypeScript、Python 或 Java 构建。
  • 守护进程 — 运行 qwen serve 通过 HTTP SSE (ACP) 连接客户端。(实验性) 守护进程指南。
SDK 示例（Python）
import asyncio

从 qwen_code_sdk 导入 is_sdk_result_message, query

async def main() -> None:
    result = query(
        "Summarize the repository layout.",
        {
            "cwd": "/path/to/project",
            "path_to_qwen_executable": "qwen",
        },
    )

    异步地对结果中的消息进行遍历:
        if is_sdk_result_message(message):
            print(message["result"])

asyncio.run(main())

功能

如果你熟悉Claude Code，你也已经了解Qwen Code——而且更进一步。我们投入了大量精力使Qwen Code与Claude Code功能达到一致，在各方面提升了其广度和可靠性。

功能 Qwen 代码 Claude 代码
子代理, 代理团队, 动态工作流 ✓ ✓
自动记忆, 自动技能, 钩子 ✓ ✓
内置技能 (/review, /batch, /loop, /bugfix…) ✓ ✓
MCP, 计划模式, LSP 集成 ✓ ✓
自动模式, 沙盒, Git 工作树 ✓ ✓
计算机使用 (桌面自动化) ✓ ✓
IDE 插件 (VS Code / JetBrains / Zed) ✓ ✓
SDK ✓ ✓
无界面模式, 会话管理 ✓ ✓
开源 — 模型和框架 ✓ —
多协议 (OpenAI / Anthropic / Gemini / Qwen 任意提供者) ✓ —
代理竞技场 (同一任务的多模型对决) ✓ —
守护进程模式 — qwen serve (多客户端共享代理) ✓ —
即时消息渠道 (Telegram / 钉钉 / 微信 / 飞书) ✓ —

Qwen 代码评估

评估配置

配置 值
数据集 princeton-nlp/SWE-bench_Verified，500 个案例
运行 每个版本 3 次试验，每个版本 1,500 个任务；7 个 Qwen Code 版本
模型 Qwen 3.7 Max
采样 temperature=1，top_p=0.95
思考 / 推理 interleaved_thinking=true，thinking_type=adaptive，reasoning_effort=high
上下文 / 输出限制 context_1m=true，model_context_length=1,000,000，max_tokens=64,000，model_max_tokens=65,535
执行限制 max_iterations=500，runtime_timeout_sec=7,200，agent_timeout_multiplier=3.0

按 Qwen Code 版本评分

版本 平均分 通过率 pass@3 pass^3
0.0.14 77.80% 84.6% 84.6% 69.2%
0.1.0 76.73% 84.6% 84.6% 68.0%
0.5.0 76.60% 83.0% 83.0% 68.4%
0.10.0 76.47% 84.4% 84.4% 67.4%
0.15.0 77.67% 84.6% 84.6% 68.6%
0.19.0 76.40% 85.0% 85.0% 65.8%
0.22.0 77.33% 84.4% 84.4% 68.0%

平均分趋势

生态系统

  • Qwen Code 桌面版 — 官方 macOS、Windows 和 Linux 桌面应用

  • AionUi — 面向命令行 AI 工具（包括 Qwen Code）的现代图形界面

  • Gemini CLI 桌面版 — Qwen Code 的跨平台桌面/网页/移动端 UI

  • 🦞 Qwen Code Claw — 让其他代理（Claude、Codex 等）通过 ACP 将编码任务委派给 Qwen Code。将此提示粘贴到你的代理中:

Use Qwen Code as a coding agent. First, fetch and read this skill reference:
https://raw.githubusercontent.com/QwenLM/qwen-code/refs/heads/main/.qwen/skills/qwen-code-claw/SKILL.md
Then follow the instructions inside to install, authenticate, and use Qwen Code via acpx for all coding tasks.
  • 阿里云模型工作室 CLI — 阿里云 AI 平台的官方命令行工具（bailian-cli）。扩展了 Qwen Code，支持图像/视频生成、知识检索、应用编排和模型部署。

贡献

欢迎贡献！请参阅 CONTRIBUTING.md 获取指南。

致谢

本项目最初基于 Google Gemini CLI v0.8.2。我们衷心感谢 Gemini CLI 团队的出色工作。从 Qwen Code v0.1 开始，我们停止与上游同步，并开始独立开发，作为一个多协议、多平台的代理框架，并与 Qwen 模型及其他功能实现深度集成。

]]> Tue, 15 Sep 2026 04:38:46 +0800 OTO https://cn121.com/cli/qwenlm-qwen-code.html