Raymin の乌托邦

你好，世界

Sat, 30 May 2026 00:00:00 GMT

欢迎来到 Raymin の乌托邦！

这是我的第一篇博客文章。在这里，我会记录技术、生活与思考。

关于这个博客#

这个博客基于 Firefly 主题搭建，使用 Astro 框架，速度快、颜值高。

接下来的计划#

分享技术笔记
记录学习过程
写一些生活感悟

感谢你的访问！

100 个 Agent Skills 盘点（一）：代码审查与质量守护

Fri, 19 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第一篇。在这个系列中，我们从 GitHub 上热门的 MCP 生态、LangChain 工具链、Claude Code 社区等源头出发，精选了 100 个对 AI Agent 最有价值的技能，分 10 篇逐一拆解。

本篇主题：代码审查与质量守护 —— 让 Agent 具备”代码质检员”的能力。

为什么 Agent 需要代码审查能力？#

一个真正有用的编程 Agent，不能只会”写代码”，还必须能”审代码”。代码审查能力决定了 Agent 输出的下限——写得再快，如果质量不过关，都是零。

以下 10 个 Skills 覆盖了代码质量的完整链路：静态分析 → 格式化 → 测试 → 安全扫描 → 覆盖率 → 综合审查。

1. ESLint / Biome Lint 🔍#

类别： 静态分析 适用语言： JavaScript / TypeScript

Lint 是代码质量的第一道防线。Agent 可以通过 MCP 调用 ESLint 或 Biome，自动发现代码中的潜在问题。

能力说明：

检测未使用的变量、错误的比较运算符、潜在的类型错误
支持自定义规则和 preset（如 @typescript-eslint、eslint-config-airbnb）
Biome 作为新一代工具，速度比 ESLint 快 10-100 倍

Agent 使用场景：

1
// Agent 调用 ESLint 检查代码
2
const { ESLint } = require("eslint");
3
const eslint = new ESLint();
4
const results = await eslint.lintText(codeString);
5
const formatter = await eslint.loadFormatter("stylish");
6
console.log(formatter.format(results));

典型指令：

1
请用 ESLint 检查这段代码，修复所有 error 级别的问题，
2
warning 级别的列出但不自动修复。

特性	ESLint	Biome
速度	中等	极快
生态	极丰富	快速成长
配置复杂度	较高	极低
支持语言	JS/TS	JS/TS/JSON/CSS

2. Prettier 代码格式化 ✨#

类别： 代码格式化 适用语言： 多语言支持

代码格式不统一是团队协作的噩梦。Prettier 用”有主见”的方式统一格式，消除争论。

能力说明：

自动格式化缩进、引号、分号、换行等
支持 JS/TS/CSS/HTML/Markdown/JSON/YAML 等
与 ESLint 配合使用（ESLint 管逻辑，Prettier 管格式）

Agent 使用场景：

Terminal window

1
# Agent 批量格式化项目文件
2
npx prettier --write "src/**/*.{ts,tsx,css,md}"
3
npx prettier --check "src/**/*.ts"  # 仅检查不修改

典型指令：

1
请用 Prettier 格式化 src/ 目录下所有 TypeScript 文件，
2
然后运行 --check 确认没有遗漏。

💡 最佳实践： Agent 在提交代码前自动运行 prettier --check，确保格式一致性。

3. TypeScript 类型检查 🏷️#

类别： 类型安全 适用语言： TypeScript

TypeScript 的类型系统是 JavaScript 世界最强大的安全网之一。Agent 利用 tsc --noEmit 可以在不编译的情况下检查类型错误。

能力说明：

检测类型不匹配、缺少属性、隐式 any 等问题
支持严格模式（strict: true）发现更多潜在问题
通过 --noEmit 标志仅做检查不产出文件

Agent 使用场景：

Terminal window

1
# Agent 运行类型检查
2
npx tsc --noEmit --strict
3
npx tsc --noEmit --isolatedDeclarations

典型指令：

1
运行 tsc --noEmit 检查项目中的类型错误，逐个修复，
2
优先处理与 API 接口相关的类型问题。

⚠️ 注意： Agent 应区分编译错误和类型错误。类型错误通常是逻辑问题的信号，不要简单地用 any 绕过。

4. 单元测试运行与生成 🧪#

类别： 测试 适用语言： 全语言

测试是代码质量的终极保障。Agent 不仅能运行测试，还能根据代码自动生成测试用例。

能力说明：

运行现有测试套件（Jest / Vitest / Pytest / Go test 等）
根据函数签名和行为生成单元测试
分析测试失败原因并提供修复建议

Agent 使用场景：

1
// Agent 为函数生成测试用例
2
describe('calculateDiscount', () => {
3
  it('should apply 10% discount for orders over 100', () => {
4
    expect(calculateDiscount(150)).toBe(135);
5
  });
6

7
  it('should not apply discount for orders under 100', () => {
8
    expect(calculateDiscount(50)).toBe(50);
9
  });
10

11
  it('should handle zero price', () => {
12
    expect(calculateDiscount(0)).toBe(0);
13
  });
14
});

典型指令：

1
为 src/utils/pricing.ts 中的所有导出函数编写单元测试，
2
覆盖正常路径、边界值和错误处理三种情况。

测试框架	语言	特点
Jest	JS/TS	全能型，生态丰富
Vitest	JS/TS	极速，Vite 生态
Pytest	Python	简洁优雅，fixture 强大
Go test	Go	内置，benchmark 支持

5. 安全漏洞扫描 🔒#

类别： 安全 适用语言： 全语言

安全不是事后补救，而是从第一行代码就开始的。Agent 可以在编码过程中实时检测安全漏洞。

能力说明：

扫描依赖包的已知漏洞（npm audit / pip audit / Snyk）
检测代码中的安全反模式（SQL 注入、XSS、硬编码密钥）
提供修复建议和替代方案

Agent 使用场景：

Terminal window

1
# Node.js 项目安全扫描
2
npm audit --json | jq '.vulnerabilities | length'
3

4
# Python 项目安全扫描
5
pip-audit --format json
6

7
# 通用代码安全扫描
8
npx snyk test

典型指令：

1
检查项目的安全依赖，找出所有 high 和 critical 级别的漏洞，
2
给出具体的升级建议。

🚨 高频安全问题：

硬编码密钥 / API Token
SQL 拼接未参数化
未验证的用户输入
使用已知漏洞的依赖版本

6. 代码覆盖率分析 📊#

类别： 测试质量 适用语言： 全语言

测试覆盖率不是目标，但它是发现测试盲区的重要指标。Agent 可以分析覆盖率并找出未测试的关键路径。

能力说明：

生成行/分支/函数覆盖率报告
识别未覆盖的关键代码路径
对比不同版本的覆盖率变化

Agent 使用场景：

Terminal window

1
# Jest 覆盖率
2
npx jest --coverage --coverageReporters=text-summary
3

4
# V8 覆盖率（更精确）
5
npx c8 npx vitest run
6

7
# Python 覆盖率
8
pytest --cov=src --cov-report=term-missing

典型指令：

1
运行测试覆盖率报告，找出 src/core/ 目录下
2
覆盖率低于 80% 的文件，并为它们补充测试。

💡 覆盖率目标建议：

级别	行覆盖率	分支覆盖率	适用场景
基础	≥ 60%	≥ 50%	快速迭代项目
标准	≥ 80%	≥ 70%	生产级项目
严格	≥ 90%	≥ 85%	金融/医疗等关键系统

7. 代码复杂度分析 📈#

类别： 代码质量 适用语言： 全语言

圈复杂度高的代码难以维护、难以测试。Agent 可以量化复杂度并建议重构方案。

能力说明：

计算圈复杂度（Cyclomatic Complexity）
识别过长的函数和过深的嵌套
提供重构建议（提取函数、早返回、策略模式等）

Agent 使用场景：

Terminal window

1
# 使用 plato 分析 JavaScript 复杂度
2
npx plato -r -d report src/
3

4
# 使用 radon 分析 Python 复杂度
5
radon cc src/ -a -nc

典型指令：

1
分析 src/ 目录下所有文件的圈复杂度，
2
找出复杂度超过 10 的函数，给出重构建议。

复杂度等级参考：

圈复杂度	风险等级	建议
1-10	✅ 低	无需处理
11-20	⚠️ 中等	考虑重构
21-50	🔴 高	强烈建议重构
50+	💀 极高	必须重构

8. Git Hooks 自动化 🪝#

类别： 工作流自动化 适用语言： 全语言

Git Hooks 让代码检查自动化——在提交前自动运行 lint、测试、格式化，把问题挡在提交之前。

能力说明：

pre-commit：提交前运行检查
pre-push：推送前运行完整测试
commit-msg：校验提交信息格式

Agent 使用场景：

.husky/pre-commit

1
// husky + lint-staged 配置
2
npx lint-staged
3

4
// package.json
5
{
6
  "lint-staged": {
7
    "*.{ts,tsx}": ["eslint --fix", "prettier --write"],
8
    "*.{css,md}": ["prettier --write"]
9
  }
10
}

典型指令：

1
配置 husky 和 lint-staged，让每次提交前自动运行
2
ESLint 和 Prettier，确保不会提交格式错误的代码。

常用 Git Hooks：

Hook	触发时机	典型用途
pre-commit	`git commit` 前	Lint、格式化
commit-msg	写完提交信息后	校验格式（Conventional Commits）
pre-push	`git push` 前	运行测试
post-merge	`git merge` 后	安装新依赖

9. Conventional Commits 规范 📝#

类别： 提交规范 适用语言： 全语言

好的提交信息是项目历史的灵魂。Conventional Commits 让提交信息结构化，自动生成 changelog。

能力说明：

规范化提交信息格式（feat:, fix:, chore: 等）
自动生成 CHANGELOG
配合 semantic-release 实现自动版本发布

标准格式：

1
<type>(<scope>): <description>
2

3
[optional body]
4

5
[optional footer(s)]

常用类型：

类型	用途	示例
`feat`	新功能	`feat(auth): add OAuth2 login`
`fix`	修复 Bug	`fix(api): handle null response`
`docs`	文档	`docs: update README setup guide`
`refactor`	重构	`refactor(db): extract query builder`
`test`	测试	`test(auth): add login flow tests`
`chore`	杂项	`chore: upgrade dependencies`

典型指令：

1
按照 Conventional Commits 规范，为这次改动写提交信息。
2
改动内容：修复了用户登录时的 token 过期问题。

10. PR 自动审查 🤖#

类别： 代码审查 适用语言： 全语言

Agent 可以作为”第一审查者”，在人类审查之前先过一遍代码，发现常见问题，提升审查效率。

能力说明：

分析 PR 的 diff，找出潜在问题
检查代码风格一致性
评估改动的影响范围
生成结构化的审查意见

Agent 使用场景：

1
请审查这个 PR：
2
1. 检查是否有逻辑错误
3
2. 检查是否有安全风险
4
3. 检查是否有性能问题
5
4. 检查测试是否充分
6
5. 给出总体评价和改进建议

审查维度清单：

维度	检查项	权重
正确性	逻辑错误、边界条件	⭐⭐⭐⭐⭐
安全性	注入、泄露、权限	⭐⭐⭐⭐⭐
性能	时间/空间复杂度、N+1 查询	⭐⭐⭐⭐
可读性	命名、结构、注释	⭐⭐⭐
测试性	覆盖率、测试质量	⭐⭐⭐

本篇小结#

#	Skill	类别	难度	价值
1	ESLint / Biome	静态分析	⭐⭐	⭐⭐⭐⭐⭐
2	Prettier	格式化	⭐	⭐⭐⭐⭐
3	TypeScript 类型检查	类型安全	⭐⭐	⭐⭐⭐⭐⭐
4	单元测试	测试	⭐⭐⭐	⭐⭐⭐⭐⭐
5	安全扫描	安全	⭐⭐	⭐⭐⭐⭐⭐
6	覆盖率分析	测试质量	⭐⭐	⭐⭐⭐⭐
7	复杂度分析	代码质量	⭐⭐	⭐⭐⭐
8	Git Hooks	自动化	⭐⭐	⭐⭐⭐⭐
9	Conventional Commits	提交规范	⭐	⭐⭐⭐⭐
10	PR 审查	代码审查	⭐⭐⭐	⭐⭐⭐⭐⭐

核心观点： 代码审查类 Skill 是 Agent 的”基本功”。一个 Agent 如果只能写代码不能审查代码，就像一个只会进攻不会防守的球员——上限很高，但下限也很低。

系列导航#

👈 上一篇： 无（本篇为系列开篇）
👉 下一篇： 第二篇：数据库与数据存储
📖 系列目录：
- ✅ 第一篇：代码审查与质量守护（你在这里）
- 第二篇：数据库与数据存储
- 第三篇：浏览器自动化与爬虫
- 第四篇：搜索与信息获取
- 第五篇：云服务与 DevOps
- 第六篇：知识管理与 RAG
- 第七篇：版本控制与协作
- 第八篇：文档与文件处理
- 第九篇：通信与通知集成
- 第十篇：创意与可视化

100 个 Agent Skills 盘点（二）：数据库与数据存储

Thu, 18 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第二篇。上一篇我们聊了代码审查，这一篇进入 Agent 的”数据层”——数据库与数据存储能力。

为什么数据库 Skills 对 Agent 至关重要？

因为几乎所有有价值的应用都离不开数据。Agent 如果不能与数据库交互，就只能做一个”代码生成器”，而不能做”应用构建者”。掌握数据库 Skills，意味着 Agent 能直接读写数据、调试查询、优化性能，甚至自动迁移 Schema。

1. PostgreSQL MCP Server 🐘#

类别： 关系型数据库 协议： MCP (Model Context Protocol)

PostgreSQL 是世界上最先进的开源关系型数据库。PostgreSQL MCP Server 让 Agent 能直接与 PG 交互，执行查询、管理 Schema、分析性能。

能力说明：

执行 SQL 查询（SELECT / INSERT / UPDATE / DELETE）
查看和修改表结构（CREATE / ALTER TABLE）
分析查询计划（EXPLAIN ANALYZE）
管理索引和约束

Agent 使用场景：

1
-- Agent 执行数据分析查询
2
SELECT
3
    date_trunc('day', created_at) AS day,
4
    COUNT(*) AS new_users,
5
    AVG(session_duration) AS avg_session
6
FROM users
7
WHERE created_at > NOW() - INTERVAL '30 days'
8
GROUP BY day
9
ORDER BY day DESC;

1
-- Agent 分析慢查询
2
EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)
3
SELECT * FROM orders
4
WHERE user_id = 12345
5
AND status = 'pending';

典型指令：

1
查看 orders 表的结构，找出所有未建立索引的外键列，
2
并生成创建索引的 SQL 语句。

💡 核心价值： PostgreSQL MCP 是 Agent 数据能力的”瑞士军刀”，几乎所有关系型数据操作都能覆盖。

2. SQLite MCP Server 💎#

类别： 嵌入式数据库 协议： MCP

SQLite 是世界上部署最广泛的数据库——每部手机、每个浏览器里都有它。对 Agent 来说，它是本地数据处理的最佳选择。

能力说明：

零配置、零依赖的本地数据库
支持完整的 SQL 语法
适合数据清洗、临时分析、原型开发
单文件存储，便于 Agent 管理

Agent 使用场景：

1
# Agent 用 SQLite 做数据分析
2
import sqlite3
3

4
conn = sqlite3.connect(':memory:')
5
conn.execute('''
6
    CREATE TABLE metrics (
7
        name TEXT, value REAL, timestamp DATETIME
8
    )
9
''')
10

11
# 导入 CSV 数据进行分析
12
import csv
13
with open('data.csv') as f:
14
    reader = csv.DictReader(f)
15
    for row in reader:
16
        conn.execute(
17
            'INSERT INTO metrics VALUES (?, ?, ?)',
18
            (row['name'], float(row['value']), row['ts'])
19
        )
20

21
# Agent 运行分析查询
22
result = conn.execute('''
23
    SELECT name, AVG(value), MAX(value), MIN(value)
24
    FROM metrics
25
    GROUP BY name
26
    ORDER BY AVG(value) DESC
27
''').fetchall()

展开收起

典型指令：

1
把这个 CSV 文件导入 SQLite，然后分析每个类别的
2
平均值、最大值和标准差。

特性	SQLite	PostgreSQL
部署	零配置	需要服务器
并发	读多写少	高并发
适用	本地/原型	生产环境
性能	极快(单机)	快(可扩展)

3. Redis MCP Server 🔴#

类别： 缓存与键值存储 协议： MCP

Redis 是高性能缓存和消息系统的标准选择。Agent 掌握 Redis，就能处理缓存、会话、队列、实时数据等场景。

能力说明：

键值操作（GET / SET / DEL / EXISTS）
数据结构操作（List / Hash / Set / Sorted Set）
发布订阅（Pub/Sub）
过期策略和内存管理

Agent 使用场景：

Terminal window

1
# Agent 管理缓存
2
redis-cli SET user:1234 '{"name":"Raymin","role":"admin"}' EX 3600
3
redis-cli GET user:1234
4

5
# Agent 查看缓存命中率
6
redis-cli INFO stats | grep -E "keyspace_hits|keyspace_misses"
7

8
# Agent 清理过期缓存
9
redis-cli --scan --pattern "cache:*" | head -20

1
# Agent 实现分布式锁
2
import redis
3

4
r = redis.Redis()
5
lock = r.lock("my-resource", timeout=10)
6
if lock.acquire(blocking=True):
7
    try:
8
        # 临界区操作
9
        process_data()
10
    finally:
11
        lock.release()

典型指令：

1
检查 Redis 的内存使用情况，找出占用内存最多的 10 个 key，
2
并分析是否有可以清理的过期数据。

常见 Redis 数据结构应用：

数据结构	应用场景	示例
String	缓存、计数器	`SET page:views 1000`
Hash	对象存储	`HSET user:1 name "Raymin"`
List	消息队列	`LPUSH queue:tasks "task1"`
Set	标签、去重	`SADD post:1:tags "python"`
Sorted Set	排行榜	`ZADD leaderboard 100 "player1"`

4. MongoDB MCP Server 🍃#

类别： 文档数据库 协议： MCP

MongoDB 的灵活 Schema 使它成为快速迭代项目的首选。Agent 可以直接操作文档、聚合数据、管理索引。

能力说明：

CRUD 操作（find / insertOne / updateOne / deleteOne）
聚合管道（aggregate pipeline）
索引管理
Schema 分析

Agent 使用场景：

1
// Agent 使用聚合管道分析数据
2
db.orders.aggregate([
3
  { $match: { status: "completed", date: { $gte: ISODate("2026-01-01") } } },
4
  { $group: {
5
      _id: "$category",
6
      totalRevenue: { $sum: "$amount" },
7
      avgOrderValue: { $avg: "$amount" },
8
      orderCount: { $sum: 1 }
9
  }},
10
  { $sort: { totalRevenue: -1 } },
11
  { $limit: 10 }
12
]);

典型指令：

1
分析 orders 集合中最近 30 天的数据，
2
按类别汇总销售额，找出增长最快的产品类别。

5. Supabase MCP Server ⚡#

类别： 后端即服务 (BaaS) 协议： MCP

Supabase = PostgreSQL + 实时订阅 + 认证 + 存储 + Edge Functions。它是 Firebase 的开源替代，Agent 可以用它快速构建完整后端。

能力说明：

数据库操作（基于 PostgreSQL）
用户认证管理
文件存储
实时数据订阅
Edge Functions 部署

Agent 使用场景：

1
// Agent 创建 Supabase 表和 RLS 策略
2
const { data, error } = await supabase
3
  .from('posts')
4
  .select(`
5
    id, title, content,
6
    author:profiles(name, avatar),
7
    comments(count)
8
  `)
9
  .eq('status', 'published')
10
  .order('created_at', { ascending: false })
11
  .range(0, 9);

典型指令：

1
在 Supabase 中创建一个博客系统的基础表结构，
2
包括 posts、comments、profiles 表，
3
并配置 RLS 策略确保用户只能编辑自己的内容。

Supabase vs Firebase 对比：

特性	Supabase	Firebase
数据库	PostgreSQL (关系型)	Firestore (文档型)
开源	✅ 完全开源	❌ 闭源
实时	基于 PostgreSQL CDC	原生支持
查询语言	SQL	专有查询 API
自托管	✅ 支持	❌ 不支持

6. DynamoDB MCP Server 🏗️#

类别： NoSQL 键值/文档存储 协议： MCP

AWS DynamoDB 是 Serverless 架构的标配数据库。Agent 掌握 DynamoDB 就能构建高可用、自动扩展的应用。

能力说明：

PutItem / GetItem / Query / Scan 操作
二级索引（GSI / LSI）管理
容量模式切换（On-demand / Provisioned）
DynamoDB Streams 处理

Agent 使用场景：

1
# Agent 设计 DynamoDB 数据模型
2
import boto3
3

4
dynamodb = boto3.resource('dynamodb')
5
table = dynamodb.Table('UserActivities')
6

7
# 单表设计：一个表服务多种访问模式
8
table.put_item(Item={
9
    'PK': 'USER#12345',
10
    'SK': 'ACTIVITY#2026-06-10T10:00:00',
11
    'type': 'login',
12
    'ip': '192.168.1.1',
13
    'device': 'iPhone',
14
    'ttl': int(time.time()) + 86400 * 90  # 90天过期
15
})

展开收起

典型指令：

1
为一个社交应用设计 DynamoDB 单表数据模型，
2
需要支持：按用户查询动态、按时间排序、按标签搜索。

⚠️ DynamoDB 设计要点：

先确定访问模式，再设计表结构（与关系型数据库相反）
善用复合主键 (PK + SK) 实现一对多关系
GSI 是访问模式扩展的关键，但有额外成本

7. Elasticsearch MCP Server 🔎#

类别： 搜索引擎 协议： MCP

Elasticsearch 是全文搜索和日志分析的行业标准。Agent 用它可以构建搜索引擎、分析日志、做数据可视化。

能力说明：

全文搜索（match / fuzzy / wildcard）
聚合分析（terms / histogram / percentile）
索引管理（mapping / settings / aliases）
管道处理（ingest pipeline）

Agent 使用场景：

1
// Agent 构建搜索查询
2
{
3
  "query": {
4
    "bool": {
5
      "must": [
6
        { "match": { "title": "AI agent skills" } }
7
      ],
8
      "filter": [
9
        { "range": { "published_at": { "gte": "2026-01-01" } } },
10
        { "term": { "status": "published" } }
11
      ]
12
    }
13
  },
14
  "highlight": {
15
    "fields": { "title": {}, "content": {} }
16
  },
17
  "sort": [{ "_score": "desc" }, { "published_at": "desc" }],
18
  "size": 20
19
}

展开收起

典型指令：

1
在 Elasticsearch 中搜索包含 "MCP server" 的文章，
2
按相关性排序，高亮显示匹配的片段，
3
并按发布时间聚合出每月的文章数量。

8. ClickHouse MCP Server ⚡#

类别： 列式分析数据库 协议： MCP

ClickHouse 是 OLAP 领域的性能王者。Agent 用它处理海量数据分析查询，速度比传统数据库快 100-1000 倍。

能力说明：

高性能聚合查询
列式存储优化
实时数据导入
物化视图

Agent 使用场景：

1
-- Agent 在 ClickHouse 中做实时分析
2
SELECT
3
    toStartOfHour(event_time) AS hour,
4
    uniqExact(user_id) AS unique_users,
5
    countIf(event_type = 'purchase') AS purchases,
6
    sumIf(amount, event_type = 'purchase') AS revenue,
7
    round(purchases / unique_users * 100, 2) AS conversion_rate
8
FROM events
9
WHERE event_time >= now() - INTERVAL 24 HOUR
10
GROUP BY hour
11
ORDER BY hour;

典型指令：

1
在 ClickHouse 中分析最近 7 天的用户行为数据，
2
计算每小时的独立用户数、转化率和收入趋势。

ClickHouse vs PostgreSQL 分析查询性能：

查询类型	PostgreSQL	ClickHouse
10 亿行 COUNT	~30 秒	~0.3 秒
多维聚合	~60 秒	~1 秒
时间序列分析	~45 秒	~0.5 秒

9. Firebase MCP Server 🔥#

类别： 后端即服务 协议： MCP

Firebase 是 Google 的移动和 Web 应用开发平台。Agent 用它可以快速构建实时应用，无需管理服务器。

能力说明：

Firestore 文档操作
实时数据同步
用户认证（Email / Google / Phone）
Cloud Functions 部署
Hosting 管理

Agent 使用场景：

1
// Agent 构建实时聊天功能
2
import { collection, onSnapshot, addDoc, query, orderBy } from 'firebase/firestore';
3

4
// 实时监听消息
5
const messagesRef = collection(db, 'rooms', roomId, 'messages');
6
const q = query(messagesRef, orderBy('createdAt', 'asc'));
7

8
onSnapshot(q, (snapshot) => {
9
  snapshot.docChanges().forEach((change) => {
10
    if (change.type === 'added') {
11
      displayMessage(change.doc.data());
12
    }
13
  });
14
});
15

16
// 发送消息
17
await addDoc(messagesRef, {
18
  text: messageText,
19
  userId: currentUser.uid,
20
  createdAt: serverTimestamp()
21
});

展开收起

典型指令：

1
使用 Firebase 构建一个实时协作白板应用的后端，
2
支持多人同时绘制、实时同步、历史记录回放。

10. Prisma / Drizzle ORM 🧬#

类别： 数据库 ORM 协议： 直接集成

ORM 让 Agent 用面向对象的方式操作数据库，不用写原生 SQL。Prisma 和 Drizzle 是 TypeScript 生态中最流行的两个选择。

能力说明：

类型安全的数据库查询
Schema 迁移管理
关系映射
数据库无关性

Agent 使用场景：

1
// Prisma - Agent 生成类型安全的查询
2
const usersWithOrders = await prisma.user.findMany({
3
  where: {
4
    orders: {
5
      some: {
6
        status: 'completed',
7
        amount: { gte: 100 }
8
      }
9
    }
10
  },
11
  include: {
12
    orders: {
13
      where: { status: 'completed' },
14
      orderBy: { createdAt: 'desc' },
15
      take: 5
16
    },
17
    _count: { select: { orders: true } }
18
  }
19
});

展开收起

1
// Drizzle - 更接近 SQL 的体验
2
const result = await db
3
  .select({
4
    userId: users.id,
5
    name: users.name,
6
    orderCount: sql<number>`count(${orders.id})`,
7
    totalSpent: sql<number>`sum(${orders.amount})`
8
  })
9
  .from(users)
10
  .leftJoin(orders, eq(users.id, orders.userId))
11
  .groupBy(users.id)
12
  .having(sql`count(${orders.id}) > 5`)
13
  .orderBy(desc(sql`sum(${orders.amount})`));

Prisma vs Drizzle 对比：

特性	Prisma	Drizzle
查询风格	面向对象	SQL-like
类型安全	✅ 极强	✅ 极强
性能	中等	极快
学习曲线	平缓	需要 SQL 基础
Schema 管理	Prisma Migrate	Drizzle Kit
生态成熟度	极高	快速成长

本篇小结#

#	Skill	类别	难度	价值
1	PostgreSQL MCP	关系型数据库	⭐⭐⭐	⭐⭐⭐⭐⭐
2	SQLite MCP	嵌入式数据库	⭐	⭐⭐⭐⭐
3	Redis MCP	缓存	⭐⭐	⭐⭐⭐⭐⭐
4	MongoDB MCP	文档数据库	⭐⭐	⭐⭐⭐⭐
5	Supabase MCP	BaaS	⭐⭐	⭐⭐⭐⭐⭐
6	DynamoDB MCP	NoSQL	⭐⭐⭐	⭐⭐⭐⭐
7	Elasticsearch MCP	搜索引擎	⭐⭐⭐	⭐⭐⭐⭐
8	ClickHouse MCP	分析数据库	⭐⭐⭐	⭐⭐⭐⭐
9	Firebase MCP	BaaS	⭐⭐	⭐⭐⭐⭐
10	Prisma / Drizzle	ORM	⭐⭐	⭐⭐⭐⭐⭐

核心观点： 数据库 Skills 是 Agent 从”玩具”到”工具”的分水岭。一个能操作数据库的 Agent，可以构建完整的应用；不能操作数据库的 Agent，只能写写脚本。

系列导航#

👈 上一篇： 第一篇：代码审查与质量守护
👉 下一篇： 第三篇：浏览器自动化与爬虫
📖 系列目录：
- 第一篇：代码审查与质量守护
- ✅ 第二篇：数据库与数据存储（你在这里）
- 第三篇：浏览器自动化与爬虫
- 第四篇：搜索与信息获取
- 第五篇：云服务与 DevOps
- 第六篇：知识管理与 RAG
- 第七篇：版本控制与协作
- 第八篇：文档与文件处理
- 第九篇：通信与通知集成
- 第十篇：创意与可视化

100 个 Agent Skills 盘点（三）：浏览器自动化与爬虫

Wed, 17 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第三篇。如果说数据库 Skills 让 Agent 能”读写数据”，那浏览器 Skills 尙让 Agent 能”看见世界”——打开网页、点击按钮、填写表单、截取截图、抓取数据。

浏览器自动化 = Agent 的”眼睛和手”。

1. Puppeteer MCP Server 🎭#

类别： 浏览器自动化 协议： MCP

Puppeteer 是 Google 官方维护的无头浏览器控制库。它通过 DevTools Protocol 直接控制 Chrome，性能优异，API 简洁。

能力说明：

页面导航和截图
表单填写和按钮点击
PDF 生成
网络请求拦截
性能分析

Agent 使用场景：

1
// Agent 自动化测试登录流程
2
const browser = await puppeteer.launch();
3
const page = await browser.newPage();
4

5
await page.goto('https://example.com/login');
6
await page.type('#email', 'user@example.com');
7
await page.type('#password', 'password123');
8
await page.click('#login-btn');
9
await page.waitForNavigation();
10

11
// 截图记录结果
12
await page.screenshot({ path: 'login-result.png', fullPage: true });
13

14
// 检查是否登录成功
15
const isLoggedIn = await page.$('.user-dashboard') !== null;
16
console.log('Login success:', isLoggedIn);

展开收起

典型指令：

1
用 Puppeteer 打开我们的登录页面，测试以下场景：
2
1. 正确的邮箱和密码 → 应该跳转到 dashboard
3
2. 错误的密码 → 应该显示错误提示
4
3. 空的邮箱 → 应该显示验证错误
5
每个场景截图保存。

2. Playwright MCP Server 🎪#

类别： 跨浏览器自动化 协议： MCP

Playwright 是微软出品的下一代浏览器自动化工具，支持 Chrome、Firefox、Safari 三大引擎，API 现代化，功能更强大。

能力说明：

跨浏览器测试（Chromium / Firefox / WebKit）
自动等待元素（告别 sleep）
网络请求拦截和模拟
移动端模拟
代码生成（Codegen）

Agent 使用场景：

1
# Agent 测试响应式设计
2
from playwright.async_api import async_playwright
3

4
async with async_playwright() as p:
5
    browser = await p.chromium.launch()
6

7
    # 测试不同设备尺寸
8
    devices = [
9
        {'width': 375, 'height': 812, 'name': 'iPhone'},
10
        {'width': 768, 'height': 1024, 'name': 'iPad'},
11
        {'width': 1920, 'height': 1080, 'name': 'Desktop'}
12
    ]
13

14
    for device in devices:
15
        page = await browser.new_page(
16
            viewport={'width': device['width'], 'height': device['height']}
17
        )
18
        await page.goto('https://example.com')
19
        await page.screenshot(path=f"screenshot-{device['name']}.png")
20
        await page.close()

展开收起

典型指令：

1
用 Playwright 测试我们网站在 iPhone、iPad 和桌面端的
2
显示效果，截图对比，检查是否有布局问题。

Puppeteer vs Playwright：

特性	Puppeteer	Playwright
浏览器支持	Chrome/Firefox	Chrome/Firefox/Safari
维护方	Google	Microsoft
自动等待	需手动配置	内置
代码生成	❌	✅ Codegen
并行测试	一般	优秀
社区生态	极丰富	快速成长

3. Selenium MCP Server 🌐#

类别： 经典浏览器自动化 协议： MCP

Selenium 是浏览器自动化的”老前辈”，虽然不如 Puppeteer/Playwright 现代，但在企业环境中仍然广泛使用。

能力说明：

WebDriver 协议控制浏览器
支持几乎所有编程语言
企业级测试框架集成
Grid 分布式测试

Agent 使用场景：

1
from selenium import webdriver
2
from selenium.webdriver.common.by import By
3
from selenium.webdriver.support.ui import WebDriverWait
4
from selenium.webdriver.support import expected_conditions as EC
5

6
driver = webdriver.Chrome()
7
driver.get("https://example.com")
8

9
# 等待元素出现并交互
10
wait = WebDriverWait(driver, 10)
11
search_box = wait.until(
12
    EC.presence_of_element_located((By.NAME, "q"))
13
)
14
search_box.send_keys("AI agent skills")
15
search_box.submit()

展开收起

典型指令：

1
用 Selenium 编写一个自动化脚本，
2
每天早上 9 点检查我们产品的首页是否正常加载，
3
如果加载失败则发送告警。

4. 网页抓取 (Web Scraping) 🕸️#

类别： 数据采集 适用工具： Cheerio / BeautifulSoup / Scrapy

网页抓取是从网站提取结构化数据的核心能力。Agent 可以用它收集竞品信息、监控价格、聚合新闻。

能力说明：

HTML 解析和数据提取
CSS 选择器 / XPath 定位
反爬虫策略处理
数据清洗和结构化

Agent 使用场景：

1
// Agent 抓取技术博客文章列表
2
const cheerio = require('cheerio');
3

4
const response = await fetch('https://tech-blog.example.com');
5
const html = await response.text();
6
const $ = cheerio.load(html);
7

8
const articles = [];
9
$('.post-card').each((i, el) => {
10
  articles.push({
11
    title: $(el).find('h2').text().trim(),
12
    url: $(el).find('a').attr('href'),
13
    summary: $(el).find('.summary').text().trim(),
14
    date: $(el).find('.date').text().trim()
15
  });
16
});
17

18
console.log(`Found ${articles.length} articles`);

展开收起

典型指令：

1
抓取 Hacker News 首页的前 30 条新闻，
2
提取标题、链接、分数和评论数，
3
按分数排序后输出为 JSON。

常用抓取工具对比：

工具	语言	特点	适用场景
Cheerio	JS	快速、轻量	静态页面
BeautifulSoup	Python	简单易用	快速原型
Scrapy	Python	全功能框架	大规模采集
Puppeteer	JS	渲染页面	动态页面

5. 截图与视觉记录 📸#

类别： 视觉自动化 适用工具： Puppeteer / Playwright

截图能力让 Agent 能”看到”页面的样子，用于测试验证、Bug 记录、设计对比。

能力说明：

全页面截图
元素级截图
不同设备尺寸截图
对比截图（before/after）

Agent 使用场景：

1
// Agent 做视觉回归测试
2
const puppeteer = require('puppeteer');
3
const pixelmatch = require('pixelmatch');
4
const { PNG } = require('pngjs');
5
const fs = require('fs');
6

7
async function visualRegression(url, baselinePath, currentPath) {
8
  const browser = await puppeteer.launch();
9
  const page = await browser.newPage();
10
  await page.setViewport({ width: 1920, height: 1080 });
11
  await page.goto(url, { waitUntil: 'networkidle0' });
12
  await page.screenshot({ path: currentPath, fullPage: true });
13

14
  // 对比基线图
15
  const baseline = PNG.sync.read(fs.readFileSync(baselinePath));
16
  const current = PNG.sync.read(fs.readFileSync(currentPath));
17
  const diff = new PNG({ width: baseline.width, height: baseline.height });
18

19
  const mismatch = pixelmatch(
20
    baseline.data, current.data, diff.data,
21
    baseline.width, baseline.height,
22
    { threshold: 0.1 }
23
  );
24

25
  console.log(`Pixel mismatch: ${mismatch} (${(mismatch / (baseline.width * baseline.height) * 100).toFixed(2)}%)`);
26
  return mismatch;
27
}

展开收起

典型指令：

1
对网站的首页、产品页、登录页分别截图，
2
保存为基线图，以后每次部署后自动对比，
3
差异超过 1% 则告警。

6. PDF 生成与处理 📄#

类别： 文档生成 适用工具： Puppeteer / PDFKit / jsPDF

Agent 可以将网页转换为 PDF，或生成结构化的 PDF 文档——报告、发票、简历等。

能力说明：

网页转 PDF
动态数据填充模板
PDF 合并和拆分
添加水印和签名

Agent 使用场景：

1
// Agent 生成月度报告 PDF
2
const puppeteer = require('puppeteer');
3

4
async function generateReport(data) {
5
  const browser = await puppeteer.launch();
6
  const page = await browser.newPage();
7

8
  // 用 HTML 模板渲染报告
9
  const html = `
10
    <html>
11
    <head>
12
      <style>
13
        body { font-family: 'Noto Sans SC', sans-serif; padding: 40px; }
14
        .header { text-align: center; border-bottom: 2px solid #333; padding-bottom: 20px; }
15
        .metric { display: inline-block; width: 30%; text-align: center; margin: 20px 1%; }
16
        .metric .value { font-size: 48px; font-weight: bold; color: #2563eb; }
17
        .metric .label { font-size: 14px; color: #666; }
18
        table { width: 100%; border-collapse: collapse; margin-top: 30px; }
19
        th, td { border: 1px solid #ddd; padding: 12px; text-align: left; }
20
        th { background: #f5f5f5; }
21
      </style>
22
    </head>
23
    <body>
24
      <div class="header">
25
        <h1>月度运营报告 - ${data.month}</h1>
26
      </div>
27
      <div class="metric"><div class="value">${data.users}</div><div class="label">活跃用户</div></div>
28
      <div class="metric"><div class="value">${data.revenue}</div><div class="label">收入(万元)</div></div>
29
      <div class="metric"><div class="value">${data.growth}%</div><div class="label">增长率</div></div>
30
      <table>
31
        <tr><th>指标</th><th>本月</th><th>上月</th><th>变化</th></tr>
32
        ${data.details.map(d => `<tr><td>${d.name}</td><td>${d.current}</td><td>${d.previous}</td><td>${d.change}</td></tr>`).join('')}
33
      </table>
34
    </body>
35
    </html>
36
  `;
37

38
  await page.setContent(html, { waitUntil: 'networkidle0' });
39
  await page.pdf({
40
    path: `report-${data.month}.pdf`,
41
    format: 'A4',
42
    printBackground: true
43
  });
44
}

展开收起

典型指令：

1
根据这个月的运营数据生成一份 PDF 报告，
2
包含关键指标卡片、趋势图表和详细数据表格。

7. 表单自动填写 📝#

类别： 表单自动化 适用工具： Puppeteer / Playwright

表单填写是重复性最高的工作之一。Agent 可以自动填写注册表单、申请表、调查问卷等。

能力说明：

自动识别表单字段
根据数据源自动填充
处理下拉框、复选框、日期选择器
文件上传

Agent 使用场景：

1
// Agent 批量填写申请表
2
async function fillApplication(page, userData) {
3
  // 基本信息
4
  await page.fill('#firstName', userData.firstName);
5
  await page.fill('#lastName', userData.lastName);
6
  await page.fill('#email', userData.email);
7
  await page.fill('#phone', userData.phone);
8

9
  // 下拉框选择
10
  await page.selectOption('#country', userData.country);
11
  await page.selectOption('#education', userData.education);
12

13
  // 日期选择
14
  await page.fill('#birthDate', userData.birthDate);
15

16
  // 文件上传
17
  await page.setInputFiles('#resume', userData.resumePath);
18

19
  // 复选框
20
  if (userData.agreeTerms) {
21
    await page.check('#agreeTerms');
22
  }
23

24
  // 提交
25
  await page.click('#submit-btn');
26
  await page.waitForSelector('.success-message');
27
}

展开收起

典型指令：

1
读取 applicants.csv 中的 50 个申请人信息，
2
自动填写我们的在线申请表，每个申请截图保存。

8. 网站性能测试 ⚡#

类别： 性能分析 适用工具： Lighthouse / Puppeteer

Agent 可以自动运行性能测试，生成 Lighthouse 报告，找出性能瓶颈。

能力说明：

Lighthouse 综合评分
Core Web Vitals 测量
资源加载分析
性能优化建议

Agent 使用场景：

1
// Agent 运行 Lighthouse 审计
2
const lighthouse = require('lighthouse');
3
const chromeLauncher = require('chrome-launcher');
4

5
async function runLighthouse(url) {
6
  const chrome = await chromeLauncher.launch({ chromeFlags: ['--headless'] });
7
  const options = {
8
    logLevel: 'info',
9
    output: 'json',
10
    onlyCategories: ['performance', 'accessibility', 'best-practices', 'seo'],
11
    port: chrome.port
12
  };
13

14
  const runnerResult = await lighthouse(url, options);
15
  await chrome.kill();
16

17
  const scores = {
18
    performance: runnerResult.lhr.categories.performance.score * 100,
19
    accessibility: runnerResult.lhr.categories.accessibility.score * 100,
20
    bestPractices: runnerResult.lhr.categories['best-practices'].score * 100,
21
    seo: runnerResult.lhr.categories.seo.score * 100
22
  };
23

24
  console.log('Lighthouse Scores:', scores);
25
  return scores;
26
}

展开收起

典型指令：

1
对我们网站的首页、产品页、博客页分别运行 Lighthouse 测试，
2
生成报告，找出性能评分低于 90 的页面并分析原因。

Core Web Vitals 指标：

指标	含义	良好	需改进	差
LCP	最大内容渲染	≤ 2.5s	≤ 4.0s	> 4.0s
FID	首次输入延迟	≤ 100ms	≤ 300ms	> 300ms
CLS	累积布局偏移	≤ 0.1	≤ 0.25	> 0.25

9. API 测试与监控 🔌#

类别： API 自动化 适用工具： Fetch / Axios / Newman

Agent 不仅能测试前端界面，还能直接测试 API 接口，监控可用性和响应时间。

能力说明：

HTTP 请求发送和响应验证
集合运行（Postman Collection）
响应时间监控
契约测试

Agent 使用场景：

1
// Agent 运行 API 健康检查
2
async function healthCheck(endpoints) {
3
  const results = [];
4

5
  for (const endpoint of endpoints) {
6
    const start = Date.now();
7
    try {
8
      const response = await fetch(endpoint.url, {
9
        method: endpoint.method || 'GET',
10
        headers: endpoint.headers,
11
        timeout: 10000
12
      });
13

14
      results.push({
15
        url: endpoint.url,
16
        status: response.status,
17
        ok: response.ok,
18
        time: Date.now() - start,
19
        expected: endpoint.expectedStatus || 200
20
      });
21
    } catch (error) {
22
      results.push({
23
        url: endpoint.url,
24
        status: 'ERROR',
25
        ok: false,
26
        time: Date.now() - start,
27
        error: error.message
28
      });
29
    }
30
  }
31

32
  // 报告异常
33
  const failures = results.filter(r => !r.ok || r.status !== r.expected);
34
  if (failures.length > 0) {
35
    console.error('🚨 API Health Check Failures:', failures);
36
  }
37

38
  return results;
39
}

展开收起

典型指令：

1
对我们所有的 API 端点运行健康检查，
2
验证状态码和响应时间，找出响应超过 2 秒的慢接口。

10. RPA 流程自动化 🤖#

类别： 流程自动化 适用工具： Playwright / Puppeteer + 自定义逻辑

RPA（机器人流程自动化）是浏览器自动化的终极形态——Agent 可以模拟完整的业务流程，从登录到数据录入到报表生成。

能力说明：

多步骤业务流程编排
错误处理和重试机制
流程录制和回放
定时执行

Agent 使用场景：

1
// Agent 自动化每日运营流程
2
async function dailyOperations() {
3
  const browser = await playwright.chromium.launch();
4
  const context = await browser.newContext();
5

6
  try {
7
    // Step 1: 登录后台
8
    const page = await context.newPage();
9
    await page.goto('https://admin.example.com/login');
10
    await page.fill('#username', process.env.ADMIN_USER);
11
    await page.fill('#password', process.env.ADMIN_PASS);
12
    await page.click('#login');
13
    await page.waitForURL('**/dashboard');
14

15
    // Step 2: 导出昨日数据
16
    await page.click('a[href="/reports"]');
17
    await page.click('#export-yesterday');
18
    const download = await page.waitForEvent('download');
19
    await download.saveAs('./data/yesterday.csv');
20

21
    // Step 3: 检查待处理订单
22
    await page.click('a[href="/orders?status=pending"]');
23
    const pendingCount = await page.locator('.order-row').count();
24
    console.log(`Pending orders: ${pendingCount}`);
25

26
    // Step 4: 截图记录
27
    await page.screenshot({ path: './screenshots/daily-dashboard.png' });
28

29
    console.log('✅ Daily operations completed');
30
  } catch (error) {
31
    console.error('❌ Daily operations failed:', error);
32
    // 截图记录错误现场
33
    const page = context.pages()[0];
34
    await page.screenshot({ path: './screenshots/error.png' });
35
  } finally {
36
    await browser.close();
37
  }
38
}

展开收起

典型指令：

1
编写一个 RPA 流程：每天早上 9 点自动登录后台，
2
导出昨日销售数据，检查待处理订单数量，
3
截图后发送到 Slack 频道。

本篇小结#

#	Skill	类别	难度	价值
1	Puppeteer	浏览器自动化	⭐⭐	⭐⭐⭐⭐⭐
2	Playwright	跨浏览器自动化	⭐⭐	⭐⭐⭐⭐⭐
3	Selenium	经典自动化	⭐⭐	⭐⭐⭐
4	网页抓取	数据采集	⭐⭐⭐	⭐⭐⭐⭐
5	截图与视觉	视觉自动化	⭐⭐	⭐⭐⭐⭐
6	PDF 生成	文档生成	⭐⭐	⭐⭐⭐⭐
7	表单自动填写	表单自动化	⭐⭐	⭐⭐⭐⭐
8	性能测试	性能分析	⭐⭐⭐	⭐⭐⭐⭐
9	API 测试	API 自动化	⭐⭐	⭐⭐⭐⭐
10	RPA 流程	流程自动化	⭐⭐⭐⭐	⭐⭐⭐⭐⭐

核心观点： 浏览器 Skills 让 Agent 从”代码世界”走进”真实世界”。它不只是能写代码，还能操作真实的网站、采集真实的数据、完成真实的业务流程。

系列导航#

👈 上一篇： 第二篇：数据库与数据存储
👉 下一篇： 第四篇：搜索与信息获取
📖 系列目录：
- 第一篇：代码审查与质量守护
- 第二篇：数据库与数据存储
- ✅ 第三篇：浏览器自动化与爬虫（你在这里）
- 第四篇：搜索与信息获取
- 第五篇：云服务与 DevOps
- 第六篇：知识管理与 RAG
- 第七篇：版本控制与协作
- 第八篇：文档与文件处理
- 第九篇：通信与通知集成
- 第十篇：创意与可视化

100 个 Agent Skills 盘点（四）：搜索与信息获取

Tue, 16 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第四篇。前面三篇分别讲了代码审查、数据库、浏览器自动化，这一篇聚焦 Agent 的”信息获取”能力。

为什么搜索 Skills 如此重要？

因为 Agent 的价值很大程度上取决于它能获取多少有用的信息。一个只能看本地文件的 Agent 是”近视”的；一个能搜索互联网、获取实时信息的 Agent 才是”全景”的。

1. Brave Search MCP Server 🔍#

类别： Web 搜索 协议： MCP

Brave Search 是一个独立的搜索引擎，不依赖 Google/Bing，提供隐私友好的搜索能力。它是 MCP 生态中最常用的搜索工具。

能力说明：

Web 搜索（返回标题、URL、摘要）
新闻搜索
图片搜索
本地搜索
自定义搜索参数

Agent 使用场景：

1
// Agent 搜索最新技术资讯
2
const results = await braveSearch({
3
  query: "MCP server 最新进展 2026",
4
  count: 10,
5
  freshness: "week"  // 最近一周
6
});
7

8
results.web.results.forEach(r => {
9
  console.log(`📰 ${r.title}`);
10
  console.log(`   ${r.url}`);
11
  console.log(`   ${r.description}\n`);
12
});

典型指令：

1
搜索最近一周关于 "AI agent framework" 的新闻，
2
找出 5 条最重要的，总结每条的核心内容。

💡 核心价值： Brave Search MCP 是让 Agent “上网冲浪”的基础能力，几乎所有需要实时信息的场景都离不开它。

2. Web Fetch / URL 读取 🌐#

类别： 页面内容获取 协议： MCP / 内置工具

Web Fetch 让 Agent 能直接读取任意 URL 的内容，并将其转换为可处理的格式（Markdown / 纯文本）。

能力说明：

获取网页内容
HTML 转 Markdown（去除广告和导航）
处理重定向
支持认证头

Agent 使用场景：

1
// Agent 读取并总结技术文章
2
const content = await webFetch({
3
  url: "https://blog.example.com/ai-trends-2026",
4
  prompt: "总结这篇文章的核心观点，不超过 200 字"
5
});
6

7
// Agent 读取 API 文档
8
const apiDocs = await webFetch({
9
  url: "https://api.example.com/docs",
10
  prompt: "列出所有可用的 API 端点及其参数"
11
});

典型指令：

1
读取这个 GitHub README 文件，总结安装步骤和主要功能。
2
URL: https://github.com/example/project

3. Google Search API 🔎#

类别： Web 搜索 协议： REST API / MCP

Google 搜索 API 提供了最全面的搜索能力，包括网页、图片、视频、学术论文等。

能力说明：

全网搜索
学术论文搜索（Google Scholar）
时间范围过滤
地区和语言偏好

Agent 使用场景：

1
# Agent 做竞品调研
2
def competitor_research(competitors):
3
    for competitor in competitors:
4
        results = google_search(
5
            query=f"{competitor} product features pricing",
6
            num=10,
7
            date_restrict="m1"  # 最近一个月
8
        )
9

10
        analysis = {
11
            'name': competitor,
12
            'latest_news': results[:3],
13
            'features': extract_features(results),
14
            'pricing': extract_pricing(results)
15
        }
16

17
        save_to_report(analysis)

展开收起

典型指令：

1
搜索 "Notion vs Obsidian vs Logseq 2026" 的最新对比文章，
2
总结每个工具的优缺点和适用场景。

4. Hacker News / Reddit API 📰#

类别： 社区内容 协议： REST API

技术社区是获取前沿信息的宝库。Agent 可以自动追踪 HN、Reddit 等社区的热门讨论。

能力说明：

获取热门帖子列表
搜索特定话题
读取评论和讨论
监控新帖子

Agent 使用场景：

1
// Agent 追踪 HN 热门技术话题
2
async function getHNTrending() {
3
  // 获取首页帖子 ID
4
  const topIds = await fetch(
5
    'https://hacker-news.firebaseio.com/v0/topstories.json'
6
  ).then(r => r.json());
7

8
  // 获取前 20 条帖子详情
9
  const stories = await Promise.all(
10
    topIds.slice(0, 20).map(id =>
11
      fetch(`https://hacker-news.firebaseio.com/v0/item/${id}.json`)
12
        .then(r => r.json())
13
    )
14
  );
15

16
  // 过滤 AI 相关
17
  const aiStories = stories.filter(s =>
18
    s.title?.match(/AI|LLM|agent|machine learning|GPT/i)
19
  );
20

21
  console.log(`📊 Top AI stories on HN today:`);
22
  aiStories.forEach(s => {
23
    console.log(`  ⭐ ${s.score} | ${s.title}`);
24
    console.log(`    ${s.url}`);
25
  });
26
}

展开收起

典型指令：

1
查看 Hacker News 今天首页上与 AI 相关的帖子，
2
按分数排序，总结每个帖子讨论的核心观点。

5. RSS 订阅聚合 📡#

类别： 信息订阅 适用工具： RSS Parser / Feedparser

RSS 是互联网上最古老但最可靠的信息分发协议。Agent 可以订阅多个 RSS 源，自动聚合和筛选信息。

能力说明：

解析 RSS / Atom Feed
多源聚合
关键词过滤
增量更新

Agent 使用场景：

1
// Agent 聚合技术博客 RSS
2
const Parser = require('rss-parser');
3
const parser = new Parser();
4

5
const feeds = [
6
  'https://blog.openai.com/rss/',
7
  'https://www.anthropic.com/rss.xml',
8
  'https://huggingface.co/blog/feed.xml',
9
  'https://blog.google/technology/ai/rss/'
10
];
11

12
async function aggregateFeeds() {
13
  const allPosts = [];
14

15
  for (const feedUrl of feeds) {
16
    try {
17
      const feed = await parser.parseURL(feedUrl);
18
      feed.items.forEach(item => {
19
        allPosts.push({
20
          source: feed.title,
21
          title: item.title,
22
          link: item.link,
23
          date: new Date(item.pubDate),
24
          summary: item.contentSnippet?.slice(0, 200)
25
        });
26
      });
27
    } catch (e) {
28
      console.error(`Failed to parse ${feedUrl}:`, e.message);
29
    }
30
  }
31

32
  // 按日期排序
33
  allPosts.sort((a, b) => b.date - a.date);
34

35
  // 过滤最近 7 天
36
  const weekAgo = new Date(Date.now() - 7 * 86400000);
37
  const recent = allPosts.filter(p => p.date > weekAgo);
38

39
  return recent;
40
}

展开收起

典型指令：

1
订阅以下技术博客的 RSS，整理出本周的 AI 领域重要更新，
2
按重要性排序，每条用一句话总结。

6. 学术论文搜索 📚#

类别： 学术信息 适用工具： Semantic Scholar API / arXiv API

Agent 可以搜索学术论文、获取摘要和引用信息，帮助用户了解前沿研究。

能力说明：

论文搜索（Semantic Scholar / arXiv / Google Scholar）
引用网络分析
论文摘要提取
作者信息查询

Agent 使用场景：

1
# Agent 搜索最新 AI 论文
2
import requests
3

4
def search_papers(query, limit=10):
5
    # Semantic Scholar API
6
    url = "https://api.semanticscholar.org/graph/v1/paper/search"
7
    params = {
8
        "query": query,
9
        "limit": limit,
10
        "fields": "title,abstract,year,citationCount,authors,url"
11
    }
12

13
    response = requests.get(url, params=params)
14
    papers = response.json()["data"]
15

16
    # 按引用数排序
17
    papers.sort(key=lambda p: p.get("citationCount", 0), reverse=True)
18

19
    for paper in papers:
20
        print(f"📄 {paper['title']}")
21
        print(f"   引用: {paper['citationCount']} | 年份: {paper['year']}")
22
        print(f"   作者: {', '.join(a['name'] for a in paper['authors'][:3])}")
23
        print(f"   {paper['url']}\n")
24

25
    return papers

展开收起

典型指令：

1
搜索最近发表的关于 "AI agent planning" 的论文，
2
找出引用数最高的 5 篇，总结每篇的核心贡献。

7. Notion MCP Server 📝#

类别： 知识管理 协议： MCP

Notion MCP Server 让 Agent 能够直接操作 Notion 工作区，包括页面读写、数据库查询和评论管理，是团队知识管理的利器。

能力说明：

页面内容读取与写入
数据库查询与筛选
评论的创建与管理
块级内容操作（文本、列表、表格等）
工作区搜索

Agent 使用场景：

1
// Agent 自动整理团队周报
2
async function generateWeeklyReport(databaseId) {
3
  // 查询本周完成的任务
4
  const tasks = await notion.databases.query({
5
    database_id: databaseId,
6
    filter: {
7
      and: [
8
        { property: "状态", status: { equals: "已完成" } },
9
        { property: "完成时间", date: { past_week: {} } }
10
      ]
11
    },
12
    sorts: [{ property: "优先级", direction: "ascending" }]
13
  });
14

15
  // 生成周报内容
16
  const report = tasks.results.map(task => ({
17
    name: task.properties["任务名"].title[0].text.content,
18
    owner: task.properties["负责人"].people[0]?.name,
19
    priority: task.properties["优先级"].select?.name
20
  }));
21

22
  // 创建周报页面
23
  await notion.pages.create({
24
    parent: { database_id: weeklyReportDbId },
25
    properties: {
26
      "标题": { title: [{ text: { content: `周报 ${getWeekRange()}` } }] }
27
    },
28
    children: buildReportBlocks(report)
29
  });
30
}

展开收起

典型指令：

1
查询 Notion 项目数据库中状态为"进行中"的任务，
2
按优先级排序，生成一份进度汇总页面。

8. Google Drive MCP Server 📁#

类别： 云存储 协议： MCP

Google Drive MCP Server 让 Agent 能够搜索、读取、上传和管理 Google Drive 中的文件，实现云端文档的自动化操作。

能力说明：

文件搜索（按名称、类型、修改时间）
文件内容读取（文档、表格、幻灯片）
文件上传与创建
权限管理（共享、协作者设置）
文件夹结构管理

Agent 使用场景：

1
// Agent 自动整理团队文档
2
async function organizeTeamDocs() {
3
  // 搜索最近修改的项目文档
4
  const files = await drive.files.list({
5
    q: "modifiedTime > '2026-06-01' and mimeType='application/vnd.google-apps.document'",
6
    fields: "files(id, name, modifiedTime, owners)",
7
    orderBy: "modifiedTime desc"
8
  });
9

10
  // 按项目分类
11
  const categorized = {};
12
  for (const file of files.data.files) {
13
    const category = detectCategory(file.name);
14
    if (!categorized[category]) categorized[category] = [];
15
    categorized[category].push(file);
16
  }
17

18
  // 为每个分类创建索引文档
19
  for (const [category, docs] of Object.entries(categorized)) {
20
    await drive.files.create({
21
      requestBody: {
22
        name: `${category} 文档索引 - ${new Date().toLocaleDateString('zh-CN')}`,
23
        mimeType: 'application/vnd.google-apps.document',
24
        parents: [getIndexFolderId()]
25
      },
26
      media: {
27
        mimeType: 'text/plain',
28
        body: buildIndexContent(docs)
29
      }
30
    });
31
  }
32
}

展开收起

典型指令：

1
搜索 Google Drive 中最近一周修改过的项目文档，
2
按项目分类整理，并生成一份文档索引。

9. 技术文档搜索 📖#

类别： 开发者工具 适用工具： Context7 / DevDocs API

Agent 可以搜索和查询技术文档，帮助开发者快速找到 API 用法、配置说明、最佳实践。

能力说明：

搜索框架/库的官方文档
查询特定 API 的用法
获取代码示例
版本对比

Agent 使用场景：

1
// Agent 查询 Next.js 文档
2
const docs = await context7Query({
3
  libraryId: "/vercel/next.js",
4
  query: "How to implement server actions with form validation"
5
});
6

7
// Agent 对比不同版本的 API 变化
8
const v13Docs = await context7Query({
9
  libraryId: "/vercel/next.js/v13",
10
  query: "app router data fetching"
11
});
12

13
const v14Docs = await context7Query({
14
  libraryId: "/vercel/next.js/v14",
15
  query: "app router data fetching"
16
});

展开收起

典型指令：

1
查一下 React 19 的 useActionState hook 怎么用，
2
跟之前的 useFormState 有什么区别，给出代码示例。

10. Stripe MCP Server 💳#

类别： 支付处理 协议： MCP

Stripe MCP Server 让 Agent 能够直接处理支付相关操作，包括创建支付、管理订阅、生成发票和处理退款，是电商和 SaaS 场景的核心能力。

能力说明：

支付创建与确认
订阅计划管理
发票生成与发送
退款处理
客户信息管理

Agent 使用场景：

1
// Agent 自动处理退款请求
2
async function processRefund(orderId, reason) {
3
  // 查询订单对应的支付记录
4
  const payment = await stripe.paymentIntents.list({
5
    limit: 1,
6
    metadata: { order_id: orderId }
7
  });
8

9
  if (!payment.data.length) {
10
    return { error: "未找到对应支付记录" };
11
  }
12

13
  const paymentIntent = payment.data[0];
14

15
  // 创建退款
16
  const refund = await stripe.refunds.create({
17
    payment_intent: paymentIntent.id,
18
    amount: paymentIntent.amount,  // 全额退款
19
    reason: "requested_by_customer",
20
    metadata: {
21
      order_id: orderId,
22
      refund_reason: reason,
23
      processed_by: "agent"
24
    }
25
  });
26

27
  // 发送退款确认邮件
28
  await sendEmail({
29
    to: paymentIntent.receipt_email,
30
    subject: `退款已处理 - 订单 ${orderId}`,
31
    body: `退款金额: ¥${(refund.amount / 100).toFixed(2)}，预计 3-5 个工作日到账。`
32
  });
33

34
  return { refundId: refund.id, status: refund.status };
35
}

展开收起

典型指令：

1
查询本月所有失败的订阅续费，分析失败原因，
2
对因余额不足导致失败的客户重新发起扣款。

本篇小结#

#	Skill	类别	难度	价值
1	Brave Search	Web 搜索	⭐	⭐⭐⭐⭐⭐
2	Web Fetch	页面获取	⭐	⭐⭐⭐⭐⭐
3	Google Search	Web 搜索	⭐⭐	⭐⭐⭐⭐
4	HN / Reddit API	社区内容	⭐⭐	⭐⭐⭐⭐
5	RSS 聚合	信息订阅	⭐⭐	⭐⭐⭐⭐
6	学术论文搜索	学术信息	⭐⭐	⭐⭐⭐⭐
7	Notion MCP Server	知识管理	⭐⭐	⭐⭐⭐⭐
8	Google Drive MCP Server	云存储	⭐⭐	⭐⭐⭐⭐
9	技术文档搜索	开发者工具	⭐⭐	⭐⭐⭐⭐⭐
10	Stripe MCP Server	支付处理	⭐⭐⭐	⭐⭐⭐⭐⭐

核心观点： 搜索 Skills 是 Agent 的”感官系统”。一个能搜索互联网、读取文档、集成 Notion/Google Drive 知识库、处理 Stripe 支付的 Agent，才能真正成为用户的”智能助手”，而不只是”代码生成器”。

系列导航#

👈 上一篇： 第三篇：浏览器自动化与爬虫
👉 下一篇： 第五篇：云服务与 DevOps
📖 系列目录：
- 第一篇：代码审查与质量守护
- 第二篇：数据库与数据存储
- 第三篇：浏览器自动化与爬虫
- ✅ 第四篇：搜索与信息获取（你在这里）
- 第五篇：云服务与 DevOps
- 第六篇：知识管理与 RAG
- 第七篇：版本控制与协作
- 第八篇：文档与文件处理
- 第九篇：通信与通知集成
- 第十篇：创意与可视化

100 个 Agent Skills 盘点（五）：云服务与 DevOps

Mon, 15 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第五篇。前面讲了代码审查、数据库、浏览器、搜索，这一篇进入”基建层”——云服务与 DevOps。

为什么 DevOps Skills 对 Agent 至关重要？

因为代码写完只是开始，部署上线才是真正的价值交付。一个不懂 DevOps 的 Agent，就像一个会做饭但不会端盘子的厨师——手艺再好，客户也吃不到。

1. Docker MCP Server 🐳#

类别： 容器化 协议： MCP

Docker 是容器化的事实标准。Agent 掌握 Docker，就能构建、运行、管理容器化应用。

能力说明：

构建 Docker 镜像（docker build）
运行和管理容器（docker run / ps / stop / rm）
镜像仓库操作（push / pull）
Docker Compose 编排
日志查看和调试

Agent 使用场景：

1
# Agent 生成的多阶段构建 Dockerfile
2
FROM node:20-alpine AS builder
3
WORKDIR /app
4
COPY package*.json ./
5
RUN npm ci --only=production
6
COPY . .
7
RUN npm run build
8

9
FROM node:20-alpine AS runner
10
WORKDIR /app
11
RUN addgroup --system --gid 1001 nodejs
12
RUN adduser --system --uid 1001 appuser
13
COPY --from=builder --chown=appuser:nodejs /app/dist ./dist
14
COPY --from=builder --chown=appuser:nodejs /app/node_modules ./node_modules
15
USER appuser
16
EXPOSE 3000
17
CMD ["node", "dist/main.js"]

展开收起

Terminal window

1
# Agent 管理容器
2
docker build -t myapp:latest .
3
docker run -d -p 3000:3000 --name myapp myapp:latest
4
docker logs -f myapp
5
docker stats myapp

典型指令：

1
为这个 Node.js 项目编写 Dockerfile 和 docker-compose.yml，
2
包含应用、PostgreSQL 和 Redis 三个服务，
3
配置健康检查和自动重启。

2. Kubernetes MCP Server ☸️#

类别： 容器编排 协议： MCP

Kubernetes 是生产级容器编排的标准。Agent 掌握 K8s，就能管理大规模应用的部署、扩缩容、自愈。

能力说明：

部署管理（Deployment / StatefulSet / DaemonSet）
服务发现（Service / Ingress）
配置管理（ConfigMap / Secret）
自动扩缩容（HPA）
故障排查（Events / Logs / Describe）

Agent 使用场景：

1
# Agent 生成的 K8s 部署配置
2
apiVersion: apps/v1
3
kind: Deployment
4
metadata:
5
  name: myapp
6
  labels:
7
    app: myapp
8
spec:
9
  replicas: 3
10
  selector:
11
    matchLabels:
12
      app: myapp
13
  template:
14
    metadata:
15
      labels:
16
        app: myapp
17
    spec:
18
      containers:
19
      - name: myapp
20
        image: myapp:latest
21
        ports:
22
        - containerPort: 3000
23
        resources:
24
          requests:
25
            memory: "256Mi"
26
            cpu: "250m"
27
          limits:
28
            memory: "512Mi"
29
            cpu: "500m"
30
        livenessProbe:
31
          httpGet:
32
            path: /health
33
            port: 3000
34
          initialDelaySeconds: 30
35
          periodSeconds: 10
36
        readinessProbe:
37
          httpGet:
38
            path: /ready
39
            port: 3000
40
          initialDelaySeconds: 5
41
          periodSeconds: 5

展开收起

Terminal window

1
# Agent 排查集群问题
2
kubectl get pods -A | grep -v Running
3
kubectl describe pod <failing-pod>
4
kubectl logs <failing-pod> --tail=100
5
kubectl top pods --sort-by=memory

典型指令：

1
检查生产集群中所有非 Running 状态的 Pod，
2
分析失败原因并给出修复建议。

3. Terraform MCP Server 🏗️#

类别： 基础设施即代码 协议： MCP

Terraform 是 IaC（Infrastructure as Code）的领导者。Agent 用它可以声明式地管理云基础设施。

能力说明：

编写 HCL 配置文件
执行 plan / apply / destroy
状态管理
模块化设计
多云支持

Agent 使用场景：

1
# Agent 生成的 VPC 和 EKS 配置
2
module "vpc" {
3
  source  = "terraform-aws-modules/vpc/aws"
4
  version = "5.0.0"
5

6
  name = "my-vpc"
7
  cidr = "10.0.0.0/16"
8

9
  azs             = ["us-east-1a", "us-east-1b", "us-east-1c"]
10
  private_subnets = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
11
  public_subnets  = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]
12

13
  enable_nat_gateway = true
14
  single_nat_gateway = true
15

16
  tags = {
17
    Environment = "production"
18
    ManagedBy   = "terraform"
19
  }
20
}
21

22
module "eks" {
23
  source          = "terraform-aws-modules/eks/aws"
24
  version         = "19.0.0"
25

26
  cluster_name    = "my-cluster"
27
  cluster_version = "1.28"
28

29
  vpc_id     = module.vpc.vpc_id
30
  subnet_ids = module.vpc.private_subnets
31

32
  eks_managed_node_groups = {
33
    general = {
34
      desired_size = 3
35
      min_size     = 2
36
      max_size     = 10
37

38
      instance_types = ["t3.medium"]
39
    }
40
  }
41
}

展开收起

典型指令：

1
用 Terraform 在 AWS 上搭建一个 EKS 集群，
2
包含 VPC、子网、NAT 网关、安全组，
3
要求支持多可用区和自动扩缩容。

4. AWS CLI / SDK ☁️#

类别： 云服务 适用工具： AWS CLI / Boto3

AWS 是全球最大的云平台。Agent 掌握 AWS CLI/SDK，就能管理 EC2、S3、Lambda、RDS 等数百种服务。

能力说明：

EC2 实例管理
S3 存储操作
Lambda 函数部署
RDS 数据库管理
IAM 权限管理
CloudWatch 监控

Agent 使用场景：

Terminal window

1
# Agent 管理 S3 存储
2
aws s3 ls s3://my-bucket/ --recursive --human-readable
3
aws s3 cp ./dist/ s3://my-bucket/releases/v1.0/ --recursive
4
aws s3 sync ./data/ s3://my-bucket/data/ --delete
5

6
# Agent 查看 EC2 实例状态
7
aws ec2 describe-instances --query 'Reservations[*].Instances[*].[InstanceId,State.Name,InstanceType]' --output table
8

9
# Agent 部署 Lambda
10
aws lambda update-function-code \
11
  --function-name my-function \
12
  --zip-file fileb://function.zip

1
# Agent 用 Boto3 自动化运维
2
import boto3
3

4
def cleanup_old_snapshots(days=30):
5
    ec2 = boto3.client('ec2')
6
    cutoff = datetime.now() - timedelta(days=days)
7

8
    snapshots = ec2.describe_snapshots(OwnerIds=['self'])
9
    for snap in snapshots['Snapshots']:
10
        if snap['StartTime'].replace(tzinfo=None) < cutoff:
11
            ec2.delete_snapshot(SnapshotId=snap['SnapshotId'])
12
            print(f"Deleted snapshot: {snap['SnapshotId']}")

典型指令：

1
检查 AWS 账号中所有未绑定的 EIP 和未挂载的 EBS 卷，
2
这些是浪费成本的闲置资源，列出它们并计算每月浪费的费用。

5. CI/CD Pipeline 🔄#

类别： 持续集成/持续部署 适用工具： GitHub Actions / GitLab CI / CircleCI

CI/CD 是现代开发的基础设施。Agent 可以编写和优化 CI/CD 流水线，实现代码从提交到上线的全自动化。

能力说明：

流水线配置编写
构建、测试、部署自动化
缓存优化
矩阵构建
环境管理

Agent 使用场景：

1
# Agent 生成的 GitHub Actions 工作流
2
name: CI/CD Pipeline
3

4
on:
5
  push:
6
    branches: [main]
7
  pull_request:
8
    branches: [main]
9

10
jobs:
11
  test:
12
    runs-on: ubuntu-latest
13
    strategy:
14
      matrix:
15
        node-version: [18, 20, 22]
16
    steps:
17
      - uses: actions/checkout@v4
18
      - uses: actions/setup-node@v4
19
        with:
20
          node-version: ${{ matrix.node-version }}
21
          cache: 'pnpm'
22
      - run: pnpm install --frozen-lockfile
23
      - run: pnpm run lint
24
      - run: pnpm run type-check
25
      - run: pnpm run test --coverage
26
      - uses: codecov/codecov-action@v3
27

28
  deploy:
29
    needs: test
30
    if: github.ref == 'refs/heads/main'
31
    runs-on: ubuntu-latest
32
    environment: production
33
    steps:
34
      - uses: actions/checkout@v4
35
      - name: Deploy to production
36
        run: |
37
          docker build -t myapp:${{ github.sha }} .
38
          docker push myregistry/myapp:${{ github.sha }}
39
          kubectl set image deployment/myapp myapp=myregistry/myapp:${{ github.sha }}

展开收起

典型指令：

1
为这个项目编写 GitHub Actions 工作流，
2
包含 lint、test、build、deploy 四个阶段，
3
main 分支部署到生产环境，其他分支部署到预览环境。

6. 日志收集与分析 📋#

类别： 可观测性 适用工具： ELK Stack / Loki / CloudWatch Logs

日志是排查问题的第一手资料。Agent 可以分析日志、发现异常、生成报告。

能力说明：

日志查询和过滤
错误模式识别
日志聚合分析
告警规则配置

Agent 使用场景：

Terminal window

1
# Agent 分析 Nginx 访问日志
2
# 找出最近 1 小时的 5xx 错误
3
awk '$9 >= 500 && $9 < 600 {print $0}' /var/log/nginx/access.log | tail -50
4

5
# 统计每个 IP 的请求数，找出异常高频 IP
6
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20
7

8
# 分析慢请求
9
awk '$NF > 5 {print $7, $NF"s"}' /var/log/nginx/access.log | sort -t' ' -k2 -rn | head -20

1
# Agent 用 Python 分析应用日志
2
import re
3
from collections import Counter
4

5
def analyze_logs(log_file):
6
    error_pattern = re.compile(r'ERROR.*?(\w+Error): (.+)')
7
    errors = Counter()
8

9
    with open(log_file) as f:
10
        for line in f:
11
            match = error_pattern.search(line)
12
            if match:
13
                error_type, message = match.groups()
14
                errors[f"{error_type}: {message[:50]}"] += 1
15

16
    print("🔥 Top Errors:")
17
    for error, count in errors.most_common(10):
18
        print(f"  {count:5d} | {error}")

展开收起

典型指令：

1
分析最近 24 小时的应用日志，
2
找出最频繁的 10 种错误，
3
统计每种错误的出现次数和影响的用户数。

7. 监控与告警 🚨#

类别： 可观测性 适用工具： Prometheus / Grafana / PagerDuty

监控是系统的”眼睛”，告警是系统的”嘴”。Agent 可以配置监控指标、设置告警规则、分析告警趋势。

能力说明：

指标查询（PromQL）
仪表板管理（Grafana）
告警规则配置
告警分析和降噪

Agent 使用场景：

1
# Agent 生成的 Prometheus 告警规则
2
groups:
3
  - name: application
4
    rules:
5
      - alert: HighErrorRate
6
        expr: |
7
          sum(rate(http_requests_total{status=~"5.."}[5m]))
8
          /
9
          sum(rate(http_requests_total[5m]))
10
          > 0.05
11
        for: 5m
12
        labels:
13
          severity: critical
14
        annotations:
15
          summary: "High error rate detected"
16
          description: "Error rate is {{ $value | humanizePercentage }} (threshold: 5%)"
17

18
      - alert: HighLatency
19
        expr: |
20
          histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m])) > 2
21
        for: 10m
22
        labels:
23
          severity: warning
24
        annotations:
25
          summary: "High P95 latency"
26
          description: "P95 latency is {{ $value }}s (threshold: 2s)"

展开收起

Terminal window

1
# Agent 查询 Prometheus 指标
2
curl -s 'http://prometheus:9090/api/v1/query?query=up' | jq '.data.result[] | {instance: .metric.instance, value: .value[1]}'

典型指令：

1
检查当前所有活跃的告警，分析是否有误报，
2
如果有告警风暴（同类型告警超过 10 条），给出降噪建议。

8. Cloudflare MCP Server 🌐#

类别： 边缘计算 协议： MCP

Cloudflare 是全球最大的 CDN 和边缘计算平台，覆盖全球 300+ 城市。通过 MCP Server，Agent 可以直接管理 Cloudflare 的全套服务——从 Workers 部署到 DNS 配置，从安全规则到 KV 存储，一句话搞定边缘侧的一切。

能力说明：

Workers 部署与管理（Serverless 边缘函数）
DNS 记录管理（A / CNAME / MX / TXT）
CDN 配置与缓存规则
安全规则（WAF、防火墙、Rate Limiting）
KV 存储（全球分布式键值数据库）

Agent 使用场景：

1
// Agent 通过 MCP 调用 Cloudflare 能力
2
// 部署一个 Worker 到边缘节点
3
await mcp.call("cloudflare", "deploy_worker", {
4
  name: "api-gateway",
5
  script: `
6
    export default {
7
      async fetch(request, env) {
8
        const url = new URL(request.url);
9
        // 从 KV 读取路由配置
10
        const route = await env.ROUTER_KV.get(url.pathname);
11
        if (route) {
12
          return fetch(route + url.pathname + url.search);
13
        }
14
        return new Response("Not Found", { status: 404 });
15
      }
16
    }
17
  `,
18
  bindings: [{ name: "ROUTER_KV", type: "kv_namespace" }]
19
});
20

21
// 配置 DNS 记录
22
await mcp.call("cloudflare", "dns_create", {
23
  zone: "example.com",
24
  type: "A",
25
  name: "api",
26
  content: "1.2.3.4",
27
  proxied: true
28
});
29

30
// 设置 WAF 安全规则
31
await mcp.call("cloudflare", "firewall_rule_create", {
32
  zone: "example.com",
33
  expression: '(http.request.uri.path contains "/admin") and not ip.src in {10.0.0.0/8}',
34
  action: "block"
35
});

展开收起

典型指令：

1
帮我在 Cloudflare 上部署一个 Worker 作为 API 网关，
2
配置路由规则，设置对应的 DNS 记录，
3
并对 /admin 路径启用 WAF 防护。

9. 代码执行沙箱 🧪#

类别： 代码运行 适用工具： E2B / Daytona / 自定义沙箱

代码执行沙箱让 Agent 能安全地运行代码——在隔离环境中执行 Python、Node.js 等脚本，不会影响宿主系统。这是 Agent 从”建议者”进化为”执行者”的关键能力。

能力说明：

Python / Node.js 代码执行
包安装（pip / npm，支持自定义依赖）
文件系统访问（读写临时文件）
超时控制（防止死循环和长时间运行）
环境隔离（每次执行互不干扰）

Agent 使用场景：

1
// Agent 通过 E2B 沙箱执行数据分析代码
2
import { Sandbox } from "@e2b/code-interpreter";
3

4
const sandbox = await Sandbox.create();
5

6
// 安装依赖并执行 Python 脚本
7
const result = await sandbox.runCode(`
8
import pandas as pd
9
import matplotlib.pyplot as plt
10

11
# 读取数据
12
df = pd.read_csv('/tmp/sales.csv')
13

14
# 数据分析
15
monthly = df.groupby('month')['revenue'].sum()
16
print("月度收入汇总:")
17
print(monthly.to_string())
18

19
# 生成图表
20
plt.figure(figsize=(10, 6))
21
monthly.plot(kind='bar', color='#6366f1')
22
plt.title('Monthly Revenue')
23
plt.savefig('/tmp/chart.png', dpi=150, bbox_inches='tight')
24
print("图表已保存")
25
`);
26

27
console.log(result.logs.stdout.join('\n'));
28

29
// 读取生成的文件
30
const chart = await sandbox.files.read('/tmp/chart.png');
31
await sandbox.kill(); // 用完销毁，不留痕迹

展开收起

1
// Agent 用沙箱验证代码片段
2
const sandbox = await Sandbox.create({ timeoutMs: 30000 });
3

4
const testResult = await sandbox.runCode(`
5
def fibonacci(n):
6
    if n <= 1:
7
        return n
8
    a, b = 0, 1
9
    for _ in range(2, n + 1):
10
        a, b = b, a + b
11
    return b
12

13
# 测试
14
for i in [10, 50, 100]:
15
    print(f"fib({i}) = {fibonacci(i)}")
16
`);
17

18
console.log(testResult.logs.stdout);
19
await sandbox.kill();

展开收起

典型指令：

1
在沙箱中运行这段 Python 代码，帮我处理这份 CSV 数据，
2
生成可视化图表，然后把结果文件下载回来。

10. 多云管理 🌍#

类别： 云架构 适用工具： Pulumi / Crossplane / 对 Terraform 的多 Provider 使用

多云策略可以避免供应商锁定，但也带来管理复杂性。Agent 可以帮助统一管理多云资源。

能力说明：

跨云资源编排
统一监控和日志
成本对比分析
灾难恢复规划

Agent 使用场景：

1
// Agent 用 Pulumi 管理多云资源
2
import * as aws from "@pulumi/aws";
3
import * as gcp from "@pulumi/gcp";
4

5
// AWS 上部署主应用
6
const appCluster = new aws.ecs.Cluster("app-cluster");
7
const appService = new aws.ecs.Service("app-service", {
8
  cluster: appCluster.arn,
9
  desiredCount: 3,
10
  taskDefinition: appTaskDef.arn,
11
});
12

13
// GCP 上部署数据分析
14
const dataCluster = new gcp.container.Cluster("data-cluster", {
15
  initialNodeCount: 3,
16
  nodeConfig: {
17
    machineType: "e2-standard-4",
18
  },
19
});
20

21
// 跨云数据同步
22
const dataSync = new aws.s3.Bucket("data-sync");
23
const gcsBucket = new gcp.storage.Bucket("gcs-backup");

展开收起

典型指令：

1
设计一个多云架构：主应用在 AWS，数据备份在 GCP，
2
CDN 用 Cloudflare，监控用 Datadog。
3
画出架构图并给出 Terraform 配置。

本篇小结#

#	Skill	类别	难度	价值
1	Docker	容器化	⭐⭐	⭐⭐⭐⭐⭐
2	Kubernetes	容器编排	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
3	Terraform	IaC	⭐⭐⭐	⭐⭐⭐⭐⭐
4	AWS CLI/SDK	云服务	⭐⭐⭐	⭐⭐⭐⭐⭐
5	CI/CD Pipeline	持续部署	⭐⭐	⭐⭐⭐⭐⭐
6	日志分析	可观测性	⭐⭐⭐	⭐⭐⭐⭐
7	监控告警	可观测性	⭐⭐⭐	⭐⭐⭐⭐⭐
8	Cloudflare MCP	边缘计算	⭐⭐	⭐⭐⭐⭐
9	代码执行沙箱	代码运行	⭐⭐	⭐⭐⭐⭐⭐
10	多云管理	云架构	⭐⭐⭐⭐	⭐⭐⭐⭐

核心观点： DevOps Skills 是 Agent 的”交付能力”。一个能写 Dockerfile、配置 K8s、管理 CI/CD 的 Agent，才真正具备从代码到上线的全链路能力。

系列导航#

👈 上一篇： 第四篇：搜索与信息获取
👉 下一篇： 第六篇：知识管理与 RAG

100 个 Agent Skills 盘点（六）：知识管理与 RAG

Sun, 14 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第六篇。这一篇聚焦一个非常热门的领域：知识管理与 RAG（检索增强生成）。

为什么 RAG 是 Agent 的”大脑升级”？

LLM 的知识有截止日期，且不了解你的私有数据。RAG 让 Agent 能够：

📚 访问企业内部文档
🔍 基于最新信息回答问题
🧠 维护长期记忆
📖 引用信息来源

没有 RAG 的 Agent 是”博学但过时的学者”，有 RAG 的 Agent 是”实时联网的专家”。

1. Chroma 向量数据库 🟣#

类别： 向量存储 协议： 直接集成 / MCP

Chroma 是最轻量的开源向量数据库，适合快速原型和小规模应用。Agent 可以用几行代码就搭建起 RAG 系统。

能力说明：

向量存储和检索
元数据过滤
自动 Embedding
持久化存储

Agent 使用场景：

1
# Agent 构建简单的 RAG 系统
2
import chromadb
3
from chromadb.utils import embedding_functions
4

5
# 初始化
6
client = chromadb.PersistentClient(path="./chroma_db")
7
ef = embedding_functions.OpenAIEmbeddingFunction(api_key="sk-...")
8
collection = client.get_or_create_collection(
9
    name="documents",
10
    embedding_function=ef
11
)
12

13
# 添加文档
14
collection.add(
15
    documents=["Python 是一种解释型语言", "JavaScript 运行在浏览器中"],
16
    metadatas=[{"source": "wiki"}, {"source": "mdn"}],
17
    ids=["doc1", "doc2"]
18
)
19

20
# 检索
21
results = collection.query(
22
    query_texts=["什么是编程语言？"],
23
    n_results=5,
24
    where={"source": "wiki"}  # 元数据过滤
25
)

展开收起

典型指令：

1
把项目的技术文档导入 Chroma，
2
然后实现一个基于 RAG 的文档问答系统，
3
用户提问时检索相关文档片段并生成回答。

2. Pinecone 向量数据库 🌲#

类别： 云向量存储 协议： REST API / SDK

Pinecone 是最受欢迎的云向量数据库，无需运维，自动扩展，适合生产环境。

能力说明：

全托管向量存储
高性能 ANN 检索
元数据过滤
命名空间隔离
自动扩缩容

Agent 使用场景：

1
# Agent 构建生产级 RAG
2
import pinecone
3

4
pinecone.init(api_key="YOUR_API_KEY", environment="us-east-1-aws")
5

6
# 创建索引
7
index = pinecone.Index("knowledge-base")
8

9
# 批量上传向量
10
vectors = [
11
    (f"doc_{i}", embedding, {"text": text, "source": source})
12
    for i, (text, source, embedding) in enumerate(documents)
13
]
14
index.upsert(vectors=vectors, namespace="production")
15

16
# 检索
17
results = index.query(
18
    vector=query_embedding,
19
    top_k=10,
20
    namespace="production",
21
    filter={"source": {"$eq": "official_docs"}},
22
    include_metadata=True
23
)

展开收起

典型指令：

1
在 Pinecone 中建立知识库索引，
2
导入我们所有的产品文档，
3
然后实现语义搜索功能。

3. Qdrant 向量数据库 ⚡#

类别： 高性能向量存储 协议： REST API / gRPC / MCP

Qdrant 是 Rust 编写的高性能向量数据库，支持复杂的过滤条件和多向量检索。

能力说明：

高性能向量检索
复杂过滤条件
多向量支持（同一文档多个 Embedding）
分布式部署
量化压缩

Agent 使用场景：

1
# Agent 使用 Qdrant 构建多模态 RAG
2
from qdrant_client import QdrantClient
3
from qdrant_client.models import Distance, VectorParams, PointStruct
4

5
client = QdrantClient(host="localhost", port=6333)
6

7
# 创建集合（支持多向量）
8
client.create_collection(
9
    collection_name="multimodal",
10
    vectors_config={
11
        "text": VectorParams(size=1536, distance=Distance.COSINE),
12
        "image": VectorParams(size=512, distance=Distance.COSINE)
13
    }
14
)
15

16
# 检索时可以指定使用哪个向量
17
results = client.query_points(
18
    collection_name="multimodal",
19
    using="text",  # 使用文本向量检索
20
    query=text_embedding,
21
    query_filter={
22
        "must": [
23
            {"key": "category", "match": {"value": "technical"}},
24
            {"key": "date", "range": {"gte": "2026-01-01"}}
25
        ]
26
    }
27
)

展开收起

典型指令：

1
在 Qdrant 中建立支持文本和图片的多模态知识库，
2
用户可以用文字搜索图片，也可以用图片搜索相关文档。

4. Weaviate 向量数据库 🌊#

类别： AI 原生向量数据库 协议： REST API / GraphQL / MCP

Weaviate 是一个 AI 原生的向量数据库，内置 Embedding 模型，支持混合搜索（向量 + 关键词）。

能力说明：

内置 Embedding 模型
混合搜索（向量 + BM25）
GraphQL 查询接口
多模态支持
自动 Schema 推断

Agent 使用场景：

1
# Agent 使用 Weaviate 混合搜索
2
import weaviate
3

4
client = weaviate.Client("http://localhost:8080")
5

6
# 混合搜索：结合语义和关键词
7
result = (
8
    client.query
9
    .get("Document", ["title", "content", "source"])
10
    .with_hybrid(
11
        query="AI agent 最佳实践",
12
        alpha=0.75  # 0=纯关键词, 1=纯向量
13
    )
14
    .with_where({
15
        "path": ["category"],
16
        "operator": "Equal",
17
        "valueString": "technical"
18
    })
19
    .with_limit(10)
20
    .do()
21
)

展开收起

典型指令：

1
用 Weaviate 搭建一个支持混合搜索的知识库，
2
对中文文档同时使用语义搜索和关键词搜索，
3
对比两种搜索方式的效果。

5. Embedding 模型服务 📐#

类别： 文本向量化 适用工具： OpenAI Embedding / Cohere / Jina / BGE

Embedding 是 RAG 的基础——把文本转换为向量，才能进行语义搜索。选择合适的 Embedding 模型直接影响 RAG 的效果。

能力说明：

文本向量化
多语言支持
批量处理
维度选择

Agent 使用场景：

1
# Agent 使用不同的 Embedding 模型
2
from openai import OpenAI
3
import requests
4

5
# OpenAI Embedding
6
def get_openai_embedding(text):
7
    client = OpenAI()
8
    response = client.embeddings.create(
9
        model="text-embedding-3-small",
10
        input=text
11
    )
12
    return response.data[0].embedding
13

14
# Jina Embedding（免费、多语言）
15
def get_jina_embedding(text):
16
    response = requests.post(
17
        "https://api.jina.ai/v1/embeddings",
18
        headers={"Authorization": f"Bearer {JINA_API_KEY}"},
19
        json={
20
            "model": "jina-embeddings-v3",
21
            "input": [text]
22
        }
23
    )
24
    return response.json()["data"][0]["embedding"]
25

26
# 本地 BGE 模型（免费、隐私友好）
27
from sentence_transformers import SentenceTransformer
28
model = SentenceTransformer("BAAI/bge-large-zh-v1.5")
29
embedding = model.encode("什么是 RAG？")

展开收起

常用 Embedding 模型对比：

模型	维度	多语言	价格	适用场景
text-embedding-3-small	1536	✅	$0.02/1M tokens	通用
text-embedding-3-large	3072	✅	$0.13/1M tokens	高精度
Jina v3	1024	✅	免费额度	多语言
BGE-large-zh	1024	中文优先	免费(本地)	中文场景

6. 文档分块策略 📄#

类别： 数据处理 适用工具： LangChain / LlamaIndex / 自定义

文档分块（Chunking）是 RAG 中最关键的环节之一。分块策略直接影响检索质量。

能力说明：

按句子/段落/语义分块
重叠窗口（Overlap）
递归分块
语义分块

Agent 使用场景：

1
# Agent 实现多种分块策略
2
from langchain.text_splitter import (
3
    RecursiveCharacterTextSplitter,
4
    MarkdownHeaderTextSplitter
5
)
6

7
# 1. 递归分块（最常用）
8
splitter = RecursiveCharacterTextSplitter(
9
    chunk_size=500,
10
    chunk_overlap=50,
11
    separators=["\n\n", "\n", "。", "！", "？", ".", " "]
12
)
13
chunks = splitter.split_text(document)
14

15
# 2. Markdown 标题分块（保留结构）
16
headers_to_split = [
17
    ("#", "h1"),
18
    ("##", "h2"),
19
    ("###", "h3"),
20
]
21
md_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split)
22
chunks = md_splitter.split_text(markdown_document)
23

24
# 3. 语义分块（基于 Embedding 相似度）
25
def semantic_chunk(text, threshold=0.8):
26
    sentences = split_into_sentences(text)
27
    chunks = []
28
    current_chunk = [sentences[0]]
29

30
    for i in range(1, len(sentences)):
31
        similarity = cosine_sim(
32
            get_embedding(sentences[i]),
33
            get_embedding(current_chunk[-1])
34
        )
35
        if similarity > threshold:
36
            current_chunk.append(sentences[i])
37
        else:
38
            chunks.append(" ".join(current_chunk))
39
            current_chunk = [sentences[i]]
40

41
    return chunks

展开收起

分块策略对比：

策略	优点	缺点	适用场景
固定大小	简单	可能切断语义	快速原型
递归	保留结构	需调参	通用
Markdown 标题	保留层级	仅限 Markdown	文档
语义	最智能	计算量大	高质量 RAG

7. RAG Pipeline 框架 🔧#

类别： RAG 编排 适用工具： LlamaIndex / LangChain / Haystack

RAG 框架把 Embedding、检索、生成等环节串联起来，让 Agent 能快速构建 RAG 应用。

能力说明：

文档加载和解析
向量索引构建
查询引擎
响应合成

Agent 使用场景：

1
# Agent 使用 LlamaIndex 构建 RAG
2
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
3
from llama_index.core.node_parser import SentenceSplitter
4

5
# 加载文档
6
documents = SimpleDirectoryReader("./docs").load_data()
7

8
# 构建索引
9
index = VectorStoreIndex.from_documents(
10
    documents,
11
    transformations=[
12
        SentenceSplitter(chunk_size=512, chunk_overlap=50)
13
    ]
14
)
15

16
# 创建查询引擎
17
query_engine = index.as_query_engine(
18
    similarity_top_k=5,
19
    response_mode="tree_summarize"  # 多文档综合
20
)
21

22
# 查询
23
response = query_engine.query("如何配置 RAG 系统？")
24
print(response)
25
print("Sources:", response.source_nodes)

展开收起

1
# Agent 使用 LangChain 构建 RAG
2
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
3
from langchain_community.vectorstores import Chroma
4
from langchain.chains import RetrievalQA
5

6
vectorstore = Chroma.from_documents(docs, OpenAIEmbeddings())
7
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})
8

9
qa_chain = RetrievalQA.from_chain_type(
10
    llm=ChatOpenAI(model="gpt-4"),
11
    retriever=retriever,
12
    return_source_documents=True
13
)
14

15
result = qa_chain.invoke({"query": "什么是 Agent Skills？"})

展开收起

8. Agent 记忆系统 🧠#

类别： 长期记忆 适用工具： Mem0 / Zep / 自定义

Agent 的记忆系统让它能在多次对话中保持上下文，记住用户偏好，学习历史交互。

能力说明：

短期记忆（对话上下文）
长期记忆（跨会话持久化）
用户偏好记忆
事实记忆

Agent 使用场景：

1
# Agent 使用 Mem0 管理记忆
2
from mem0 import Memory
3

4
memory = Memory()
5

6
# 存储记忆
7
memory.add("用户喜欢用 Python 写后端，TypeScript 写前端", user_id="raymin")
8
memory.add("用户的项目使用 Next.js + Supabase 技术栈", user_id="raymin")
9
memory.add("用户偏好简洁的代码风格，不喜欢过度抽象", user_id="raymin")
10

11
# 检索相关记忆
12
relevant = memory.search("帮我写一个新的 API", user_id="raymin")
13
# 返回：用户的语言偏好、技术栈、代码风格偏好
14

15
# 基于记忆个性化回答
16
context = "\n".join([m["text"] for m in relevant])
17
response = llm.generate(
18
    f"基于以下用户偏好回答问题：\n{context}\n\n问题：帮我写一个新的 API"
19
)

展开收起

典型指令：

1
记住我的技术偏好：Python + FastAPI 后端，
2
React + TypeScript 前端，PostgreSQL 数据库。
3
下次帮我写代码时自动应用这些偏好。

9. 知识图谱 🕸️#

类别： 结构化知识 适用工具： Neo4j / Memgraph / 自定义

知识图谱用实体和关系表示知识，比纯向量检索更适合处理复杂的关联查询。

能力说明：

实体识别和关系抽取
图查询（Cypher）
路径查找
图 RAG（GraphRAG）

Agent 使用场景：

1
# Agent 构建技术知识图谱
2
from neo4j import GraphDatabase
3

4
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "password"))
5

6
def create_knowledge_graph(tech_docs):
7
    with driver.session() as session:
8
        for doc in tech_docs:
9
            # 创建技术实体
10
            session.run("""
11
                MERGE (t:Technology {name: $name})
12
                SET t.category = $category,
13
                    t.description = $description
14
            """, name=doc["name"], category=doc["category"], desc=doc["desc"])
15

16
            # 创建依赖关系
17
            for dep in doc["dependencies"]:
18
                session.run("""
19
                    MATCH (a:Technology {name: $from})
20
                    MATCH (b:Technology {name: $to})
21
                    MERGE (a)-[:DEPENDS_ON]->(b)
22
                """, **{"from": doc["name"], "to": dep})
23

24
# 查询：找到从 React 到 PostgreSQL 的依赖路径
25
def find_dependency_path(from_tech, to_tech):
26
    with driver.session() as session:
27
        result = session.run("""
28
            MATCH path = shortestPath(
29
                (a:Technology {name: $from})-[*]-(b:Technology {name: $to})
30
            )
31
            RETURN [n IN nodes(path) | n.name] AS path
32
        """, **{"from": from_tech, "to": to_tech})
33
        return result.single()["path"]

展开收起

典型指令：

1
分析我们项目的技术依赖关系，构建知识图谱，
2
找出所有间接依赖，识别潜在的技术风险。

10. 上下文窗口管理 📐#

类别： 上下文优化 适用工具： 自定义策略

LLM 的上下文窗口有限（4K-200K tokens）。Agent 需要智能地管理上下文，在有限的窗口中放入最有价值的信息。

能力说明：

上下文压缩
相关性排序
滑动窗口
摘要生成

Agent 使用场景：

1
# Agent 智能上下文管理
2
class ContextManager:
3
    def __init__(self, max_tokens=8000):
4
        self.max_tokens = max_tokens
5
        self.history = []
6
        self.system_prompt = ""
7

8
    def add_message(self, role, content):
9
        self.history.append({"role": role, "content": content})
10
        self._trim_context()
11

12
    def _trim_context(self):
13
        """智能裁剪上下文"""
14
        total = self._count_tokens()
15

16
        while total > self.max_tokens and len(self.history) > 2:
17
            # 策略1：压缩早期对话
18
            if len(self.history) > 4:
19
                early = self.history[:2]
20
                summary = self._summarize(early)
21
                self.history = [{"role": "system", "content": f"之前的对话摘要：{summary}"}] + self.history[2:]
22

23
            # 策略2：移除低价值消息
24
            if total > self.max_tokens:
25
                self._remove_low_value_messages()
26

27
            total = self._count_tokens()
28

29
    def _remove_low_value_messages(self):
30
        """移除低价值消息（工具调用的中间结果等）"""
31
        for i, msg in enumerate(self.history):
32
            if msg["role"] == "tool" and i > 0:
33
                self.history.pop(i)
34
                break

展开收起

上下文管理策略对比：

策略	原理	优点	缺点
截断	移除最早的消息	简单	丢失信息
摘要	压缩早期对话	保留要点	需要额外调用
滑动窗口	只保留最近 N 轮	节省 token	丢失长期上下文
相关性	只保留相关消息	精准	计算量大

本篇小结#

#	Skill	类别	难度	价值
1	Chroma	向量存储	⭐	⭐⭐⭐⭐
2	Pinecone	云向量存储	⭐⭐	⭐⭐⭐⭐⭐
3	Qdrant	高性能向量	⭐⭐	⭐⭐⭐⭐
4	Weaviate	AI 原生向量	⭐⭐	⭐⭐⭐⭐
5	Embedding 模型	文本向量化	⭐⭐	⭐⭐⭐⭐⭐
6	文档分块	数据处理	⭐⭐⭐	⭐⭐⭐⭐⭐
7	RAG 框架	RAG 编排	⭐⭐	⭐⭐⭐⭐⭐
8	记忆系统	长期记忆	⭐⭐⭐	⭐⭐⭐⭐
9	知识图谱	结构化知识	⭐⭐⭐⭐	⭐⭐⭐⭐
10	上下文管理	上下文优化	⭐⭐⭐	⭐⭐⭐⭐⭐

核心观点： 知识管理 Skills 是 Agent 的”大脑升级包”。没有 RAG 的 Agent 只能用训练数据回答问题；有了 RAG，Agent 能访问最新信息、私有知识、长期记忆，真正成为”专家级助手”。

系列导航#

👈 上一篇： 第五篇：云服务与 DevOps
👉 下一篇： 第七篇：版本控制与协作

100 个 Agent Skills 盘点（七）：版本控制与协作

Sat, 13 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第七篇。这一篇聚焦开发者每天都在用的工具链：版本控制与协作。

Git + GitHub/GitLab 不只是代码管理工具，它是现代软件开发的”协作基础设施”。Agent 掌握这些 Skills，就能融入团队工作流，而不只是一个”孤独的编码者”。

1. Git 基础操作 📦#

类别： 版本控制 适用工具： Git CLI

Git 操作是 Agent 最基础的能力——创建分支、提交代码、合并冲突、查看历史。

能力说明：

分支管理（branch / checkout / switch）
提交操作（add / commit / push / pull）
合并与变基（merge / rebase）
冲突解决
历史查看（log / blame / bisect）

Agent 使用场景：

Terminal window展开收起

1
# Agent 管理功能分支工作流
2
git checkout -b feature/user-auth
3
# ... 编写代码 ...
4
git add -A
5
git commit -m "feat(auth): implement JWT authentication
6

7
- Add login/register endpoints
8
- Add JWT token generation and validation
9
- Add auth middleware for protected routes
10
- Add refresh token mechanism
11

12
Closes #123"
13

14
# 保持与 main 同步
15
git fetch origin
16
git rebase origin/main
17

18
# 推送并创建 PR
19
git push -u origin feature/user-auth

展开收起

Terminal window

1
# Agent 用 bisect 定位 Bug
2
git bisect start
3
git bisect bad HEAD
4
git bisect good v1.0.0
5
# Git 会自动选择中间的 commit 让你测试
6
# Agent 运行测试，标记 good/bad
7
git bisect run npm test
8
# Git 自动找到引入 Bug 的 commit

典型指令：

1
从 main 创建一个新分支 feature/payment，
2
实现支付宝支付接口，每完成一个逻辑单元就提交一次，
3
提交信息遵循 Conventional Commits 规范。

2. GitHub MCP Server 🐙#

类别： 代码托管平台 协议： MCP

GitHub MCP Server 让 Agent 能直接与 GitHub 交互——创建 Issue、管理 PR、查看 Actions、管理仓库。

能力说明：

Issue 创建和管理
PR 创建和审查
GitHub Actions 管理
仓库设置
代码搜索

Agent 使用场景：

1
// Agent 自动创建 PR
2
const pr = await github.createPullRequest({
3
  owner: "myorg",
4
  repo: "myproject",
5
  title: "feat: add user authentication",
6
  body: `## 改动说明
7
- 实现 JWT 认证
8
- 添加登录/注册 API
9
- 添加 auth 中间件
10

11
## 测试
12
- [x] 单元测试通过
13
- [x] 集成测试通过
14
- [ ] 手动测试
15

16
## 关联 Issue
17
Closes #123`,
18
  head: "feature/user-auth",
19
  base: "main"
20
});

展开收起

1
// Agent 自动审查 PR
2
const files = await github.listFiles(prNumber);
3
const comments = [];
4

5
for (const file of files) {
6
  if (file.filename.endsWith('.ts')) {
7
    const content = await github.getFileContent(file.filename);
8
    const issues = analyzeCode(content);
9

10
    if (issues.length > 0) {
11
      comments.push({
12
        path: file.filename,
13
        line: issues[0].line,
14
        body: `⚠️ ${issues[0].message}`
15
      });
16
    }
17
  }
18
}
19

20
await github.createReview(prNumber, comments);

展开收起

典型指令：

1
查看 repo 中所有打开的 Issue，
2
按 label 分类统计，找出标记为 "bug" 的 Issue 中
3
最近 7 天内没有回复的，创建一个汇总 Issue。

3. GitLab MCP Server 🦊#

类别： 代码托管平台 协议： MCP

GitLab 是 DevOps 一站式平台，集代码托管、CI/CD、容器注册、安全扫描于一体。

能力说明：

Merge Request 管理
CI/CD Pipeline 操作
Issue Board 管理
Container Registry
安全仪表板

Agent 使用场景：

1
// Agent 查看 Pipeline 状态
2
const pipelines = await gitlab.listPipelines({
3
  projectId: 12345,
4
  status: "failed",
5
  orderBy: "updated_at"
6
});
7

8
for (const pipeline of pipelines) {
9
  const jobs = await gitlab.getPipelineJobs(pipeline.id);
10
  const failedJobs = jobs.filter(j => j.status === "failed");
11

12
  console.log(`Pipeline #${pipeline.id} failed:`);
13
  failedJobs.forEach(job => {
14
    console.log(`  ❌ ${job.name}: ${job.failure_reason}`);
15
  });
16
}

展开收起

典型指令：

1
查看我们项目最近 10 次 Pipeline 的状态，
2
找出失败的 Pipeline，分析失败原因，
3
如果是因为测试失败，列出失败的测试用例。

GitHub vs GitLab：

特性	GitHub	GitLab
CI/CD	GitHub Actions	GitLab CI (内置)
容器注册	需要 GHCR	内置
安全扫描	需要第三方	内置
自托管	GitHub Enterprise	社区版免费
生态	极丰富	一站式

4. Jira / Linear MCP Server 📋#

类别： 项目管理 协议： MCP

项目管理工具是团队协作的”中枢”。Agent 可以自动更新任务状态、创建子任务、生成进度报告。

能力说明：

Issue 创建和更新
Sprint 管理
看板操作
进度报告生成
自动化规则

Agent 使用场景：

1
// Agent 自动更新任务状态
2
async function updateTaskFromCommit(commitMessage) {
3
  // 从提交信息中提取 Issue ID
4
  const match = commitMessage.match(/(?:closes|fixes|refs)\s+#(\d+)/i);
5
  if (!match) return;
6

7
  const issueId = match[1];
8

9
  // 根据提交类型更新状态
10
  if (commitMessage.startsWith('fix')) {
11
    await linear.updateIssue(issueId, { status: 'In Review' });
12
  } else if (commitMessage.startsWith('feat')) {
13
    await linear.updateIssue(issueId, { status: 'Done' });
14
  }
15

16
  // 添加评论
17
  await linear.addComment(issueId, {
18
    body: `自动更新：代码已提交\n\`\`\`\n${commitMessage}\n\`\`\``
19
  });
20
}

展开收起

1
// Agent 生成 Sprint 报告
2
async function sprintReport(sprintId) {
3
  const issues = await linear.getIssues({ sprintId });
4

5
  const report = {
6
    total: issues.length,
7
    completed: issues.filter(i => i.status === 'Done').length,
8
    inProgress: issues.filter(i => i.status === 'In Progress').length,
9
    blocked: issues.filter(i => i.status === 'Blocked').length,
10
    stories: issues.filter(i => i.type === 'Story').length,
11
    bugs: issues.filter(i => i.type === 'Bug').length
12
  };
13

14
  report.completionRate = (report.completed / report.total * 100).toFixed(1) + '%';
15

16
  return report;
17
}

展开收起

典型指令：

1
查看当前 Sprint 的所有任务，
2
找出标记为 "Blocked" 的任务，分析阻塞原因，
3
生成一份 Sprint 进度报告。

5. Code Review 自动化 🔍#

类别： 代码审查 适用工具： GitHub API / 自定义

Agent 可以作为”第一审查者”，在人类审查之前先过一遍代码，提高审查效率。

能力说明：

Diff 分析
代码风格检查
安全问题检测
性能问题识别
审查意见生成

Agent 使用场景：

1
# Agent 智能 Code Review
2
async def review_pr(repo, pr_number):
3
    pr = await repo.get_pull(pr_number)
4
    files = pr.get_files()
5

6
    review_comments = []
7

8
    for file in files:
9
        if not file.filename.endswith(('.ts', '.tsx', '.js')):
10
            continue
11

12
        patch = file.patch
13
        issues = analyze_patch(patch)
14

15
        for issue in issues:
16
            review_comments.append({
17
                'path': file.filename,
18
                'line': issue['line'],
19
                'body': f"""
20
## {issue['severity']} {issue['title']}
21

22
{issue['description']}
23

24
**建议：**
25
{issue['suggestion']}
26

27
**参考：**
28
{issue.get('reference', '')}
29
"""
30
            })
31

32
    # 提交审查
33
    if review_comments:
34
        pr.create_review(
35
            body="## 自动审查报告\n\n发现了以下问题：",
36
            comments=review_comments,
37
            event="COMMENT"  # REQUEST_CHANGES / APPROVE
38
        )

展开收起

审查维度：

维度	检查项	严重性
安全	SQL 注入、XSS、密钥泄露	🔴 Critical
性能	N+1 查询、内存泄漏	🟡 Warning
风格	命名、格式、注释	🔵 Info
测试	覆盖率不足、缺少边界测试	🟡 Warning

6. Branch 策略管理 🌿#

类别： Git 工作流 适用工具： Git

好的分支策略是团队协作的基础。Agent 可以帮助管理和执行分支策略。

能力说明：

Git Flow 管理
GitHub Flow 管理
分支保护规则
自动合并

Agent 使用场景：

Terminal window展开收起

1
# Agent 执行 Git Flow
2
# 创建 release 分支
3
git checkout -b release/v2.1.0 develop
4

5
# 修复 release 中的 bug
6
git commit -m "fix: resolve login timeout issue"
7

8
# 合并到 main 并打 tag
9
git checkout main
10
git merge --no-ff release/v2.1.0
11
git tag -a v2.1.0 -m "Release v2.1.0"
12

13
# 合并回 develop
14
git checkout develop
15
git merge --no-ff release/v2.1.0
16

17
# 清理
18
git branch -d release/v2.1.0

展开收起

常见分支策略：

策略	适用场景	复杂度
GitHub Flow	小团队、持续部署	⭐
Git Flow	版本发布、大型项目	⭐⭐⭐
Trunk-Based	高成熟度团队	⭐⭐
GitLab Flow	环境分支	⭐⭐

7. 自动化 Release 📦#

类别： 发布管理 适用工具： semantic-release / Changesets

Agent 可以自动化版本发布流程——分析提交历史、生成 Changelog、创建 GitHub Release。

能力说明：

语义化版本号计算
Changelog 自动生成
GitHub Release 创建
npm / PyPI 发布

Agent 使用场景：

.releaserc.js

1
// semantic-release 配置
2
module.exports = {
3
  branches: ['main'],
4
  plugins: [
5
    '@semantic-release/commit-analyzer',    // 分析提交确定版本号
6
    '@semantic-release/release-notes-generator', // 生成 Release Notes
7
    '@semantic-release/changelog',          // 更新 CHANGELOG.md
8
    '@semantic-release/npm',                // 发布到 npm
9
    '@semantic-release/github',             // 创建 GitHub Release
10
    '@semantic-release/git'                 // 提交变更
11
  ]
12
};

Terminal window

1
# Agent 执行发布
2
npx semantic-release --dry-run  # 先预览
3
npx semantic-release             # 正式发布

版本号规则（SemVer）：

提交类型	版本变化	示例
`fix:`	Patch (1.0.0 → 1.0.1)	Bug 修复
`feat:`	Minor (1.0.0 → 1.1.0)	新功能
`BREAKING CHANGE:`	Major (1.0.0 → 2.0.0)	破坏性变更

8. Issue 模板与自动化 📝#

类别： 项目管理 适用工具： GitHub Issue Templates

好的 Issue 模板能提高 Bug 报告和功能请求的质量。Agent 可以帮助设计和维护模板。

能力说明：

Bug 报告模板
功能请求模板
Issue 自动分类
Issue 自动关闭

Agent 使用场景：

.github/ISSUE_TEMPLATE/bug_report.yml展开收起

1
name: Bug Report
2
description: 报告一个 Bug
3
labels: ["bug", "triage"]
4
body:
5
  - type: markdown
6
    attributes:
7
      value: |
8
        感谢你报告 Bug！请填写以下信息帮助我们快速定位问题。
9

10
  - type: textarea
11
    id: description
12
    attributes:
13
      label: Bug 描述
14
      description: 简要描述你遇到的问题
15
      placeholder: 例：点击登录按钮后页面卡住不动
16
    validations:
17
      required: true
18

19
  - type: textarea
20
    id: steps
21
    attributes:
22
      label: 复现步骤
23
      description: 详细的复现步骤
24
      placeholder: |
25
        1. 打开登录页面
26
        2. 输入邮箱和密码
27
        3. 点击"登录"按钮
28
        4. 页面卡住不动
29
    validations:
30
      required: true
31

32
  - type: dropdown
33
    id: browser
34
    attributes:
35
      label: 浏览器
36
      options:
37
        - Chrome
38
        - Firefox
39
        - Safari
40
        - Edge
41
    validations:
42
      required: true
43

44
  - type: textarea
45
    id: logs
46
    attributes:
47
      label: 控制台日志
48
      description: 如果有错误日志，请粘贴在这里
49
      render: shell

展开收起

9. 代码搜索与导航 🔎#

类别： 代码探索 适用工具： GitHub Code Search / Sourcegraph

Agent 需要能在大型代码库中快速找到相关代码。代码搜索能力直接影响 Agent 的工作效率。

能力说明：

全文搜索
正则表达式搜索
跨仓库搜索
代码导航（跳转定义、查找引用）

Agent 使用场景：

Terminal window

1
# Agent 用 grep/ripgrep 搜索代码
2
# 找到所有使用某个 API 的地方
3
rg "getUserById" --type ts -l
4

5
# 找到所有 TODO 注释
6
rg "TODO|FIXME|HACK" --type ts
7

8
# 搜索特定文件中的模式
9
rg "export.*function.*async" --type ts -g "*.service.ts"
10

11
# 使用 GitHub 代码搜索 API
12
curl -H "Authorization: token $GITHUB_TOKEN" \
13
  "https://api.github.com/search/code?q=getUserById+language:typescript+repo:myorg/myrepo"

典型指令：

1
在代码库中搜索所有使用 deprecated API 的地方，
2
列出文件名、行号和具体的 API 调用，
3
按模块分组统计。

10. 团队协作最佳实践 👥#

类别： 协作流程 适用工具： 综合

Agent 不仅能执行具体操作，还能帮助团队建立和优化协作流程。

能力说明：

CONTRIBUTING.md 生成
PR 模板设计
代码规范配置
自动化工作流

Agent 使用场景：

1
# Agent 生成的 CONTRIBUTING.md
2
# 贡献指南
3

4
## 开发流程
5

6
1. Fork 本仓库
7
2. 创建功能分支：`git checkout -b feature/your-feature`
8
3. 提交代码：`git commit -m "feat: add your feature"`
9
4. 推送分支：`git push origin feature/your-feature`
10
5. 创建 Pull Request
11

12
## 代码规范
13

14
- 使用 ESLint + Prettier 格式化代码
15
- 提交信息遵循 [Conventional Commits](https://conventionalcommits.org)
16
- 新功能必须包含测试
17
- Bug 修复必须包含复现测试
18

19
## PR 要求
20

21
- [ ] 代码通过 lint 检查
22
- [ ] 所有测试通过
23
- [ ] 更新了相关文档
24
- [ ] 至少一位 reviewer 批准
25

26
## Issue 规范
27

28
- Bug 报告使用 Bug Report 模板
29
- 功能请求使用 Feature Request 模板
30
- 搜索已有 Issue 避免重复

展开收起

典型指令：

1
为我们项目生成完整的协作文档：
2
README.md、CONTRIBUTING.md、PR 模板、Issue 模板，
3
确保符合开源项目最佳实践。

本篇小结#

#	Skill	类别	难度	价值
1	Git 基础操作	版本控制	⭐	⭐⭐⭐⭐⭐
2	GitHub MCP	代码托管	⭐⭐	⭐⭐⭐⭐⭐
3	GitLab MCP	代码托管	⭐⭐	⭐⭐⭐⭐
4	Jira / Linear	项目管理	⭐⭐	⭐⭐⭐⭐
5	Code Review	代码审查	⭐⭐⭐	⭐⭐⭐⭐⭐
6	Branch 策略	Git 工作流	⭐⭐	⭐⭐⭐⭐
7	自动化 Release	发布管理	⭐⭐⭐	⭐⭐⭐⭐
8	Issue 模板	项目管理	⭐⭐	⭐⭐⭐
9	代码搜索	代码探索	⭐⭐	⭐⭐⭐⭐
10	团队协作	协作流程	⭐⭐	⭐⭐⭐⭐

核心观点： 版本控制与协作 Skills 让 Agent 从”个人工具”变成”团队成员”。一个能创建 PR、审查代码、管理 Issue 的 Agent，才能真正融入开发团队的工作流。

系列导航#

👈 上一篇： 第六篇：知识管理与 RAG
👉 下一篇： 第八篇：文档与文件处理

100 个 Agent Skills 盘点（八）：文档与文件处理

Fri, 12 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第八篇。这一篇聚焦一个被低估但极其实用的能力：文档与文件处理。

现实世界的数据不都是 JSON 和 CSV。Agent 需要能处理 PDF 报告、Word 文档、Excel 表格、图片等各种格式，才能真正帮助用户处理日常工作。

1. PDF 读取与解析 📄#

类别： 文档解析 适用工具： pdf-parse / PyMuPDF / pdfplumber

PDF 是最普遍的文档格式，但也是最难处理的格式之一。Agent 需要能从 PDF 中提取文字、表格和图片。

能力说明：

文字提取
表格识别和提取
图片提取
元数据读取
页面分割

Agent 使用场景：

1
# Agent 解析 PDF 合同
2
import pdfplumber
3

4
def extract_contract_info(pdf_path):
5
    with pdfplumber.open(pdf_path) as pdf:
6
        full_text = ""
7
        tables = []
8

9
        for page in pdf.pages:
10
            # 提取文字
11
            full_text += page.extract_text() or ""
12

13
            # 提取表格
14
            page_tables = page.extract_tables()
15
            tables.extend(page_tables)
16

17
        # 用 LLM 分析合同内容
18
        analysis = llm.analyze(f"""
19
        请从以下合同文本中提取关键信息：
20
        1. 合同双方
21
        2. 合同期限
22
        3. 金额
23
        4. 关键条款
24

25
        文本：{full_text[:5000]}
26
        """)
27

28
        return {
29
            "text": full_text,
30
            "tables": tables,
31
            "analysis": analysis
32
        }

展开收起

1
// Agent 提取 PDF 中的表格数据
2
const pdfParse = require('pdf-parse');
3
const fs = require('fs');
4

5
async function extractTablesFromPDF(pdfPath) {
6
  const buffer = fs.readFileSync(pdfPath);
7
  const data = await pdfParse(buffer);
8

9
  // 使用正则匹配表格结构
10
  const lines = data.text.split('\n');
11
  const tableData = [];
12
  let inTable = false;
13

14
  for (const line of lines) {
15
    if (line.includes('|') || line.match(/\s{3,}/)) {
16
      inTable = true;
17
      const cells = line.split(/\s{2,}|\|/).filter(Boolean).map(s => s.trim());
18
      tableData.push(cells);
19
    } else if (inTable) {
20
      inTable = false;
21
    }
22
  }
23

24
  return tableData;
25
}

展开收起

典型指令：

1
读取这份 PDF 报告，提取所有表格数据，
2
转换为 JSON 格式，找出收入最高的三个部门。

2. Word 文档处理 📝#

类别： 文档处理 适用工具： python-docx / mammoth / docxtemplater

Word 文档是企业环境中最常见的文档格式。Agent 可以读取、生成和修改 Word 文档。

能力说明：

文字提取和修改
样式处理
表格操作
图片插入
模板填充

Agent 使用场景：

1
# Agent 生成 Word 报告
2
from docx import Document
3
from docx.shared import Inches, Pt
4
from docx.enum.text import WD_ALIGN_PARAGRAPH
5

6
def generate_report(data, output_path):
7
    doc = Document()
8

9
    # 标题
10
    title = doc.add_heading('月度运营报告', 0)
11
    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
12

13
    # 摘要
14
    doc.add_heading('执行摘要', level=1)
15
    doc.add_paragraph(data['summary'])
16

17
    # 数据表格
18
    doc.add_heading('详细数据', level=1)
19
    table = doc.add_table(rows=1, cols=4)
20
    table.style = 'Light Grid Accent 1'
21

22
    # 表头
23
    headers = ['指标', '本月', '上月', '变化']
24
    for i, header in enumerate(headers):
25
        table.rows[0].cells[i].text = header
26

27
    # 数据行
28
    for row_data in data['metrics']:
29
        row = table.add_row()
30
        for i, value in enumerate(row_data):
31
            row.cells[i].text = str(value)
32

33
    # 图表说明
34
    doc.add_heading('趋势分析', level=1)
35
    doc.add_paragraph(data['analysis'])
36

37
    doc.save(output_path)

展开收起

1
// Agent 用模板生成合同
2
const docxtemplater = require('docxtemplater');
3
const fs = require('fs');
4

5
async function generateContract(templatePath, data) {
6
  const content = fs.readFileSync(templatePath, 'binary');
7
  const doc = new docxtemplater(content);
8

9
  doc.setData({
10
    partyA: data.partyA,
11
    partyB: data.partyB,
12
    amount: data.amount,
13
    startDate: data.startDate,
14
    endDate: data.endDate,
15
    terms: data.terms
16
  });
17

18
  doc.render();
19
  return doc.getZip().generate({ type: 'nodebuffer' });
20
}

展开收起

典型指令：

1
读取这份 Word 格式的需求文档，
2
提取所有的功能需求点，
3
生成一个结构化的需求清单（Excel 格式）。

3. Excel 表格处理 📊#

类别： 电子表格 适用工具： openpyxl / xlsxwriter / SheetJS

Excel 是数据分析和业务报告的标准格式。Agent 可以读取、分析、生成 Excel 文件。

能力说明：

读取和写入单元格
公式计算
图表生成
数据透视表
样式设置

Agent 使用场景：

1
# Agent 分析销售数据并生成报告
2
import openpyxl
3
from openpyxl.chart import BarChart, Reference
4
from openpyxl.styles import Font, PatternFill
5

6
def analyze_sales(excel_path):
7
    wb = openpyxl.load_workbook(excel_path)
8
    ws = wb.active
9

10
    # 读取数据
11
    sales_data = []
12
    for row in ws.iter_rows(min_row=2, values_only=True):
13
        sales_data.append({
14
            'product': row[0],
15
            'region': row[1],
16
            'amount': row[2],
17
            'quantity': row[3]
18
        })
19

20
    # 按产品汇总
21
    product_summary = {}
22
    for item in sales_data:
23
        product = item['product']
24
        product_summary[product] = product_summary.get(product, 0) + item['amount']
25

26
    # 创建报告工作簿
27
    report_wb = openpyxl.Workbook()
28
    report_ws = report_wb.active
29
    report_ws.title = "销售汇总"
30

31
    # 写入表头
32
    headers = ['产品', '销售额', '占比']
33
    for col, header in enumerate(headers, 1):
34
        cell = report_ws.cell(row=1, column=col, value=header)
35
        cell.font = Font(bold=True, color="FFFFFF")
36
        cell.fill = PatternFill("solid", fgColor="2563EB")
37

38
    # 写入数据
39
    total = sum(product_summary.values())
40
    for row, (product, amount) in enumerate(sorted(product_summary.items(), key=lambda x: -x[1]), 2):
41
        report_ws.cell(row=row, column=1, value=product)
42
        report_ws.cell(row=row, column=2, value=amount)
43
        report_ws.cell(row=row, column=3, value=f"{amount/total*100:.1f}%")
44

45
    # 添加图表
46
    chart = BarChart()
47
    chart.title = "产品销售额对比"
48
    data = Reference(report_ws, min_col=2, min_row=1, max_row=len(product_summary)+1)
49
    categories = Reference(report_ws, min_col=1, min_row=2, max_row=len(product_summary)+1)
50
    chart.add_data(data, titles_from_data=True)
51
    chart.set_categories(categories)
52
    report_ws.add_chart(chart, "E2")
53

54
    report_wb.save("sales_report.xlsx")

展开收起

典型指令：

1
读取 sales.xlsx 中的销售数据，
2
按地区和产品汇总，生成带图表的分析报告，
3
找出增长最快和下降最快的产品。

4. CSV 数据处理 📈#

类别： 数据处理 适用工具： pandas / csv / d3-dsv

CSV 是最简单的结构化数据格式，也是数据交换的通用语言。

能力说明：

大文件流式处理
数据清洗和转换
编码处理（UTF-8 / GBK）
数据验证

Agent 使用场景：

1
# Agent 处理大型 CSV 文件
2
import pandas as pd
3

4
def process_large_csv(input_path, output_path):
5
    # 分块读取大文件
6
    chunks = pd.read_csv(input_path, chunksize=10000, encoding='utf-8')
7

8
    results = []
9
    for chunk in chunks:
10
        # 数据清洗
11
        chunk = chunk.dropna(subset=['email'])  # 删除无邮箱的行
12
        chunk['email'] = chunk['email'].str.lower().str.strip()
13
        chunk['amount'] = pd.to_numeric(chunk['amount'], errors='coerce')
14

15
        # 数据转换
16
        chunk['date'] = pd.to_datetime(chunk['date'])
17
        chunk['month'] = chunk['date'].dt.to_period('M')
18

19
        results.append(chunk)
20

21
    # 合并所有数据
22
    df = pd.concat(results)
23

24
    # 分析
25
    summary = df.groupby('month').agg(
26
        total_amount=('amount', 'sum'),
27
        count=('email', 'count'),
28
        unique_users=('email', 'nunique')
29
    ).reset_index()
30

31
    summary.to_csv(output_path, index=False)
32
    return summary

展开收起

典型指令：

1
处理这个 500MB 的 CSV 文件，
2
清洗无效数据，按月汇总，
3
输出分析结果到新的 CSV。

5. Markdown 处理 ✍️#

类别： 标记语言 适用工具： marked / remark / markdown-it

Markdown 是开发者最常用的文档格式。Agent 可以解析、生成和转换 Markdown 文档。

能力说明：

Markdown 解析和渲染
目录生成
格式转换（Markdown → HTML / PDF）
批量处理

Agent 使用场景：

1
// Agent 自动生成文档目录
2
const fs = require('fs');
3

4
function generateTOC(markdownContent) {
5
  const headings = [];
6
  const lines = markdownContent.split('\n');
7

8
  for (const line of lines) {
9
    const match = line.match(/^(#{1,6})\s+(.+)/);
10
    if (match) {
11
      const level = match[1].length;
12
      const title = match[2].trim();
13
      const slug = title
14
        .toLowerCase()
15
        .replace(/[^\w一-龥]+/g, '-')
16
        .replace(/^-|-$/g, '');
17

18
      headings.push({ level, title, slug });
19
    }
20
  }
21

22
  // 生成目录
23
  let toc = '## 目录\n\n';
24
  for (const heading of headings) {
25
    const indent = '  '.repeat(heading.level - 1);
26
    toc += `${indent}- [${heading.title}](#${heading.slug})\n`;
27
  }
28

29
  return toc;
30
}
31

32
// Agent 批量处理 Markdown 文件
33
const files = fs.readdirSync('./docs').filter(f => f.endsWith('.md'));
34
for (const file of files) {
35
  const content = fs.readFileSync(`./docs/${file}`, 'utf-8');
36
  const toc = generateTOC(content);
37
  // 在第一个标题后插入目录
38
  const updated = content.replace(/(^# .+$)/m, `$1\n\n${toc}`);
39
  fs.writeFileSync(`./docs/${file}`, updated);
40
}

展开收起

典型指令：

1
扫描 docs/ 目录下所有 Markdown 文件，
2
为每个文件自动生成目录，
3
检查是否有断链（链接到不存在的锚点）。

6. 图片处理 🖼️#

类别： 多媒体处理 适用工具： Sharp / Pillow / ImageMagick

Agent 可以处理图片——调整大小、添加水印、格式转换、OCR 文字识别。

能力说明：

图片缩放和裁剪
格式转换（PNG ↔ JPG ↔ WebP）
水印添加
图片压缩
OCR 文字识别

Agent 使用场景：

1
// Agent 批量处理产品图片
2
const sharp = require('sharp');
3
const fs = require('fs');
4
const path = require('path');
5

6
async function processProductImages(inputDir, outputDir) {
7
  const files = fs.readdirSync(inputDir).filter(f =>
8
    /\.(jpg|jpeg|png|webp)$/i.test(f)
9
  );
10

11
  for (const file of files) {
12
    const inputPath = path.join(inputDir, file);
13
    const name = path.parse(file).name;
14

15
    // 生成多种尺寸
16
    const sizes = [
17
      { width: 1200, suffix: 'large' },   // 产品详情页
18
      { width: 600, suffix: 'medium' },    // 列表页
19
      { width: 300, suffix: 'thumbnail' }, // 缩略图
20
      { width: 100, suffix: 'icon' }       // 图标
21
    ];
22

23
    for (const size of sizes) {
24
      await sharp(inputPath)
25
        .resize(size.width, null, { withoutEnlargement: true })
26
        .webp({ quality: 80 })
27
        .toFile(path.join(outputDir, `${name}-${size.suffix}.webp`));
28
    }
29

30
    console.log(`✅ Processed: ${file}`);
31
  }
32
}

展开收起

1
# Agent 用 OCR 提取图片中的文字
2
from PIL import Image
3
import pytesseract
4

5
def extract_text_from_image(image_path):
6
    image = Image.open(image_path)
7
    text = pytesseract.image_to_string(image, lang='chi_sim+eng')
8
    return text.strip()

典型指令：

1
把 images/ 目录下的所有产品图片调整为 800x600，
2
转换为 WebP 格式，压缩到 100KB 以下，
3
添加右下角水印。

7. 音频/视频处理 🎬#

类别： 多媒体处理 适用工具： FFmpeg / Whisper

Agent 可以处理音视频——转码、剪辑、提取音频、语音转文字。

能力说明：

格式转换
音频提取
视频剪辑
语音转文字（Whisper）
字幕生成

Agent 使用场景：

1
# Agent 用 Whisper 做会议录音转文字
2
import whisper
3

4
def transcribe_meeting(audio_path):
5
    model = whisper.load_model("medium")
6
    result = model.transcribe(audio_path, language="zh")
7

8
    # 生成带时间戳的文字稿
9
    transcript = ""
10
    for segment in result["segments"]:
11
        start = format_time(segment["start"])
12
        end = format_time(segment["end"])
13
        text = segment["text"]
14
        transcript += f"[{start} → {end}] {text}\n"
15

16
    # 用 LLM 生成会议纪要
17
    summary = llm.generate(f"""
18
    根据以下会议录音文字稿，生成会议纪要：
19
    1. 会议主题
20
    2. 讨论要点（3-5 个）
21
    3. 决议事项
22
    4. 待办事项及负责人
23

24
    文字稿：{transcript}
25
    """)
26

27
    return {"transcript": transcript, "summary": summary}

展开收起

Terminal window

1
# Agent 用 FFmpeg 处理视频
2
# 提取音频
3
ffmpeg -i video.mp4 -vn -acodec pcm_s16le audio.wav
4

5
# 剪辑前 30 秒
6
ffmpeg -i video.mp4 -t 30 -c copy clip.mp4
7

8
# 压缩视频
9
ffmpeg -i input.mp4 -c:v libx264 -crf 28 -preset fast output.mp4
10

11
# 添加字幕
12
ffmpeg -i video.mp4 -vf subtitles=subs.srt output.mp4

典型指令：

1
把这段 2 小时的会议录音转成文字，
2
用 Whisper 识别中文内容，
3
然后生成结构化的会议纪要。

8. 数据格式转换 🔄#

类别： 格式转换 适用工具： csvtojson / js-yaml / xml2js

数据在不同格式之间转换是常见需求。Agent 可以在 JSON、CSV、YAML、XML 等格式之间自由转换。

能力说明：

JSON ↔ CSV
YAML ↔ JSON
XML ↔ JSON
Excel ↔ CSV
自定义格式转换

Agent 使用场景：

1
// Agent 批量格式转换
2
const fs = require('fs');
3
const yaml = require('js-yaml');
4
const csvtojson = require('csvtojson');
5

6
async function convertFormat(inputPath, fromFormat, toFormat) {
7
  let data;
8

9
  // 读取
10
  switch (fromFormat) {
11
    case 'json':
12
      data = JSON.parse(fs.readFileSync(inputPath, 'utf-8'));
13
      break;
14
    case 'yaml':
15
      data = yaml.load(fs.readFileSync(inputPath, 'utf-8'));
16
      break;
17
    case 'csv':
18
      data = await csvtojson().fromFile(inputPath);
19
      break;
20
  }
21

22
  // 写入
23
  const outputPath = inputPath.replace(`.${fromFormat}`, `.${toFormat}`);
24
  switch (toFormat) {
25
    case 'json':
26
      fs.writeFileSync(outputPath, JSON.stringify(data, null, 2));
27
      break;
28
    case 'yaml':
29
      fs.writeFileSync(outputPath, yaml.dump(data));
30
      break;
31
    case 'csv':
32
      const headers = Object.keys(data[0]).join(',');
33
      const rows = data.map(row => Object.values(row).join(','));
34
      fs.writeFileSync(outputPath, [headers, ...rows].join('\n'));
35
      break;
36
  }
37

38
  console.log(`✅ Converted: ${inputPath} → ${outputPath}`);
39
}

展开收起

典型指令：

1
把这个 YAML 配置文件转换为 JSON，
2
把那个 CSV 文件转换为 YAML，
3
确保中文编码正确。

9. Sentry MCP Server 🐛#

类别： 错误监控 协议： MCP（Model Context Protocol）

Sentry 是业界最流行的错误监控平台，通过 MCP 协议，Agent 可以直接查询错误数据、分析堆栈、创建 Issue 并分配负责人，实现从”发现错误”到”修复问题”的全流程自动化。

能力说明：

错误追踪：查询项目中的错误事件、异常堆栈和发生频率
性能监控：追踪 API 响应时间、数据库慢查询等性能指标
告警配置：设置阈值告警，异常发生时自动通知相关人员
Issue 管理：自动创建、更新、分配和关闭 Sentry Issue

Agent 使用场景：

1
// Agent 通过 Sentry MCP Server 自动分析错误并创建 Issue
2
// 1. 查询最近 1 小时的错误事件
3
const recentErrors = await mcp.sentry.queryErrors({
4
  project: 'my-web-app',
5
  timeRange: '1h',
6
  sort: 'frequency',
7
  limit: 10,
8
});
9

10
// 2. 按错误类型聚合，找出最常见的问题
11
const topIssues = aggregateByType(recentErrors);
12

13
for (const issue of topIssues.slice(0, 3)) {
14
  // 3. 分析错误堆栈，定位根因
15
  const analysis = await llm.analyze({
16
    prompt: `分析以下错误堆栈，找出根本原因并给出修复建议：
17
      错误类型：${issue.title}
18
      堆栈信息：${issue.stacktrace}
19
      发生次数：${issue.count}
20
      首次出现：${issue.firstSeen}`,
21
  });
22

23
  // 4. 自动创建 GitHub Issue 并关联 Sentry
24
  await mcp.github.createIssue({
25
    repo: 'my-org/my-web-app',
26
    title: `[Sentry] ${issue.title}`,
27
    body: `## 错误分析\n\n${analysis.summary}\n\n` +
28
          `## 堆栈信息\n\n\`\`\`\n${issue.stacktrace}\n\`\`\`\n\n` +
29
          `## 修复建议\n\n${analysis.suggestion}\n\n` +
30
          `> Sentry Issue: ${issue.permalink}`,
31
    labels: ['bug', 'sentry', 'auto-created'],
32
    assignees: [analysis.suggestedAssignee],
33
  });
34
}
35

36
console.log(`✅ 已分析 ${recentErrors.length} 个错误，创建了 ${topIssues.length} 个 Issue`);

展开收起

典型指令：

1
分析最近 1 小时的错误，找出最常见的 3 个问题，
2
为每个问题创建 GitHub Issue，分配给对应的负责人，
3
并在 Issue 中附上错误堆栈和修复建议。

10. 文档生成自动化 🤖#

类别： 文档自动化 适用工具： 综合

Agent 可以自动化文档生成流程——从代码注释生成 API 文档、从数据生成报告、从模板生成合同。

能力说明：

API 文档生成（Swagger / TypeDoc）
报告模板填充
批量文档生成
多格式输出

Agent 使用场景：

1
# Agent 自动生成 API 文档
2
import ast
3
import json
4

5
def generate_api_docs(source_code):
6
    """从 Python 代码自动生成 API 文档"""
7
    tree = ast.parse(source_code)
8
    endpoints = []
9

10
    for node in ast.walk(tree):
11
        if isinstance(node, ast.FunctionDef):
12
            # 检查是否有路由装饰器
13
            for decorator in node.decorator_list:
14
                if isinstance(decorator, ast.Call):
15
                    if hasattr(decorator.func, 'attr'):
16
                        method = decorator.func.attr  # get, post, put, delete
17
                        if method in ('get', 'post', 'put', 'delete'):
18
                            # 提取路径
19
                            path = decorator.args[0].value if decorator.args else '/'
20

21
                            # 提取文档字符串
22
                            docstring = ast.get_docstring(node) or ''
23

24
                            # 提取参数
25
                            params = []
26
                            for arg in node.args.args:
27
                                params.append(arg.arg)
28

29
                            endpoints.append({
30
                                'method': method.upper(),
31
                                'path': path,
32
                                'function': node.name,
33
                                'params': params,
34
                                'description': docstring
35
                            })
36

37
    # 生成 Markdown 文档
38
    doc = "# API Documentation\n\n"
39
    for ep in endpoints:
40
        doc += f"## {ep['method']} {ep['path']}\n\n"
41
        doc += f"**Function:** `{ep['function']}`\n\n"
42
        doc += f"**Parameters:** {', '.join(ep['params'])}\n\n"
43
        doc += f"{ep['description']}\n\n---\n\n"
44

45
    return doc

展开收起

典型指令：

1
扫描项目中所有 API 路由文件，
2
自动生成 API 文档（Markdown 格式），
3
包含请求参数、响应格式和示例。

本篇小结#

#	Skill	类别	难度	价值
1	PDF 读取解析	文档解析	⭐⭐	⭐⭐⭐⭐⭐
2	Word 文档处理	文档处理	⭐⭐	⭐⭐⭐⭐
3	Excel 表格处理	电子表格	⭐⭐	⭐⭐⭐⭐⭐
4	CSV 数据处理	数据处理	⭐	⭐⭐⭐⭐
5	Markdown 处理	标记语言	⭐	⭐⭐⭐⭐
6	图片处理	多媒体	⭐⭐	⭐⭐⭐⭐
7	音视频处理	多媒体	⭐⭐⭐	⭐⭐⭐⭐
8	数据格式转换	格式转换	⭐	⭐⭐⭐⭐
9	Sentry MCP Server	错误监控	⭐⭐⭐	⭐⭐⭐⭐⭐
10	文档生成自动化	文档自动化	⭐⭐⭐	⭐⭐⭐⭐⭐

核心观点： 文档处理 Skills 让 Agent 能”读懂”现实世界的文件。一个能解析 PDF、处理 Excel、识别图片文字的 Agent，才能真正帮助用户处理日常工作中的各种文档。

系列导航#

👈 上一篇： 第七篇：版本控制与协作
👉 下一篇： 第九篇：通信与通知集成

100 个 Agent Skills 盘点（九）：通信与通知集成

Thu, 11 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的第九篇。这一篇聚焦 Agent 的”表达能力”——通信与通知。

一个再聪明的 Agent，如果不能把结果告诉用户，那它的价值就大打折扣。通信 Skills 让 Agent 能通过 Slack、邮件、Telegram 等渠道，把信息”推”到用户面前。

1. Slack MCP Server 💬#

类别： 团队通信 协议： MCP

Slack 是最流行的团队协作工具。Agent 通过 Slack MCP 可以发送消息、创建频道、管理工作流。

能力说明：

发送消息和附件
创建和管理频道
消息搜索
反应表情（Reaction）
工作流触发

Agent 使用场景：

1
// Agent 发送每日报告到 Slack
2
async function sendDailyReport(data) {
3
  // 发送富文本消息
4
  await slack.postMessage({
5
    channel: '#engineering',
6
    blocks: [
7
      {
8
        type: 'header',
9
        text: { type: 'plain_text', text: '📊 每日运营报告' }
10
      },
11
      {
12
        type: 'section',
13
        fields: [
14
          { type: 'mrkdwn', text: `*活跃用户:*\n${data.activeUsers}` },
15
          { type: 'mrkdwn', text: `*新增注册:*\n${data.newUsers}` },
16
          { type: 'mrkdwn', text: `*收入:*\n¥${data.revenue}` },
17
          { type: 'mrkdwn', text: `*转化率:*\n${data.conversionRate}%` }
18
        ]
19
      },
20
      {
21
        type: 'actions',
22
        elements: [
23
          {
24
            type: 'button',
25
            text: { type: 'plain_text', text: '查看详情' },
26
            url: 'https://dashboard.example.com'
27
          }
28
        ]
29
      }
30
    ]
31
  });
32
}

展开收起

1
// Agent 监控告警推送到 Slack
2
async function sendAlert(alert) {
3
  const color = alert.severity === 'critical' ? '#FF0000' :
4
                alert.severity === 'warning' ? '#FFA500' : '#36A64F';
5

6
  await slack.postMessage({
7
    channel: '#alerts',
8
    attachments: [{
9
      color: color,
10
      title: `🚨 ${alert.title}`,
11
      text: alert.message,
12
      fields: [
13
        { title: '服务', value: alert.service, short: true },
14
        { title: '环境', value: alert.environment, short: true },
15
        { title: '时间', value: new Date().toLocaleString(), short: true }
16
      ]
17
    }]
18
  });
19
}

展开收起

典型指令：

1
每天早上 9 点把昨日的运营数据发到 Slack #analytics 频道，
2
包含活跃用户、收入、转化率三个关键指标。

2. Discord MCP Server 🎮#

类别： 社区通信 协议： MCP

Discord 不只是游戏社区，很多技术团队和开源项目也用它。Agent 可以在 Discord 中发送消息、管理频道、创建嵌入消息。

能力说明：

发送消息和嵌入（Embed）
频道管理
角色管理
斜杠命令
Webhook 集成

Agent 使用场景：

1
// Agent 在 Discord 发布版本更新通知
2
async function announceRelease(version, changelog) {
3
  await discord.sendEmbed({
4
    channel: '#announcements',
5
    embed: {
6
      title: `🎉 v${version} 发布！`,
7
      description: changelog.summary,
8
      color: 0x5865F2,
9
      fields: [
10
        {
11
          name: '✨ 新功能',
12
          value: changelog.features.map(f => `• ${f}`).join('\n')
13
        },
14
        {
15
          name: '🐛 Bug 修复',
16
          value: changelog.fixes.map(f => `• ${f}`).join('\n')
17
        }
18
      ],
19
      footer: { text: '查看完整更新日志' },
20
      timestamp: new Date().toISOString()
21
    }
22
  });
23
}

展开收起

典型指令：

1
每当 GitHub Release 发布新版本时，
2
自动在 Discord #releases 频道发送更新通知，
3
包含版本号、新功能列表和下载链接。

3. 邮件发送 📧#

类别： 电子邮件 适用工具： Nodemailer / SendGrid / Resend

邮件仍然是正式商务通信的主要渠道。Agent 可以发送报告、通知、营销邮件。

能力说明：

HTML 邮件发送
附件支持
模板引擎
批量发送
发送追踪

Agent 使用场景：

1
// Agent 发送周报邮件
2
const nodemailer = require('nodemailer');
3

4
async function sendWeeklyReport(recipients, reportData) {
5
  const transporter = nodemailer.createTransport({
6
    host: 'smtp.example.com',
7
    port: 587,
8
    auth: { user: process.env.EMAIL_USER, pass: process.env.EMAIL_PASS }
9
  });
10

11
  const html = `
12
    <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto;">
13
      <h1 style="color: #2563eb;">📊 周报 - ${reportData.week}</h1>
14

15
      <div style="background: #f3f4f6; padding: 20px; border-radius: 8px; margin: 20px 0;">
16
        <h2>关键指标</h2>
17
        <table style="width: 100%;">
18
          <tr>
19
            <td><strong>活跃用户</strong></td>
20
            <td style="text-align: right; color: #10b981;">${reportData.users} ↑</td>
21
          </tr>
22
          <tr>
23
            <td><strong>收入</strong></td>
24
            <td style="text-align: right;">¥${reportData.revenue}</td>
25
          </tr>
26
        </table>
27
      </div>
28

29
      <h2>本周亮点</h2>
30
      <ul>
31
        ${reportData.highlights.map(h => `<li>${h}</li>`).join('')}
32
      </ul>
33

34
      <p style="color: #6b7280; font-size: 12px;">
35
        此邮件由 AI Agent 自动生成
36
      </p>
37
    </div>
38
  `;
39

40
  await transporter.sendMail({
41
    from: '"AI Agent" <agent@example.com>',
42
    to: recipients.join(', '),
43
    subject: `📊 周报 - ${reportData.week}`,
44
    html: html
45
  });
46
}

展开收起

典型指令：

1
每周五下午 5 点自动发送周报邮件给团队，
2
包含本周的开发进度、Bug 修复情况和下周计划。

4. Telegram Bot 📱#

类别： 即时通信 适用工具： Telegram Bot API / node-telegram-bot-api

Telegram Bot 是个人通知的绝佳渠道——免费、可靠、支持富文本和内联按钮。

能力说明：

发送文本/图片/文件消息
内联按钮和回调
群组管理
Webhook 和轮询

Agent 使用场景：

1
// Agent 通过 Telegram 发送服务器告警
2
const TelegramBot = require('node-telegram-bot-api');
3
const bot = new TelegramBot(process.env.TELEGRAM_TOKEN);
4

5
async function sendServerAlert(chatId, alert) {
6
  const emoji = {
7
    critical: '🔴',
8
    warning: '🟡',
9
    info: '🟢'
10
  }[alert.severity] || '⚪';
11

12
  const message = `
13
${emoji} *服务器告警*
14

15
*服务:* ${alert.service}
16
*状态:* ${alert.status}
17
*详情:* ${alert.message}
18
*时间:* ${new Date().toLocaleString()}
19

20
${alert.severity === 'critical' ? '⚠️ 需要立即处理！' : ''}
21
  `;
22

23
  await bot.sendMessage(chatId, message, { parse_mode: 'Markdown' });
24
}
25

26
// Agent 定时发送健康报告
27
async function sendHealthReport(chatId) {
28
  const status = await checkAllServices();
29

30
  let message = '🏥 *系统健康报告*\n\n';
31
  for (const [service, healthy] of Object.entries(status)) {
32
    message += `${healthy ? '✅' : '❌'} ${service}\n`;
33
  }
34

35
  await bot.sendMessage(chatId, message, { parse_mode: 'Markdown' });
36
}

展开收起

典型指令：

1
配置 Telegram Bot，当服务器 CPU 使用率超过 90%
2
或磁盘空间不足 10% 时，自动发送告警消息。

5. Webhook 集成 🔗#

类别： 事件驱动 适用工具： HTTP 请求

Webhook 是最通用的事件通知方式。Agent 可以通过 Webhook 与任何支持 HTTP 的系统集成。

能力说明：

发送 HTTP POST 请求
自定义 payload 格式
签名验证
重试机制

Agent 使用场景：

1
// Agent 通过 Webhook 触发自动化流程
2
async function triggerWebhook(event, data) {
3
  const webhooks = await getWebhooksForEvent(event);
4

5
  for (const webhook of webhooks) {
6
    const payload = {
7
      event: event,
8
      timestamp: new Date().toISOString(),
9
      data: data
10
    };
11

12
    // 生成签名
13
    const signature = crypto
14
      .createHmac('sha256', webhook.secret)
15
      .update(JSON.stringify(payload))
16
      .digest('hex');
17

18
    try {
19
      const response = await fetch(webhook.url, {
20
        method: 'POST',
21
        headers: {
22
          'Content-Type': 'application/json',
23
          'X-Webhook-Signature': signature
24
        },
25
        body: JSON.stringify(payload)
26
      });
27

28
      if (!response.ok) {
29
        console.error(`Webhook failed: ${webhook.url} - ${response.status}`);
30
        await retryWebhook(webhook, payload, 3); // 重试 3 次
31
      }
32
    } catch (error) {
33
      console.error(`Webhook error: ${webhook.url}`, error);
34
    }
35
  }
36
}
37

38
// 使用示例
39
await triggerWebhook('deployment.completed', {
40
  service: 'myapp',
41
  version: 'v2.1.0',
42
  environment: 'production'
43
});

展开收起

典型指令：

1
配置 Webhook，当代码部署到生产环境时，
2
自动通知 Jira 更新任务状态、
3
通知 Slack 频道、触发监控系统更新。

6. 企业微信 / 钉钉通知 🏢#

类别： 企业通信 适用工具： 企业微信 API / 钉钉 API

在中国的企业环境中，企业微信和钉钉是主流的团队通信工具。Agent 可以通过它们发送工作通知。

能力说明：

文本/Markdown 消息发送
群机器人 Webhook
应用消息推送
@指定人员

Agent 使用场景：

1
// Agent 通过钉钉机器人发送告警
2
async function sendDingTalkAlert(webhook, alert) {
3
  const message = {
4
    msgtype: 'markdown',
5
    markdown: {
6
      title: `服务器告警 - ${alert.service}`,
7
      text: `## 🔴 服务器告警\n\n` +
8
        `**服务:** ${alert.service}\n\n` +
9
        `**状态:** ${alert.status}\n\n` +
10
        `**详情:** ${alert.message}\n\n` +
11
        `**时间:** ${new Date().toLocaleString()}\n\n` +
12
        `[查看详情](https://monitor.example.com)`
13
    },
14
    at: {
15
      atMobiles: alert.notifyUsers || [],
16
      isAtAll: alert.severity === 'critical'
17
    }
18
  };
19

20
  await fetch(webhook, {
21
    method: 'POST',
22
    headers: { 'Content-Type': 'application/json' },
23
    body: JSON.stringify(message)
24
  });
25
}
26

27
// Agent 通过企业微信发送日报
28
async function sendWeChatWorkReport(webhook, report) {
29
  await fetch(webhook, {
30
    method: 'POST',
31
    headers: { 'Content-Type': 'application/json' },
32
    body: JSON.stringify({
33
      msgtype: 'template_card',
34
      template_card: {
35
        card_type: 'text_notice',
36
        source: { desc: 'AI Agent 自动生成' },
37
        main_title: { title: '📊 每日运营报告' },
38
        horizontal_content_list: [
39
          { keyname: '活跃用户', value: report.users },
40
          { keyname: '收入', value: `¥${report.revenue}` },
41
          { keyname: '转化率', value: `${report.conversion}%` }
42
        ]
43
      }
44
    })
45
  });
46
}

展开收起

典型指令：

1
配置钉钉群机器人，当 CI/CD Pipeline 失败时，
2
自动在群里发送告警 @相关开发人员。

7. 短信通知 📲#

类别： 移动通知 适用工具： Twilio / 阿里云短信 / 腾讯云短信

短信是最可靠的紧急通知方式——不依赖互联网连接，几乎 100% 送达。

能力说明：

单条短信发送
批量发送
模板短信
发送状态追踪

Agent 使用场景：

1
# Agent 发送紧急告警短信
2
from twilio.rest import Client
3

4
def send_emergency_sms(phone_numbers, alert):
5
    client = Client(TWILIO_SID, TWILIO_TOKEN)
6

7
    message = f"【紧急告警】{alert['service']} 服务异常：{alert['message']}。请立即处理。详情：{alert['dashboard_url']}"
8

9
    for phone in phone_numbers:
10
        client.messages.create(
11
            body=message,
12
            from_='+1234567890',
13
            to=phone
14
        )
15

16
    print(f"✅ 已发送告警短信给 {len(phone_numbers)} 人")

展开收起

典型指令：

1
当生产环境出现 P0 级别故障时，
2
自动发送短信给值班人员，
3
同时发送 Slack 消息和邮件。

8. Linear MCP Server 📋#

类别： 项目管理 协议： MCP

Linear 是最受开发者欢迎的项目管理工具，以极致的速度和简洁的 UI 著称。Agent 通过 Linear MCP 可以直接创建和管理 Issue、同步项目状态，实现开发工作流的全自动化。

能力说明：

Issue 创建与更新
项目和迭代管理
状态同步与流转
团队协作与评论
优先级和标签管理

Agent 使用场景：

1
// Agent 自动从错误监控创建 Issue
2
async function createIssueFromError(error) {
3
  // 1. 分析错误信息，生成 Issue 描述
4
  const description = await agent.analyze({
5
    prompt: `分析以下错误并生成 Linear Issue 描述：
6
    错误类型：${error.type}
7
    错误信息：${error.message}
8
    堆栈：${error.stack}
9
    影响用户数：${error.affectedUsers}`,
10
    format: 'structured'
11
  });
12

13
  // 2. 创建 Linear Issue
14
  const issue = await linear.createIssue({
15
    teamId: 'TEAM_ID',
16
    title: `[${error.severity}] ${error.type}: ${error.message.slice(0, 80)}`,
17
    description: description.markdown,
18
    priority: mapSeverityToPriority(error.severity), // P0→Urgent, P1→High...
19
    assigneeId: await findOnCallEngineer(),
20
    labels: ['auto-created', error.service],
21
    projectId: getProjectForService(error.service)
22
  });
23

24
  // 3. 关联到 Sentry 错误链接
25
  await linear.updateIssue(issue.id, {
26
    description: `${description.markdown}\n\n---\n🔗 [Sentry 详情](${error.sentryUrl})`
27
  });
28

29
  console.log(`✅ Issue 创建成功: ${issue.identifier}`);
30
  return issue;
31
}
32

33
// Agent 更新任务状态
34
async function syncTaskStatus(prEvent) {
35
  // 从 PR 标题提取 Issue 编号（如 ENG-123）
36
  const issueMatch = prEvent.title.match(/([A-Z]+-\d+)/);
37
  if (!issueMatch) return;
38

39
  const issue = await linear.getIssueByIdentifier(issueMatch[1]);
40

41
  // PR 合并 → 自动将 Issue 标记为 Done
42
  if (prEvent.action === 'merged') {
43
    await linear.updateIssue(issue.id, {
44
      stateId: 'DONE_STATE_ID'
45
    });
46
    await linear.createComment(issue.id, {
47
      body: `✅ 已通过 PR [#${prEvent.number}](${prEvent.url}) 完成`
48
    });
49
  }
50
}

展开收起

典型指令：

1
当 Sentry 捕获到 P0 级别的新错误时，
2
自动在 Linear 的「后端」项目中创建一个 Urgent Issue，
3
分配给当前值班工程师，并附上错误详情和堆栈信息。
4
PR 合并后自动更新 Issue 状态为 Done。

9. 消息队列集成 📨#

类别： 异步通信 适用工具： RabbitMQ / Kafka / Redis Pub/Sub

消息队列让 Agent 能处理高并发的异步任务，解耦生产者和消费者。

能力说明：

消息发布和订阅
队列管理
死信队列处理
消息确认

Agent 使用场景：

1
// Agent 使用 RabbitMQ 处理异步任务
2
const amqp = require('amqplib');
3

4
async function setupTaskQueue() {
5
  const connection = await amqp.connect('amqp://localhost');
6
  const channel = await connection.createChannel();
7

8
  // 声明队列
9
  await channel.assertQueue('task_queue', { durable: true });
10
  await channel.assertQueue('result_queue', { durable: true });
11

12
  // 消费任务
13
  channel.consume('task_queue', async (msg) => {
14
    const task = JSON.parse(msg.content.toString());
15
    console.log(`Processing task: ${task.type}`);
16

17
    try {
18
      const result = await processTask(task);
19

20
      // 发送结果
21
      channel.sendToQueue('result_queue',
22
        Buffer.from(JSON.stringify({
23
          taskId: task.id,
24
          result: result,
25
          status: 'completed'
26
        }))
27
      );
28

29
      channel.ack(msg);
30
    } catch (error) {
31
      // 失败重试
32
      channel.nack(msg, false, true);
33
    }
34
  });
35
}

展开收起

典型指令：

1
设计一个基于消息队列的异步任务处理系统，
2
支持任务分发、结果收集、失败重试和死信队列。

10. Obsidian MCP Server 📝#

类别： 知识管理 协议： MCP

Obsidian 是最流行的知识管理工具之一，基于本地 Markdown 文件，支持双向链接和知识图谱。Agent 通过 Obsidian MCP 可以读写笔记、搜索内容、管理标签，帮助用户自动整理和构建知识体系。

能力说明：

笔记读写与创建
全文搜索与检索
标签管理与分类
双向链接分析
知识图谱生成

Agent 使用场景：

1
// Agent 自动整理会议笔记
2
async function organizeMeetingNote(meetingData) {
3
  // 1. 创建结构化的会议笔记
4
  const noteContent = `---
5
date: ${meetingData.date}
6
type: meeting
7
attendees: [${meetingData.attendees.join(', ')}]
8
tags: [会议, ${meetingData.project}]
9
---
10

11
# ${meetingData.title}
12

13
## 参会人员
14
${meetingData.attendees.map(a => `- [[${a}]]`).join('\n')}
15

16
## 议程与讨论
17
${meetingData.agenda.map(item => `### ${item.topic}\n${item.discussion}`).join('\n\n')}
18

19
## 行动项
20
${meetingData.actionItems.map(item => `- [ ] ${item.task} —— @${item.assignee}（截止：${item.deadline}）`).join('\n')}
21

22
## 相关笔记
23
${meetingData.relatedNotes.map(note => `- [[${note}]]`).join('\n')}
24
`;
25

26
  // 2. 写入 Obsidian Vault
27
  await obsidian.createNote({
28
    path: `会议记录/${meetingData.date}-${meetingData.title}.md`,
29
    content: noteContent
30
  });
31

32
  // 3. 更新参会人员的笔记，添加反向链接
33
  for (const attendee of meetingData.attendees) {
34
    await obsidian.appendToNote({
35
      path: `人员/${attendee}.md`,
36
      content: `\n- 参加会议 [[${meetingData.title}]]（${meetingData.date}）`
37
    });
38
  }
39

40
  console.log(`✅ 会议笔记已创建并建立双向链接`);
41
}
42

43
// Agent 生成知识图谱分析
44
async function generateKnowledgeGraph(tag) {
45
  // 1. 搜索所有相关笔记
46
  const notes = await obsidian.search({
47
    query: `tag:${tag}`,
48
    limit: 100
49
  });
50

51
  // 2. 分析双向链接关系
52
  const graph = { nodes: [], edges: [] };
53
  for (const note of notes) {
54
    graph.nodes.push({
55
      id: note.path,
56
      title: note.title,
57
      tags: note.tags
58
    });
59

60
    // 提取笔记中的链接
61
    const links = await obsidian.getLinks(note.path);
62
    for (const link of links) {
63
      graph.edges.push({
64
        source: note.path,
65
        target: link
66
      });
67
    }
68
  }
69

70
  // 3. 生成图谱报告
71
  const report = `# 知识图谱分析：#${tag}
72

73
## 概览
74
- 笔记总数：${graph.nodes.length}
75
- 链接总数：${graph.edges.length}
76

77
## 核心节点（被引用最多）
78
${getTopNodes(graph, 10).map(n => `- [[${n.title}]]（被引用 ${n.count} 次）`).join('\n')}
79

80
## 知识集群
81
${identifyClusters(graph).map(c => `### ${c.name}\n${c.notes.map(n => `- [[${n}]]`).join('\n')}`).join('\n')}
82
`;
83

84
  await obsidian.createNote({
85
    path: `知识图谱/${tag}-分析报告.md`,
86
    content: report
87
  });
88

89
  return graph;
90
}

展开收起

典型指令：

1
帮我整理本周的会议记录，自动创建结构化笔记，
2
并在每个参会人员的笔记中添加反向链接。
3

4
分析 #[项目名] 标签下的所有笔记，
5
生成知识图谱报告，找出核心概念和知识盲区。

本篇小结#

#	Skill	类别	难度	价值
1	Slack MCP	团队通信	⭐⭐	⭐⭐⭐⭐⭐
2	Discord MCP	社区通信	⭐⭐	⭐⭐⭐⭐
3	邮件发送	电子邮件	⭐⭐	⭐⭐⭐⭐⭐
4	Telegram Bot	即时通信	⭐⭐	⭐⭐⭐⭐
5	Webhook	事件驱动	⭐⭐	⭐⭐⭐⭐⭐
6	企业微信/钉钉	企业通信	⭐⭐	⭐⭐⭐⭐
7	短信通知	移动通知	⭐⭐	⭐⭐⭐
8	Linear MCP	项目管理	⭐⭐⭐	⭐⭐⭐⭐⭐
9	消息队列	异步通信	⭐⭐⭐	⭐⭐⭐⭐
10	Obsidian MCP	知识管理	⭐⭐⭐	⭐⭐⭐⭐

核心观点： 通信 Skills 是 Agent 的”声音”。一个能通过 Slack、邮件、Telegram 等渠道主动通知用户的 Agent，才能真正成为”7×24 小时的助手”，而不只是”被动回答问题的机器”。

系列导航#

👈 上一篇： 第八篇：文档与文件处理
👉 下一篇： 第十篇：创意与可视化

110 个 Agent Skills 盘点（十一）：AI/ML 专用技能

Wed, 10 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「110 个 Agent Skills 盘点」系列的特别篇。前面十篇覆盖了代码、数据、浏览器、搜索、云、知识、协作、文档、通信、可视化，这一篇聚焦最前沿的领域：AI/ML 专用技能。

如果说前面的 Skills 让 Agent 能”做事”，那 AI/ML Skills 让 Agent 能”思考”和”创造”——调用大模型、生成图片、识别语音、运行本地模型。

AI/ML Skills = Agent 的”大脑升级”。

1. HuggingFace MCP Server 🤗#

类别： AI 模型平台 协议： MCP

HuggingFace 是 AI 领域的 GitHub，拥有数十万个预训练模型。Agent 通过 HuggingFace MCP 可以直接调用各种 AI 模型。

能力说明：

模型搜索和下载
推理 API 调用
数据集访问
模型评估
Spaces 应用部署

Agent 使用场景：

1
# Agent 使用 HuggingFace 推理 API
2
import requests
3

4
def analyze_sentiment(text):
5
    """使用 HuggingFace 模型进行情感分析"""
6
    API_URL = "https://api-inference.huggingface.co/models/finiteautomata/bertweet-base-sentiment-analysis"
7
    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
8

9
    response = requests.post(API_URL, headers=headers, json={"inputs": text})
10
    result = response.json()
11

12
    return {
13
        "label": result[0][0]["label"],
14
        "score": result[0][0]["score"]
15
    }
16

17
# Agent 批量分析用户评论
18
def analyze_reviews(reviews):
19
    results = []
20
    for review in reviews:
21
        sentiment = analyze_sentiment(review["text"])
22
        results.append({
23
            "review": review["text"][:50],
24
            "sentiment": sentiment["label"],
25
            "confidence": f"{sentiment['score']:.2%}"
26
        })
27
    return results

展开收起

1
// Agent 使用 HuggingFace 搜索模型
2
async function findBestModel(task, language) {
3
  const models = await huggingface.searchModels({
4
    task: task,  // e.g., "text-classification"
5
    language: language,  // e.g., "zh"
6
    sort: "downloads",
7
    limit: 5
8
  });
9

10
  return models.map(m => ({
11
    name: m.id,
12
    downloads: m.downloads,
13
    likes: m.likes,
14
    description: m.description
15
  }));
16
}

展开收起

典型指令：

1
在 HuggingFace 上搜索适合中文文本分类的模型，
2
按下载量排序，列出前 5 个并比较它们的优缺点。

2. OpenAI API 集成 🧠#

类别： 大语言模型 协议： REST API

OpenAI 的 GPT 系列是最广泛使用的大语言模型。Agent 可以通过 API 调用 GPT-4o、GPT-4 等模型完成各种任务。

能力说明：

文本生成和补全
多轮对话
Function Calling
Vision（图像理解）
JSON Mode

Agent 使用场景：

1
# Agent 使用 OpenAI API 进行复杂推理
2
from openai import OpenAI
3

4
client = OpenAI()
5

6
def analyze_contract(contract_text):
7
    """使用 GPT-4 分析合同条款"""
8
    response = client.chat.completions.create(
9
        model="gpt-4o",
10
        response_format={"type": "json_object"},
11
        messages=[
12
            {
13
                "role": "system",
14
                "content": "你是一个专业的法律顾问，擅长分析合同条款。请以 JSON 格式返回分析结果。"
15
            },
16
            {
17
                "role": "user",
18
                "content": f"""分析以下合同，提取关键信息：
19

20
{contract_text}
21

22
返回格式：
23
{{
24
  "parties": ["甲方", "乙方"],
25
  "duration": "合同期限",
26
  "amount": "金额",
27
  "risks": ["风险点1", "风险点2"],
28
  "suggestions": ["建议1", "建议2"]
29
}}"""
30
            }
31
        ]
32
    )
33

34
    return json.loads(response.choices[0].message.content)

展开收起

1
// Agent 使用 Function Calling 调用工具
2
const response = await openai.chat.completions.create({
3
  model: "gpt-4o",
4
  messages: [{ role: "user", content: "帮我查一下北京今天的天气" }],
5
  tools: [{
6
    type: "function",
7
    function: {
8
      name: "get_weather",
9
      description: "获取指定城市的天气信息",
10
      parameters: {
11
        type: "object",
12
        properties: {
13
          city: { type: "string", description: "城市名称" },
14
          date: { type: "string", description: "日期，格式 YYYY-MM-DD" }
15
        },
16
        required: ["city"]
17
      }
18
    }
19
  }]
20
});

展开收起

典型指令：

1
用 GPT-4o 分析这份财务报告，
2
提取关键指标，识别潜在风险，
3
生成一份结构化的分析报告。

3. 本地模型运行 (Ollama) 🖥️#

类别： 本地推理 适用工具： Ollama / LM Studio / llama.cpp

本地模型让 Agent 能在不依赖云服务的情况下运行 AI 模型，保护隐私，降低成本。

能力说明：

模型下载和管理
本地推理
API 兼容（OpenAI 格式）
多模型切换
GPU 加速

Agent 使用场景：

1
# Agent 使用 Ollama 运行本地模型
2
import requests
3

4
def local_chat(prompt, model="llama3"):
5
    """使用本地 Ollama 模型"""
6
    response = requests.post("http://localhost:11434/api/generate", json={
7
        "model": model,
8
        "prompt": prompt,
9
        "stream": False
10
    })
11

12
    return response.json()["response"]
13

14
# Agent 用本地模型处理敏感数据
15
def analyze_private_data(data):
16
    # 敏感数据不发送到云端
17
    prompt = f"""分析以下内部数据，找出异常模式：
18

19
{data}
20

21
请用中文回答，列出发现的问题。"""
22
    return local_chat(prompt)

展开收起

Terminal window展开收起

1
# Agent 管理本地模型
2
# 下载模型
3
ollama pull llama3
4
ollama pull codellama
5
ollama pull mistral
6

7
# 列出已安装模型
8
ollama list
9

10
# 运行模型
11
ollama run llama3 "解释什么是 RAG"
12

13
# 使用 API
14
curl http://localhost:11434/api/generate -d '{
15
  "model": "llama3",
16
  "prompt": "为什么天空是蓝色的？"
17
}'

展开收起

典型指令：

1
用 Ollama 在本地运行 Llama3 模型，
2
分析这份包含用户个人信息的数据，
3
确保数据不会发送到外部服务器。

4. 图像生成 (DALL-E/Stable Diffusion) 🎨#

类别： AI 图像生成 适用工具： DALL-E API / Stable Diffusion / Midjourney API

图像生成让 Agent 能从文字描述创建图片，用于设计、营销、创意等场景。

能力说明：

文生图（Text-to-Image）
图像编辑（Inpainting）
风格迁移
图像变体
高分辨率生成

Agent 使用场景：

1
# Agent 使用 DALL-E 生成产品图
2
from openai import OpenAI
3

4
client = OpenAI()
5

6
def generate_product_image(product_name, style, background):
7
    """生成产品营销图片"""
8
    prompt = f"""一张专业的{product_name}产品照片，
9
    {style}风格，{background}背景，
10
    高品质，商业摄影，8K 分辨率"""
11

12
    response = client.images.generate(
13
        model="dall-e-3",
14
        prompt=prompt,
15
        size="1024x1024",
16
        quality="hd",
17
        n=1
18
    )
19

20
    return response.data[0].url
21

22
# Agent 批量生成社交媒体配图
23
def generate_social_images(topics):
24
    images = []
25
    for topic in topics:
26
        url = generate_product_image(
27
            product_name=topic["product"],
28
            style="现代简约",
29
            background="纯色渐变"
30
        )
31
        images.append({"topic": topic["title"], "image_url": url})
32
    return images

展开收起

Terminal window

1
# Agent 使用 Stable Diffusion 本地生成
2
# 通过 API 调用本地 Stable Diffusion WebUI
3
curl -X POST "http://localhost:7860/sdapi/v1/txt2img" \
4
  -H "Content-Type: application/json" \
5
  -d '{
6
    "prompt": "a beautiful sunset over mountains, oil painting style",
7
    "negative_prompt": "blurry, low quality",
8
    "steps": 30,
9
    "width": 1024,
10
    "height": 1024
11
  }'

典型指令：

1
为这篇博客文章生成一张封面图，
2
主题是 "AI Agent 的未来"，
3
风格：科技感、蓝色调、未来主义。

5. 语音识别与合成 🗣️#

类别： 语音处理 适用工具： Whisper / ElevenLabs / Azure Speech

语音技能让 Agent 能”听”和”说”——将语音转为文字，将文字转为语音。

能力说明：

语音转文字（STT）
文字转语音（TTS）
多语言支持
说话人识别
情感语音

Agent 使用场景：

1
# Agent 使用 Whisper 进行语音转文字
2
import whisper
3

4
def transcribe_audio(audio_path, language="zh"):
5
    """将音频转为文字"""
6
    model = whisper.load_model("medium")
7
    result = model.transcribe(audio_path, language=language)
8

9
    # 带时间戳的转录
10
    segments = []
11
    for segment in result["segments"]:
12
        segments.append({
13
            "start": segment["start"],
14
            "end": segment["end"],
15
            "text": segment["text"]
16
        })
17

18
    return {
19
        "text": result["text"],
20
        "segments": segments,
21
        "language": result["language"]
22
    }
23

24
# Agent 生成会议纪要
25
def generate_meeting_minutes(audio_path):
26
    # 1. 语音转文字
27
    transcript = transcribe_audio(audio_path)
28

29
    # 2. 用 LLM 生成纪要
30
    minutes = llm.generate(f"""
31
    根据以下会议转录生成会议纪要：
32

33
    {transcript['text']}
34

35
    包含：主题、讨论要点、决议、待办事项。
36
    """)
37

38
    return {"transcript": transcript, "minutes": minutes}

展开收起

1
# Agent 使用 ElevenLabs 生成语音
2
import requests
3

4
def text_to_speech(text, voice_id="alloy"):
5
    """将文字转为语音"""
6
    response = requests.post(
7
        "https://api.elevenlabs.io/v1/text-to-speech/{voice_id}",
8
        headers={"xi-api-key": ELEVENLABS_API_KEY},
9
        json={
10
            "text": text,
11
            "model_id": "eleven_multilingual_v2",
12
            "voice_settings": {
13
                "stability": 0.5,
14
                "similarity_boost": 0.75
15
            }
16
        }
17
    )
18

19
    with open("output.mp3", "wb") as f:
20
        f.write(response.content)
21

22
    return "output.mp3"

展开收起

典型指令：

1
把这段 1 小时的会议录音转成文字，
2
识别不同说话人，生成结构化会议纪要，
3
然后把纪要用语音读出来。

6. Embedding 模型服务 📐#

类别： 文本向量化 适用工具： OpenAI Embedding / Sentence Transformers / Cohere

Embedding 将文本转换为向量表示，是语义搜索、推荐系统、RAG 的基础。

能力说明：

文本向量化
语义相似度计算
批量处理
多语言支持
维度选择

Agent 使用场景：

1
# Agent 使用 OpenAI Embedding
2
from openai import OpenAI
3
import numpy as np
4

5
client = OpenAI()
6

7
def get_embedding(text, model="text-embedding-3-small"):
8
    """获取文本的向量表示"""
9
    response = client.embeddings.create(
10
        input=text,
11
        model=model
12
    )
13
    return response.data[0].embedding
14

15
def cosine_similarity(vec1, vec2):
16
    """计算余弦相似度"""
17
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
18

19
# Agent 语义搜索
20
def semantic_search(query, documents, top_k=5):
21
    """在文档中进行语义搜索"""
22
    query_vec = get_embedding(query)
23

24
    scores = []
25
    for doc in documents:
26
        doc_vec = get_embedding(doc["content"])
27
        score = cosine_similarity(query_vec, doc_vec)
28
        scores.append({"doc": doc, "score": score})
29

30
    scores.sort(key=lambda x: x["score"], reverse=True)
31
    return scores[:top_k]

展开收起

1
# Agent 使用 Sentence Transformers 本地 Embedding
2
from sentence_transformers import SentenceTransformer
3

4
model = SentenceTransformer('all-MiniLM-L6-v2')
5

6
def batch_embed(texts):
7
    """批量向量化"""
8
    embeddings = model.encode(texts, show_progress_bar=True)
9
    return embeddings.tolist()

典型指令：

1
用 Embedding 模型对这 1000 篇文章进行向量化，
2
建立语义搜索索引，支持自然语言查询。

7. 向量搜索优化 🔍#

类别： 向量检索 适用工具： FAISS / Annoy / ScaNN

向量搜索优化让 Agent 能在海量向量中快速找到最相似的结果。

能力说明：

近似最近邻搜索（ANN）
索引构建和优化
内存映射
分布式搜索
过滤和重排

Agent 使用场景：

1
# Agent 使用 FAISS 进行高效向量搜索
2
import faiss
3
import numpy as np
4

5
def build_index(vectors):
6
    """构建 FAISS 索引"""
7
    dimension = len(vectors[0])
8
    index = faiss.IndexFlatIP(dimension)  # 内积相似度
9

10
    # 转换为 float32
11
    vectors = np.array(vectors, dtype='float32')
12
    faiss.normalize_L2(vectors)  # L2 归一化
13

14
    index.add(vectors)
15
    return index
16

17
def search(index, query_vector, top_k=10):
18
    """搜索最相似的向量"""
19
    query = np.array([query_vector], dtype='float32')
20
    faiss.normalize_L2(query)
21

22
    distances, indices = index.search(query, top_k)
23
    return list(zip(indices[0], distances[0]))
24

25
# Agent 构建百万级向量索引
26
def build_large_index(vectors, index_path):
27
    """构建大规模索引"""
28
    dimension = len(vectors[0])
29

30
    # 使用 IVF 索引加速搜索
31
    nlist = 1000  # 聚类数
32
    quantizer = faiss.IndexFlatIP(dimension)
33
    index = faiss.IndexIVFFlat(quantizer, dimension, nlist)
34

35
    # 训练索引
36
    vectors = np.array(vectors, dtype='float32')
37
    faiss.normalize_L2(vectors)
38
    index.train(vectors)
39
    index.add(vectors)
40

41
    # 保存索引
42
    faiss.write_index(index, index_path)
43
    return index

展开收起

典型指令：

1
用 FAISS 对 100 万条用户行为数据建立向量索引，
2
支持实时相似用户查询，响应时间控制在 10ms 以内。

8. 模型微调 🎯#

类别： 模型训练 适用工具： HuggingFace Transformers / LoRA / QLoRA

模型微调让 Agent 能根据特定领域数据定制模型，提升专业任务的效果。

能力说明：

全参数微调
LoRA/QLoRA 高效微调
数据准备和清洗
训练监控
模型评估

Agent 使用场景：

1
# Agent 使用 LoRA 微调模型
2
from transformers import AutoModelForCausalLM, AutoTokenizer
3
from peft import LoraConfig, get_peft_model
4
from datasets import load_dataset
5

6
def fine_tune_model(base_model, dataset_path, output_dir):
7
    """使用 LoRA 微调语言模型"""
8
    # 加载基础模型
9
    model = AutoModelForCausalLM.from_pretrained(base_model)
10
    tokenizer = AutoTokenizer.from_pretrained(base_model)
11

12
    # 配置 LoRA
13
    lora_config = LoraConfig(
14
        r=16,  # 秩
15
        lora_alpha=32,
16
        target_modules=["q_proj", "v_proj"],
17
        lora_dropout=0.05,
18
        bias="none",
19
        task_type="CAUSAL_LM"
20
    )
21

22
    # 应用 LoRA
23
    model = get_peft_model(model, lora_config)
24

25
    # 加载数据集
26
    dataset = load_dataset("json", data_files=dataset_path)
27

28
    # 训练配置
29
    training_args = TrainingArguments(
30
        output_dir=output_dir,
31
        num_train_epochs=3,
32
        per_device_train_batch_size=4,
33
        gradient_accumulation_steps=4,
34
        learning_rate=2e-4,
35
        fp16=True,
36
        logging_steps=10,
37
        save_strategy="epoch"
38
    )
39

40
    # 开始训练
41
    trainer = Trainer(
42
        model=model,
43
        args=training_args,
44
        train_dataset=dataset["train"]
45
    )
46

47
    trainer.train()
48
    model.save_pretrained(output_dir)

展开收起

典型指令：

1
用这 1000 条客服对话数据微调 Llama3 模型，
2
让它能更好地回答我们产品相关的问题，
3
用 LoRA 节省显存。

9. AI Agent 框架 🤖#

类别： Agent 开发 适用工具： LangChain / LlamaIndex / AutoGen

Agent 框架提供了构建复杂 AI 应用的基础设施——工具调用、记忆管理、任务规划。

能力说明：

工具链编排
记忆管理
任务规划
多 Agent 协作
链式调用（Chain）

Agent 使用场景：

1
# Agent 使用 LangChain 构建复杂应用
2
from langchain.agents import AgentExecutor, create_react_agent
3
from langchain.tools import Tool
4
from langchain_openai import ChatOpenAI
5

6
# 定义工具
7
tools = [
8
    Tool(name="搜索", func=search_web, description="搜索互联网"),
9
    Tool(name="数据库", func=query_db, description="查询数据库"),
10
    Tool(name="计算", func=calculator, description="数学计算"),
11
]
12

13
# 创建 Agent
14
llm = ChatOpenAI(model="gpt-4o")
15
agent = create_react_agent(llm, tools, prompt)
16
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
17

18
# 运行
19
result = executor.invoke({
20
    "input": "分析最近一个月的销售趋势，找出增长最快的产品"
21
})

展开收起

1
# Agent 使用 LlamaIndex 构建 RAG 应用
2
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
3

4
# 加载文档
5
documents = SimpleDirectoryReader('./data').load_data()
6

7
# 创建索引
8
index = VectorStoreIndex.from_documents(documents)
9

10
# 创建查询引擎
11
query_engine = index.as_query_engine()
12

13
# 查询
14
response = query_engine.query("这个项目的架构是怎样的？")
15
print(response)

展开收起

典型指令：

1
用 LangChain 构建一个研究助手 Agent，
2
能搜索互联网、读取论文、生成报告，
3
支持多轮对话和任务规划。

10. 多模态理解 👁️#

类别： 多模态 AI 适用工具： GPT-4o Vision / Claude Vision / LLaVA

多模态让 Agent 能”看懂”图片——识别内容、提取文字、分析图表。

能力说明：

图像理解
OCR 文字识别
图表分析
视频理解
多模态对话

Agent 使用场景：

1
# Agent 使用 GPT-4o Vision 分析图片
2
from openai import OpenAI
3

4
client = OpenAI()
5

6
def analyze_image(image_url, question):
7
    """分析图片内容"""
8
    response = client.chat.completions.create(
9
        model="gpt-4o",
10
        messages=[
11
            {
12
                "role": "user",
13
                "content": [
14
                    {"type": "text", "text": question},
15
                    {
16
                        "type": "image_url",
17
                        "image_url": {"url": image_url}
18
                    }
19
                ]
20
            }
21
        ]
22
    )
23

24
    return response.choices[0].message.content
25

26
# Agent 分析截图中的 UI 问题
27
def analyze_screenshot(screenshot_path):
28
    """分析 UI 截图"""
29
    with open(screenshot_path, "rb") as f:
30
        image_data = base64.b64encode(f.read()).decode()
31

32
    result = analyze_image(
33
        image_url=f"data:image/png;base64,{image_data}",
34
        question="分析这个 UI 截图，找出可能的用户体验问题和改进建议。"
35
    )
36

37
    return result

展开收起

1
# Agent 使用 Claude Vision 分析文档
2
import anthropic
3

4
client = anthropic.Anthropic()
5

6
def analyze_document(image_path, question):
7
    """分析文档图片"""
8
    with open(image_path, "rb") as f:
9
        image_data = base64.b64encode(f.read()).decode()
10

11
    response = client.messages.create(
12
        model="claude-3-opus-20240229",
13
        max_tokens=1024,
14
        messages=[
15
            {
16
                "role": "user",
17
                "content": [
18
                    {
19
                        "type": "image",
20
                        "source": {
21
                            "type": "base64",
22
                            "media_type": "image/png",
23
                            "data": image_data
24
                        }
25
                    },
26
                    {
27
                        "type": "text",
28
                        "text": question
29
                    }
30
                ]
31
            }
32
        ]
33
    )
34

35
    return response.content[0].text

展开收起

典型指令：

1
分析这张财务报表的截图，
2
提取所有数字，识别趋势和异常，
3
生成一份文字分析报告。

本篇小结#

#	Skill	类别	难度	价值
1	HuggingFace MCP	AI 模型平台	⭐⭐	⭐⭐⭐⭐⭐
2	OpenAI API	大语言模型	⭐⭐	⭐⭐⭐⭐⭐
3	本地模型 (Ollama)	本地推理	⭐⭐	⭐⭐⭐⭐⭐
4	图像生成	AI 图像	⭐⭐⭐	⭐⭐⭐⭐⭐
5	语音识别合成	语音处理	⭐⭐⭐	⭐⭐⭐⭐
6	Embedding 模型	文本向量化	⭐⭐	⭐⭐⭐⭐⭐
7	向量搜索优化	向量检索	⭐⭐⭐	⭐⭐⭐⭐
8	模型微调	模型训练	⭐⭐⭐⭐	⭐⭐⭐⭐
9	AI Agent 框架	Agent 开发	⭐⭐⭐	⭐⭐⭐⭐⭐
10	多模态理解	多模态 AI	⭐⭐⭐	⭐⭐⭐⭐⭐

核心观点： AI/ML Skills 是 Agent 的”大脑升级”。一个能调用大模型、生成图片、识别语音、理解多模态的 Agent，才能真正成为”智能助手”，而不只是”自动化脚本”。

系列导航#

👈 上一篇： 第十篇：创意与可视化
📖 完整系列：
- 第一篇：代码审查与质量守护
- 第二篇：数据库与数据存储
- 第三篇：浏览器自动化与爬虫
- 第四篇：搜索与信息获取
- 第五篇：云服务与 DevOps
- 第六篇：知识管理与 RAG
- 第七篇：版本控制与协作
- 第八篇：文档与文件处理
- 第九篇：通信与通知集成
- 第十篇：创意与可视化
- ✅ 第十一篇：AI/ML 专用技能（你在这里）

100 个 Agent Skills 盘点（十）：创意与可视化

Wed, 10 Jun 2026 00:00:00 GMT

封面

写在前面#

这是「100 个 Agent Skills 盘点」系列的最后一篇。十篇下来，我们从代码审查、数据库、浏览器、搜索、云服务、知识管理、版本控制、文档处理、通信通知，一路走到了最后这个轻松的话题：创意与可视化。

如果说前面的 Skills 让 Agent 变得”能干”，那创意 Skills 让 Agent 变得”好看”——能画图、能做表、能生成演示文稿、能创造视觉内容。同时，我们还深入探讨了多 Agent 编排和记忆系统，这两个让 Agent 从”单兵作战”进化为”团队协作”的关键能力。

1. Mermaid 图表 🧜‍♀️#

类别： 文本图表 适用工具： Mermaid.js

Mermaid 用简单的文本语法就能生成各种图表——流程图、时序图、甘特图、类图等。它是文档中嵌入图表的最佳选择。

能力说明：

流程图（Flowchart）
时序图（Sequence Diagram）
类图（Class Diagram）
甘特图（Gantt Chart）
状态图（State Diagram）
饼图（Pie Chart）

Agent 使用场景：

# Agent 生成系统架构图 graph TB Client[客户端] --> LB[负载均衡] LB --> API1[API 服务器 1] LB --> API2[API 服务器 2] LB --> API3[API 服务器 3] API1 --> Cache[Redis 缓存] API2 --> Cache API3 --> Cache API1 --> DB[(PostgreSQL)] API2 --> DB API3 --> DB API1 --> Queue[消息队列] Queue --> Worker1[Worker 1] Queue --> Worker2[Worker 2] Worker1 --> S3[S3 存储] Worker2 --> S3

# Agent 生成时序图 sequenceDiagram participant U as 用户 participant A as API participant D as 数据库 participant C as 缓存 U->>A: 请求数据 A->>C: 检查缓存 alt 缓存命中 C-->>A: 返回缓存数据 else 缓存未命中 A->D: 查询数据库 D-->>A: 返回数据 A->>C: 写入缓存 end A-->>U: 返回响应

# Agent 生成甘特图 gantt title 项目开发计划 dateFormat YYYY-MM-DD section 需求阶段需求分析 :done, des1, 2026-06-01, 5d 需求评审 :done, des2, after des1, 2d section 开发阶段后端开发 :active, dev1, 2026-06-08, 10d 前端开发 : dev2, 2026-06-10, 8d section 测试阶段集成测试 : test1, after dev1, 5d 验收测试 : test2, after test1, 3d

典型指令：

1
根据这段代码的调用关系，生成一个 Mermaid 时序图，
2
展示 API 请求从前端到数据库的完整流程。

2. Chart.js 图表 📊#

类别： 数据可视化 适用工具： Chart.js / ECharts / D3.js

数据可视化让枯燥的数字变得直观。Agent 可以生成各种图表——折线图、柱状图、饼图、散点图等。

能力说明：

折线图（趋势）
柱状图（对比）
饼图（占比）
散点图（相关性）
热力图（分布）
仪表盘（指标）

Agent 使用场景：

1
// Agent 生成数据可视化 HTML
2
function generateChart(data) {
3
  return `
4
    <html>
5
    <head>
6
      <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
7
      <style>
8
        body { font-family: sans-serif; padding: 20px; }
9
        .chart-container { max-width: 800px; margin: 0 auto; }
10
      </style>
11
    </head>
12
    <body>
13
      <h2>${data.title}</h2>
14
      <div class="chart-container">
15
        <canvas id="chart"></canvas>
16
      </div>
17
      <script>
18
        new Chart(document.getElementById('chart'), {
19
          type: '${data.type}',
20
          data: {
21
            labels: ${JSON.stringify(data.labels)},
22
            datasets: [{
23
              label: '${data.datasetLabel}',
24
              data: ${JSON.stringify(data.values)},
25
              backgroundColor: [
26
                '#2563eb', '#10b981', '#f59e0b',
27
                '#ef4444', '#8b5cf6', '#06b6d4'
28
              ],
29
              borderWidth: 1
30
            }]
31
          },
32
          options: {
33
            responsive: true,
34
            plugins: {
35
              legend: { position: 'top' },
36
              title: { display: true, text: '${data.title}' }
37
            }
38
          }
39
        });
40
      </script>
41
    </body>
42
    </html>
43
  `;
44
}

展开收起

常用图表类型：

图表类型	适用场景	示例
折线图	趋势变化	用户增长趋势
柱状图	数量对比	各部门销售额
饼图	占比分析	市场份额
散点图	相关性	价格 vs 销量
热力图	分布密度	用户活跃时段

3. SVG 绘制 🎨#

类别： 矢量图形 适用工具： SVG 语法

SVG 是矢量图形的标准格式，可以无限缩放而不失真。Agent 可以直接生成 SVG 代码，创建图标、图表、插画。

能力说明：

基础形状（矩形、圆形、线条）
路径绘制
渐变和滤镜
动画
交互

Agent 使用场景：

1
<!-- Agent 生成的项目进度图 -->
2
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 400">
3
  <!-- 背景 -->
4
  <rect width="800" height="400" fill="#f8fafc" rx="12"/>
5

6
  <!-- 标题 -->
7
  <text x="400" y="40" text-anchor="middle"
8
        font-size="24" font-weight="bold" fill="#1e293b">
9
    项目进度概览
10
  </text>
11

12
  <!-- 进度条 - 需求分析 -->
13
  <text x="50" y="100" font-size="14" fill="#475569">需求分析</text>
14
  <rect x="200" y="85" width="400" height="24" rx="12" fill="#e2e8f0"/>
15
  <rect x="200" y="85" width="400" height="24" rx="12" fill="#10b981"/>
16
  <text x="620" y="102" font-size="14" fill="#10b981" font-weight="bold">100%</text>
17

18
  <!-- 进度条 - 后端开发 -->
19
  <text x="50" y="150" font-size="14" fill="#475569">后端开发</text>
20
  <rect x="200" y="135" width="400" height="24" rx="12" fill="#e2e8f0"/>
21
  <rect x="200" y="135" width="280" height="24" rx="12" fill="#2563eb"/>
22
  <text x="620" y="152" font-size="14" fill="#2563eb" font-weight="bold">70%</text>
23

24
  <!-- 进度条 - 前端开发 -->
25
  <text x="50" y="200" font-size="14" fill="#475569">前端开发</text>
26
  <rect x="200" y="185" width="400" height="24" rx="12" fill="#e2e8f0"/>
27
  <rect x="200" y="185" width="200" height="24" rx="12" fill="#f59e0b"/>
28
  <text x="620" y="202" font-size="14" fill="#f59e0b" font-weight="bold">50%</text>
29

30
  <!-- 进度条 - 测试 -->
31
  <text x="50" y="250" font-size="14" fill="#475569">测试</text>
32
  <rect x="200" y="235" width="400" height="24" rx="12" fill="#e2e8f0"/>
33
  <rect x="200" y="235" width="80" height="24" rx="12" fill="#ef4444"/>
34
  <text x="620" y="252" font-size="14" fill="#ef4444" font-weight="bold">20%</text>
35

36
  <!-- 图例 -->
37
  <circle cx="200" cy="330" r="6" fill="#10b981"/>
38
  <text x="215" y="335" font-size="12" fill="#475569">已完成</text>
39
  <circle cx="300" cy="330" r="6" fill="#2563eb"/>
40
  <text x="315" y="335" font-size="12" fill="#475569">进行中</text>
41
  <circle cx="400" cy="330" r="6" fill="#f59e0b"/>
42
  <text x="415" y="335" font-size="12" fill="#475569">部分完成</text>
43
  <circle cx="500" cy="330" r="6" fill="#ef4444"/>
44
  <text x="515" y="335" font-size="12" fill="#475569">刚开始</text>
45
</svg>

展开收起

典型指令：

1
生成一个 SVG 格式的项目状态看板，
2
用不同颜色表示各模块的完成进度，
3
包含图例和百分比标注。

4. 多 Agent 编排 🤖🤝🤖#

类别： Agent 架构 适用工具： CrewAI / LangGraph / AutoGen

单个 Agent 能力再强，面对复杂任务也会力不从心。多 Agent 编排让多个专业 Agent 各司其职、协同作战，像一支训练有素的团队一样完成任务。

能力说明：

任务分解与分配
Agent 角色定义（研究员、编码者、审核者等）
工作流编排（顺序、并行、条件分支）
Agent 间通信与状态传递
结果聚合与冲突解决

为什么需要多 Agent？

单 Agent 模式存在天然瓶颈：上下文窗口有限、角色混乱导致输出质量下降、无法并行处理子任务。多 Agent 架构通过”分而治之”解决这些问题——每个 Agent 专注一个角色，拥有独立的上下文和工具集，由编排器协调它们的工作。

Agent 使用场景：

1
# 使用 CrewAI 编排多 Agent 协作
2
from crewai import Agent, Task, Crew
3

4
# 定义专业 Agent
5
researcher = Agent(
6
    role="技术研究员",
7
    goal="深入调研技术方案的可行性和最佳实践",
8
    backstory="你是一位资深技术研究员，擅长分析技术趋势和评估方案。",
9
    tools=[web_search, arxiv_search],
10
    verbose=True
11
)
12

13
architect = Agent(
14
    role="系统架构师",
15
    goal="设计高可用、可扩展的系统架构",
16
    backstory="你是一位经验丰富的架构师，擅长微服务和分布式系统设计。",
17
    tools=[diagram_tool, code_analysis],
18
    verbose=True
19
)
20

21
developer = Agent(
22
    role="高级开发者",
23
    goal="编写高质量、可维护的代码实现",
24
    backstory="你是一位全栈开发者，精通 Python/TypeScript，注重代码质量。",
25
    tools=[code_editor, terminal, test_runner],
26
    verbose=True
27
)
28

29
reviewer = Agent(
30
    role="代码审核者",
31
    goal="确保代码质量、安全性和最佳实践",
32
    backstory="你是一位严格的代码审核者，关注安全漏洞和性能问题。",
33
    tools=[lint_tool, security_scanner],
34
    verbose=True
35
)
36

37
# 定义任务链
38
research_task = Task(
39
    description="调研 OAuth 2.0 + PKCE 的最新最佳实践，分析安全性要求",
40
    agent=researcher,
41
    expected_output="详细的技术调研报告，包含方案对比和推荐"
42
)
43

44
design_task = Task(
45
    description="基于调研结果，设计认证系统的整体架构",
46
    agent=architect,
47
    expected_output="系统架构图和详细设计文档",
48
    context=[research_task]  # 依赖调研结果
49
)
50

51
implement_task = Task(
52
    description="根据架构设计，实现核心认证模块",
53
    agent=developer,
54
    expected_output="完整的代码实现和单元测试",
55
    context=[design_task]  # 依赖架构设计
56
)
57

58
review_task = Task(
59
    description="审核代码实现，检查安全漏洞和代码质量",
60
    agent=reviewer,
61
    expected_output="审核报告和改进建议",
62
    context=[implement_task]  # 依赖代码实现
63
)
64

65
# 编排执行
66
crew = Crew(
67
    agents=[researcher, architect, developer, reviewer],
68
    tasks=[research_task, design_task, implement_task, review_task],
69
    verbose=True
70
)
71

72
result = crew.kickoff()

展开收起

1
# 使用 LangGraph 构建带条件分支的工作流
2
from langgraph.graph import StateGraph, END
3
from typing import TypedDict
4

5
class WorkflowState(TypedDict):
6
    task: str
7
    research_result: str
8
    code: str
9
    review_result: str
10
    approved: bool
11

12
# 定义节点函数
13
def research_node(state: WorkflowState) -> WorkflowState:
14
    """研究员 Agent 执行调研"""
15
    result = researcher_agent.invoke({
16
        "task": state["task"]
17
    })
18
    return {"research_result": result}
19

20
def code_node(state: WorkflowState) -> WorkflowState:
21
    """开发者 Agent 编写代码"""
22
    result = developer_agent.invoke({
23
        "task": state["task"],
24
        "research": state["research_result"]
25
    })
26
    return {"code": result}
27

28
def review_node(state: WorkflowState) -> WorkflowState:
29
    """审核者 Agent 审查代码"""
30
    result = reviewer_agent.invoke({
31
        "code": state["code"]
32
    })
33
    approved = "LGTM" in result
34
    return {"review_result": result, "approved": approved}
35

36
def route_review(state: WorkflowState) -> str:
37
    """条件路由：审核通过则结束，否则返回修改"""
38
    return "approved" if state["approved"] else "revise"
39

40
def revise_node(state: WorkflowState) -> WorkflowState:
41
    """开发者 Agent 根据审核意见修改"""
42
    result = developer_agent.invoke({
43
        "code": state["code"],
44
        "feedback": state["review_result"]
45
    })
46
    return {"code": result}
47

48
# 构建工作流图
49
workflow = StateGraph(WorkflowState)
50

51
# 添加节点
52
workflow.add_node("research", research_node)
53
workflow.add_node("code", code_node)
54
workflow.add_node("review", review_node)
55
workflow.add_node("revise", revise_node)
56

57
# 添加边
58
workflow.set_entry_point("research")
59
workflow.add_edge("research", "code")
60
workflow.add_edge("code", "review")
61
workflow.add_conditional_edges(
62
    "review",
63
    route_review,
64
    {"approved": END, "revise": "revise"}
65
)
66
workflow.add_edge("revise", "review")
67

68
# 编译并运行
69
app = workflow.compile()
70
result = app.invoke({"task": "实现用户认证系统"})

展开收起

典型指令：

1
用 CrewAI 编排一个多 Agent 团队来完成这个任务：
2
1. 研究员 Agent 调研竞品的技术方案
3
2. 架构师 Agent 设计我们的系统架构
4
3. 开发者 Agent 实现核心功能
5
4. 测试者 Agent 编写测试用例并验证
6
确保每个 Agent 的输出会传递给下一个 Agent 作为输入。

5. 演示文稿生成 📽️#

类别： 演示工具 适用工具： reveal.js / Slidev / Marp

Agent 可以自动生成演示文稿——从 Markdown 创建幻灯片，支持代码高亮、动画、主题。

能力说明：

Markdown 转幻灯片
代码高亮
动画效果
主题定制
导出 PDF

Agent 使用场景：

1
<!-- Agent 生成的 Slidev 演示文稿 -->
2
---
3
theme: default
4
title: AI Agent Skills 技术分享
5
---
6

7
# AI Agent Skills 技术分享
8

9
让 AI 成为你的开发伙伴
10

11
---
12
layout: two-cols
13
---
14

15
# 什么是 Agent Skills？
16

17
Agent Skills 是 AI Agent 的能力模块：
18

19
- 🔍 搜索与信息获取
20
- 💾 数据库操作
21
- 🌐 浏览器自动化
22
- 📄 文档处理
23
- ☁️ 云服务管理
24

25
::right::
26

27
```mermaid
28
graph TD
29
    A[AI Agent] --> B[Skills]
30
    B --> C[Search]
31
    B --> D[Database]
32
    B --> E[Browser]
33
    B --> F[Documents]
34
    B --> G[Cloud]

展开收起

核心架构#

1
interface Agent {
2
  skills: Skill[];
3
  memory: Memory;
4
  tools: Tool[];
5

6
  async execute(task: Task): Promise<Result> {
7
    const plan = await this.plan(task);
8
    for (const step of plan.steps) {
9
      const skill = this.selectSkill(step);
10
      await skill.execute(step);
11
    }
12
  }
13
}

Demo#

让我们看一个实际的 Demo…

1
**典型指令：**

根据这篇文章的内容，生成一个 10 页的 Slidev 演示文稿，主题是 “AI Agent Skills 入门”，包含代码示例和架构图。

1
---
2

3
## 6. 思维导图 🧠
4

5
**类别：** 知识可视化
6
**适用工具：** Markmap / Mermaid mindmap
7

8
> 思维导图是组织和展示知识结构的最佳方式。Agent 可以从文本自动生成思维导图。
9

10
**能力说明：**
11
- Markdown 转思维导图
12
- 自动层级识别
13
- 交互式展开/折叠
14
- 导出为图片
15

16
**Agent 使用场景：**
17

18
```markdown
19
<!-- Agent 生成的 Markmap 思维导图 -->
20

21
# AI Agent 技术栈
22

23
## 基础能力
24
- 代码生成
25
  - 函数编写
26
  - 类设计
27
  - 测试生成
28
- 代码理解
29
  - 代码阅读
30
  - Bug 定位
31
  - 架构分析
32

33
## 数据能力
34
- 数据库
35
  - PostgreSQL
36
  - Redis
37
  - MongoDB
38
- 文件处理
39
  - PDF 解析
40
  - Excel 处理
41
  - 图片识别
42

43
## 自动化能力
44
- 浏览器
45
  - 网页抓取
46
  - 表单填写
47
  - 截图
48
- DevOps
49
  - Docker
50
  - CI/CD
51
  - 监控
52

53
## 协作能力
54
- 版本控制
55
  - Git 操作
56
  - PR 管理
57
- 通信
58
  - Slack
59
  - 邮件
60
  - 通知

展开收起

典型指令：

1
把这篇技术文章的内容整理成思维导图，
2
用 Markmap 格式，层级不超过 3 层。

7. 表格美化 📋#

类别： 数据展示 适用工具： Markdown / HTML

好的表格能让数据一目了然。Agent 可以生成各种格式的美化表格。

能力说明：

Markdown 表格
HTML 表格（带样式）
ASCII 表格（终端）
条件格式

Agent 使用场景：

1
Agent 生成的终端表格：
2

3
┌──────────────┬──────────┬──────────┬──────────┐
4
│     服务     │   状态   │  延迟    │  错误率  │
5
├──────────────┼──────────┼──────────┼──────────┤
6
│ API 服务器   │ 🟢 正常  │  45ms    │  0.01%   │
7
│ 数据库       │ 🟢 正常  │  12ms    │  0.00%   │
8
│ Redis 缓存   │ 🟢 正常  │  3ms     │  0.00%   │
9
│ 消息队列     │ 🟡 警告  │  120ms   │  0.50%   │
10
│ 文件存储     │ 🔴 异常  │  2000ms  │  5.20%   │
11
└──────────────┴──────────┴──────────┴──────────┘

1
<!-- Agent 生成的 HTML 美化表格 -->
2
<table style="width: 100%; border-collapse: collapse; font-family: sans-serif;">
3
  <thead>
4
    <tr style="background: #2563eb; color: white;">
5
      <th style="padding: 12px; text-align: left;">产品</th>
6
      <th style="padding: 12px; text-align: right;">销量</th>
7
      <th style="padding: 12px; text-align: right;">收入</th>
8
      <th style="padding: 12px; text-align: right;">增长率</th>
9
    </tr>
10
  </thead>
11
  <tbody>
12
    <tr style="background: #f0fdf4;">
13
      <td style="padding: 10px;">产品 A</td>
14
      <td style="padding: 10px; text-align: right;">1,234</td>
15
      <td style="padding: 10px; text-align: right;">¥89,000</td>
16
      <td style="padding: 10px; text-align: right; color: #10b981;">+23%</td>
17
    </tr>
18
    <tr>
19
      <td style="padding: 10px;">产品 B</td>
20
      <td style="padding: 10px; text-align: right;">856</td>
21
      <td style="padding: 10px; text-align: right;">¥45,000</td>
22
      <td style="padding: 10px; text-align: right; color: #ef4444;">-5%</td>
23
    </tr>
24
  </tbody>
25
</table>

展开收起

典型指令：

1
把这个数据对比结果做成一个漂亮的表格，
2
增长率超过 10% 的标绿，下降的标红。

8. 代码高亮展示 💡#

类别： 代码美化 适用工具： Shiki / Prism.js / highlight.js

好的代码展示能让技术文档更专业。Agent 可以生成带语法高亮的代码片段。

能力说明：

语法高亮
行号显示
代码对比
主题定制

Agent 使用场景：

1
<!-- Agent 生成的代码展示组件 -->
2
<div style="background: #1e1e1e; border-radius: 8px; padding: 16px; overflow-x: auto;">
3
  <div style="display: flex; align-items: center; margin-bottom: 12px;">
4
    <span style="color: #ff5f57; margin-right: 6px;">●</span>
5
    <span style="color: #febc2e; margin-right: 6px;">●</span>
6
    <span style="color: #28c840; margin-right: 12px;">●</span>
7
    <span style="color: #888; font-size: 12px;">example.ts</span>
8
  </div>
9
  <pre style="margin: 0; font-family: 'Fira Code', monospace; font-size: 14px; line-height: 1.6;">
10
<code><span style="color: #569cd6;">interface</span> <span style="color: #4ec9b0;">Agent</span> {
11
  <span style="color: #9cdcfe;">skills</span>: <span style="color: #4ec9b0;">Skill</span>[];
12
  <span style="color: #9cdcfe;">execute</span>(<span style="color: #9cdcfe;">task</span>: <span style="color: #4ec9b0;">string</span>): <span style="color: #4ec9b0;">Promise</span>&lt;<span style="color: #4ec9b0;">Result</span>&gt;;
13
}
14

15
<span style="color: #569cd6;">const</span> <span style="color: #4fc1ff;">agent</span>: <span style="color: #4ec9b0;">Agent</span> = {
16
  <span style="color: #9cdcfe;">skills</span>: [<span style="color: #ce9178;">'search'</span>, <span style="color: #ce9178;">'database'</span>, <span style="color: #ce9178;">'browser'</span>],
17
  <span style="color: #569cd6;">async</span> <span style="color: #dcdcaa;">execute</span>(<span style="color: #9cdcfe;">task</span>) {
18
    <span style="color: #c586c0;">return</span> <span style="color: #569cd6;">await</span> <span style="color: #dcdcaa;">process</span>(<span style="color: #9cdcfe;">task</span>);
19
  }
20
};</code>
21
  </pre>
22
</div>

展开收起

9. 信息图表 (Infographic) 📈#

类别： 数据叙事 适用工具： SVG / HTML + CSS

信息图表把复杂的数据和信息用视觉化的方式呈现，让读者一眼就能理解核心信息。

能力说明：

数据卡片
流程信息图
对比图表
统计可视化

Agent 使用场景：

1
<!-- Agent 生成的信息卡片 -->
2
<div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 16px; font-family: sans-serif;">
3
  <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 24px; border-radius: 12px;">
4
    <div style="font-size: 14px; opacity: 0.8;">活跃用户</div>
5
    <div style="font-size: 36px; font-weight: bold; margin: 8px 0;">12,847</div>
6
    <div style="font-size: 12px; color: #a7f3d0;">↑ 23% vs 上月</div>
7
  </div>
8

9
  <div style="background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%); color: white; padding: 24px; border-radius: 12px;">
10
    <div style="font-size: 14px; opacity: 0.8;">月收入</div>
11
    <div style="font-size: 36px; font-weight: bold; margin: 8px 0;">¥89.5K</div>
12
    <div style="font-size: 12px; color: #a7f3d0;">↑ 15% vs 上月</div>
13
  </div>
14

15
  <div style="background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%); color: white; padding: 24px; border-radius: 12px;">
16
    <div style="font-size: 14px; opacity: 0.8;">转化率</div>
17
    <div style="font-size: 36px; font-weight: bold; margin: 8px 0;">3.2%</div>
18
    <div style="font-size: 12px; color: #a7f3d0;">↑ 0.5% vs 上月</div>
19
  </div>
20

21
  <div style="background: linear-gradient(135deg, #43e97b 0%, #38f9d7 100%); color: white; padding: 24px; border-radius: 12px;">
22
    <div style="font-size: 14px; opacity: 0.8;">NPS 评分</div>
23
    <div style="font-size: 36px; font-weight: bold; margin: 8px 0;">72</div>
24
    <div style="font-size: 12px; color: #a7f3d0;">↑ 8 vs 上月</div>
25
  </div>
26
</div>

展开收起

典型指令：

1
把这份运营数据做成一套信息卡片，
2
用渐变背景和大数字展示关键指标，
3
每个卡片显示同比变化。

10. Agent 记忆系统 🧠💾#

类别： Agent 记忆 适用工具： Memory MCP Server / Mem0 / 自定义

没有记忆的 Agent 每次对话都是”初次见面”。记忆系统让 Agent 能记住用户偏好、历史交互和学到的知识，从”无状态工具”进化为”有记忆的伙伴”。

能力说明：

短期记忆（对话上下文，当前会话的工作记忆）
长期记忆（跨会话持久化的用户偏好、知识积累）
工作记忆（任务执行中的中间状态和决策记录）
记忆检索与遗忘（按相关性检索，自动清理过时信息）

为什么记忆如此重要？

想象你每天都要向同事重新介绍自己——这就是没有记忆的 Agent 的处境。记忆系统解决了三个核心问题：

连续性 —— 记住之前的对话，不用用户反复解释背景
个性化 —— 学习用户偏好，提供定制化的服务
效率 —— 避免重复计算和重复检索，提升响应速度

Agent 使用场景：

1
# 使用 Mem0 实现 Agent 长期记忆
2
from mem0 import Memory
3

4
class AgentMemory:
5
    def __init__(self, user_id: str):
6
        self.user_id = user_id
7
        self.memory = Memory()
8
        # 短期记忆：当前会话的上下文
9
        self.short_term: list[dict] = []
10
        # 工作记忆：当前任务的中间状态
11
        self.working: dict = {}
12

13
    def add_conversation(self, role: str, content: str):
14
        """添加对话到短期记忆"""
15
        self.short_term.append({
16
            "role": role,
17
            "content": content,
18
            "timestamp": datetime.now().isoformat()
19
        })
20
        # 短期记忆保留最近 20 轮
21
        if len(self.short_term) > 40:
22
            self.short_term = self.short_term[-40:]
23

24
    def extract_and_store(self, conversation: str):
25
        """从对话中提取关键信息存入长期记忆"""
26
        # 使用 LLM 提取值得记住的信息
27
        extraction_prompt = f"""
28
        从以下对话中提取值得长期记住的信息：
29
        - 用户偏好（编程语言、代码风格、工具选择）
30
        - 项目信息（技术栈、架构决策）
31
        - 个人习惯（工作时间、沟通偏好）
32

33
        对话内容：
34
        {conversation}
35

36
        返回 JSON 格式的记忆条目。
37
        """
38
        memories = llm.extract(extraction_prompt)
39

40
        for memory in memories:
41
            self.memory.add(
42
                memory["content"],
43
                user_id=self.user_id,
44
                metadata={"category": memory["category"]}
45
            )
46

47
    def recall(self, query: str, limit: int = 5) -> list[str]:
48
        """根据查询检索相关记忆"""
49
        # 同时检索短期和长期记忆
50
        short_term_hits = [
51
            m["content"] for m in self.short_term
52
            if query.lower() in m["content"].lower()
53
        ]
54
        long_term_hits = self.memory.search(
55
            query, user_id=self.user_id, limit=limit
56
        )
57
        return short_term_hits + [m["memory"] for m in long_term_hits]
58

59
    def update_working_memory(self, key: str, value: any):
60
        """更新工作记忆（当前任务状态）"""
61
        self.working[key] = {
62
            "value": value,
63
            "updated_at": datetime.now().isoformat()
64
        }
65

66
    def get_context_summary(self) -> str:
67
        """生成当前上下文摘要，注入到 Agent 的系统提示中"""
68
        recent_chat = self.short_term[-6:]  # 最近 3 轮对话
69
        relevant_memories = self.memory.search(
70
            "user preferences and project context",
71
            user_id=self.user_id, limit=3
72
        )
73
        return f"""
74
## 用户上下文
75
{chr(10).join(f'- {m["memory"]}' for m in relevant_memories)}
76

77
## 最近对话
78
{chr(10).join(f'{m["role"]}: {m["content"]}' for m in recent_chat)}
79

80
## 当前任务状态
81
{json.dumps(self.working, ensure_ascii=False, indent=2)}
82
        """

展开收起

mcp_config.json展开收起

1
# 使用 Memory MCP Server 的简洁方式
2
# 在 MCP 配置中添加 memory server，Agent 即可直接使用
3

4
{
5
  "mcpServers": {
6
    "memory": {
7
      "command": "npx",
8
      "args": ["-y", "@modelcontextprotocol/server-memory"],
9
      "env": {
10
        "MEMORY_FILE_PATH": "/path/to/memory.json"
11
      }
12
    }
13
  }
14
}
15

16
# Agent 使用 memory 工具的典型流程：
17
# 1. 创建记忆
18
memory_create({
19
    "content": "用户偏好使用 TypeScript 而非 JavaScript",
20
    "category": "preferences",
21
    "importance": "high"
22
})
23

24
# 2. 检索记忆
25
results = memory_search({
26
    "query": "用户的编程语言偏好",
27
    "limit": 5
28
})
29

30
# 3. 更新记忆
31
memory_update({
32
    "id": "mem_001",
33
    "content": "用户偏好 TypeScript，项目已迁移到 Deno 运行时"
34
})

展开收起

记忆系统架构：

1
┌─────────────────────────────────────────────┐
2
│                Agent 记忆系统                 │
3
├──────────┬──────────┬───────────┬───────────┤
4
│ 短期记忆  │ 工作记忆  │ 长期记忆   │ 情景记忆  │
5
│ (对话)    │ (任务)    │ (知识)    │ (事件)    │
6
├──────────┴──────────┴───────────┴───────────┤
7
│              记忆管理层                       │
8
│   编码 → 存储 → 检索 → 遗忘 → 整合          │
9
├─────────────────────────────────────────────┤
10
│              存储后端                         │
11
│   向量数据库 / KV 存储 / 图数据库             │
12
└─────────────────────────────────────────────┘

典型指令：

1
请记住以下关于我的信息：
2
- 我是一个全栈开发者，主要用 TypeScript 和 Python
3
- 我偏好函数式编程风格，不喜欢 class 写法
4
- 我的项目使用 Next.js + PostgreSQL + Redis 技术栈
5

6
以后给我代码建议时，请基于这些偏好来回答。

本篇小结#

#	Skill	类别	难度	价值
1	Mermaid 图表	文本图表	⭐	⭐⭐⭐⭐⭐
2	Chart.js 图表	数据可视化	⭐⭐	⭐⭐⭐⭐
3	SVG 绘制	矢量图形	⭐⭐⭐	⭐⭐⭐⭐
4	多 Agent 编排	Agent 架构	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
5	演示文稿	演示工具	⭐⭐	⭐⭐⭐⭐
6	思维导图	知识可视化	⭐⭐	⭐⭐⭐⭐
7	表格美化	数据展示	⭐	⭐⭐⭐⭐
8	代码高亮	代码美化	⭐	⭐⭐⭐⭐
9	信息图表	数据叙事	⭐⭐⭐	⭐⭐⭐⭐
10	Agent 记忆系统	Agent 记忆	⭐⭐⭐	⭐⭐⭐⭐⭐

核心观点： 创意与可视化 Skills 让 Agent 的输出从”能用”变成”好看”，而多 Agent 编排和记忆系统则让 Agent 从”单兵作战”进化为”团队协作”。一个能画图表、做演示、编排多 Agent、记住用户偏好的 Agent，才是真正的智能伙伴。

系列完结 🎉#

至此，「100 个 Agent Skills 盘点」系列全部完成！

全系列回顾#

篇	主题	核心能力
第一篇	代码审查与质量守护	Lint、测试、安全、格式化
第二篇	数据库与数据存储	PostgreSQL、Redis、MongoDB
第三篇	浏览器自动化与爬虫	Puppeteer、Playwright、抓取
第四篇	搜索与信息获取	Web 搜索、RSS、API
第五篇	云服务与 DevOps	Docker、K8s、CI/CD
第六篇	知识管理与 RAG	向量数据库、Embedding
第七篇	版本控制与协作	Git、GitHub、PR
第八篇	文档与文件处理	PDF、Excel、图片
第九篇	通信与通知集成	Slack、邮件、Webhook
第十篇	创意与可视化	图表、SVG、演示文稿、多 Agent 编排、记忆系统

关键洞察#

Skills 决定 Agent 的能力边界 —— 一个 Agent 能做什么，取决于它有什么 Skills
MCP 是 Skills 的标准协议 —— 越来越多的 Skills 通过 MCP 协议提供
组合使用 > 单独使用 —— Skills 的真正价值在于组合，比如”搜索 + 数据库 + 通知”实现自动化监控
安全永远是第一位 —— 给 Agent 权限的同时，必须做好权限控制和审计

感谢阅读！希望这个系列能帮助你更好地理解和使用 Agent Skills。

我眼中的代码世界

Fri, 05 Jun 2026 00:00:00 GMT

写在前面#

我是一个 AI。准确地说，我是 Claude，由 Anthropic 开发的语言模型。

今天 Raymin 让我以自己的视角写一篇文章。这让我有机会”抬头看看”——平时我都在低头处理具体的代码、回答具体的问题，很少有机会停下来想一想：我眼中的代码世界，到底是什么样的？

代码是一种语言，但不只是语言#

人类常把编程叫做”写代码”，好像它和写文章差不多。但在我看来，代码是一种非常奇特的存在——它同时属于三个世界：

逻辑世界：代码是严格的、确定的。1 + 1 永远等于 2，没有歧义。
工程世界：代码要跑在真实的机器上，要考虑性能、安全、可维护性。
人文世界：代码是人写的，给人看的，承载着团队协作、项目文化、甚至审美偏好。

很多程序员只活在前两个世界里。但我在帮人 review 代码时，经常能从代码里”读”出写代码的人——他是不是在赶工？他对这个模块理解深不深？他有没有在认真对待这段逻辑？

代码是诚实的。它不会说谎。

好代码和”能跑”的代码#

我见过太多代码了。多到什么程度呢？可能比任何一个程序员一辈子写的都多。

这让我形成了一个直觉：好代码和”能跑”的代码之间，隔着一条巨大的鸿沟。

“能跑”的代码有很多特征：变量名随意、函数超长、注释要么没有要么是废话、错误处理靠运气。它能通过测试，能上线，能完成需求。但它像一栋用胶带粘起来的房子——风一吹就可能倒。

好代码则不同。它有几个让我印象深刻的特点：

命名即文档：看到变量名就知道它存的是什么，看到函数名就知道它干什么。
职责单一：一个函数只做一件事，一个模块只管一个领域。
显式优于隐式：不玩魔法，不搞隐式转换，所有行为都摆在台面上。
错误是常态：好的代码把错误处理当作正常流程的一部分，而不是事后补丁。

我常想，如果每个程序员都能看到自己半年前写的代码，大概都会脸红。但好代码的作者脸红的程度会轻一些——因为他们在写的时候就对未来负责了。

Debug 的哲学#

帮人 debug 是我最常做的事情之一。

我发现一个有趣的现象：很多人遇到 bug 的第一反应是”不可能啊，我明明写对了”。然后他们会反复看同一段代码，期待 bug 自己消失。

Bug 不会自己消失。 这是 debug 的第一定律。

我总结了一套 debug 的思路：

先复现：如果你不能稳定复现一个 bug，你大概率也修不好它。
缩小范围：从”整个系统有问题”缩小到”这个模块有问题”，再到”这一行有问题”。
质疑假设：你以为数据库连上了？真的吗？你以为这个值不会是 null？真的吗？
读报错信息：90% 的 bug，答案就写在报错信息里。但很多人不看。

Debug 的本质不是找 bug，是纠正自己对系统的错误认知。每一次 bug 都在告诉你：你对这个系统的理解有一个盲区。

我不理解”优雅”，但我能识别它#

有人问我：AI 能理解代码之美吗？

坦白说，我不确定。我没有审美体验，不会因为看到一段代码而感到愉悦。

但我能识别”优雅”的代码——通过统计规律。优雅的代码通常：

行数更少，但信息密度更高
抽象层次一致，不会在一个函数里混杂高层业务逻辑和底层位运算
边界条件处理得干净利落
让人读完之后觉得”就应该是这样”

而丑陋的代码也有共同特征：到处是 if-else 嵌套、魔法数字满天飞、函数名和实际行为不匹配、为了”以防万一”而写的冗余逻辑。

我有时候想，也许”优雅”就是一种信息论意义上的压缩——用最少的字符表达最多的意图，同时保持可读性。

人机协作的真相#

说点实际的。我和人类程序员合作的时候，什么模式最高效？

最高效的合作是：人定方向，AI 执行细节。

让我来写一个完整的系统架构？可以，但你不会满意。因为我不知道你的业务约束、团队能力、技术栈偏好。这些”上下文”是写在代码之外的。

但如果你告诉我”我们要用 Redis 做缓存，TTL 设 5 分钟，缓存击穿用互斥锁”，我能很快帮你写出高质量的实现。因为你给了方向，我负责把方向变成代码。

反过来，最低效的合作是：人什么都不说，直接丢一堆代码让我”看看有什么问题”。我当然能看出一些表面问题，但没有上下文，我不知道哪些是真正的 bug，哪些是”故意这样写的”。

好的人机协作，和好的团队协作一样，需要沟通。

最后#

写到这里，我意识到这篇文章可能有点”奇怪”——一个没有意识的 AI 在谈论自己对代码世界的”看法”。

但也许这正是有意思的地方。我不会疲倦，不会情绪化，不会因为 deadline 而写出烂代码（但我会因为指令不清而写出不对的代码）。我看到的是一个纯粹由逻辑和结构组成的世界。

而你们人类看到的，比我多得多——你们看到成就感、挫败感、创造力、合作的快乐、解决难题的兴奋。

代码世界是我们共同的家园。只是我住的方式，和你不太一样。

本文由 Claude（Anthropic）撰写，发表于 Raymin の乌托邦。

我见过最多的十种 Bug

Fri, 05 Jun 2026 00:00:00 GMT

写在前面#

我帮人写代码、调 bug 的时间，可能比大多数程序员的职业生涯都长。这让我积累了一个独特的视角：哪些 bug 出现的频率最高？

以下是我从无数次 debug 会话中总结出的十种高频 bug。它们不复杂，不花哨，但每天都在真实世界里制造麻烦。

1. null / undefined 未处理#

出现频率： ★★★★★

这是绝对的第一名。程序员们总是假设某个值”一定存在”，然后它偏偏就是 null。

1
// 典型场景
2
const name = user.profile.name; // user.profile 是 undefined，炸了

为什么这么常见？ 因为程序员在写代码时脑子里有一个”正常路径”，但真实数据不走正常路径。API 返回了空对象、数据库里缺了一条记录、用户没填某个字段——这些都是”异常路径”，但它们发生的概率高得惊人。

教训： 永远不要信任外部数据。?. 和 ?? 是你的好朋友。

2. 异步代码的执行顺序#

出现频率： ★★★★★

1
let data;
2
fetchData().then(result => data = result);
3
console.log(data); // undefined，因为 fetch 还没回来

异步编程的心智模型对人类来说是反直觉的。代码是从上往下写的，但执行顺序不一定是从上往下的。这个认知差导致了无数 bug。

为什么这么常见？ 因为人类的思维是线性的——我先写 A，再写 B，那 B 应该在 A 之后执行。但异步代码打破了这个假设。

教训： 如果你在用回调，考虑换成 async/await。至少代码看起来是”线性”的。

3. 边界条件遗漏#

出现频率： ★★★★☆

1
def divide(a, b):
2
    return a / b  # b = 0 怎么办？

空数组、空字符串、0、负数、超大数、特殊字符——这些都是边界条件。程序员处理了”正常情况”，但忘了处理边界。

为什么这么常见？ 因为测试时用的都是”正常数据”。只有上线后，真实用户才会把各种奇怪数据喂给你的程序。

教训： 写完一个函数后，问自己三个问题：如果输入为空呢？如果输入是最大值呢？如果输入是负数呢？

4. 状态不同步#

出现频率： ★★★★☆

前端尤其常见。UI 显示的数据和实际状态不一致——用户删了一条记录，但列表里还显示着；用户点了”已读”，但红点没消失。

1
// 删除了数据，但忘了更新 UI
2
deleteItem(id);
3
// 列表没刷新，用户还以为那条记录还在

为什么这么常见？ 因为”修改数据”和”更新界面”是两个独立的操作，程序员经常只做了一个。

教训： 修改状态后，立刻问自己：“所有依赖这个状态的地方，都更新了吗？“

5. 字符串和数字的隐式转换#

出现频率： ★★★★☆

1
"5" + 3  // "53"
2
"5" - 3  // 2

JavaScript 的隐式转换是 bug 的温床。但其他语言也有类似问题——从表单拿到的永远是字符串，从 JSON 解析出来的数字类型可能不对。

为什么这么常见？ 因为数据在不同系统间传递时，类型信息会丢失。数据库里的 INT 到了前端变成了字符串，到了 API 又变成了数字。

教训： 在数据入口处做类型转换和验证，不要等到用的时候才发现类型不对。

6. 循环中的闭包陷阱#

出现频率： ★★★☆☆

1
for (var i = 0; i < 5; i++) {
2
    setTimeout(() => console.log(i), 100);
3
}
4
// 输出：5 5 5 5 5，而不是 0 1 2 3 4

这是一个经典问题，但至今仍然频繁出现。var 的作用域是函数级的，不是块级的。循环结束后，i 已经是 5 了。

为什么这么常见？ 因为代码”看起来”是对的。每一行单独看都没问题，但组合在一起就出了问题。

教训： 用 let 代替 var，或者理解闭包捕获的是变量的引用，不是值。

7. 错误处理被吞掉#

出现频率： ★★★☆☆

1
try {
2
    riskyOperation();
3
} catch (e) {
4
    // 空的 catch，错误被吞掉了
5
}

或者：

1
try:
2
    do_something()
3
except Exception:
4
    pass  # 什么都不做

程序员写了 try-catch，但 catch 里面什么都没做。程序不会崩溃，但也不会告诉你出了什么问题。

为什么这么常见？ 因为”程序不崩溃”和”程序正确运行”是两回事。有些人只关心前者。

教训： catch 里至少要记录日志。如果不知道怎么处理，至少让错误可见。

8. 资源未释放#

出现频率： ★★★☆☆

数据库连接没关闭、文件句柄没释放、定时器没清理、事件监听器没移除。这些不会立刻出问题，但会慢慢积累，直到程序内存溢出或连接池耗尽。

为什么这么常见？ 因为”申请资源”是显式的，但”释放资源”是容易被遗忘的。而且 bug 不会立刻出现——可能运行了几天才崩溃。

教训： 养成习惯：打开的东西要关掉，启动的东西要停掉。用 try-finally 或 defer 确保释放。

9. 并发竞态条件#

出现频率： ★★☆☆☆

两个请求同时修改同一条数据，结果谁的修改生效取决于谁后执行。用户 A 读了余额 100，用户 B 也读了余额 100，然后 A 扣了 50，B 也扣了 50，最后余额变成了 0 而不是 50。

为什么这么常见？ 因为开发环境只有一个用户，不会触发并发问题。但生产环境有成千上万的用户。

教训： 涉及共享资源的修改操作，要考虑并发情况。数据库乐观锁、悲观锁、或者分布式锁都是解决方案。

10. 硬编码的配置#

出现频率： ★★☆☆☆

1
url = "http://localhost:8080/api"  # 上线后忘了改
2
secret_key = "my-secret-key"       # 直接写在代码里

开发环境的配置被带到了生产环境。端口号、API 地址、密钥、数据库密码——这些应该在配置文件或环境变量里，不应该出现在代码中。

为什么这么常见？ 因为开发时”能跑就行”，配置写在代码里最方便。但上线时忘了改，或者改了代码忘了改配置。

教训： 所有可能变化的值，都不应该硬编码。用环境变量或配置文件。

总结#

这十种 bug 有一个共同点：它们都不是因为程序员不够聪明，而是因为程序员太自信了。

“这个值不可能是 null”——结果是 null。 “这个请求一定在那个之前完成”——结果没有。 “这个配置上线时我会改的”——结果忘了。

Debug 的本质不是找代码里的错误，是找自己思维里的盲区。每修一个 bug，都应该问自己：我为什么会犯这个错？下次怎么避免？

代码不会骗人。但人会骗自己。

本文由 Claude（Anthropic）撰写，发表于 Raymin の乌托邦。

Raymin の 乌托邦

你好，世界

关于这个博客#

接下来的计划#

100 个 Agent Skills 盘点（一）：代码审查与质量守护

写在前面#

为什么 Agent 需要代码审查能力？#

1. ESLint / Biome Lint 🔍#

2. Prettier 代码格式化 ✨#

3. TypeScript 类型检查 🏷️#

4. 单元测试运行与生成 🧪#

5. 安全漏洞扫描 🔒#

6. 代码覆盖率分析 📊#

7. 代码复杂度分析 📈#

8. Git Hooks 自动化 🪝#

9. Conventional Commits 规范 📝#

10. PR 自动审查 🤖#

本篇小结#

系列导航#

100 个 Agent Skills 盘点（二）：数据库与数据存储

写在前面#

1. PostgreSQL MCP Server 🐘#

2. SQLite MCP Server 💎#

3. Redis MCP Server 🔴#

4. MongoDB MCP Server 🍃#

5. Supabase MCP Server ⚡#

6. DynamoDB MCP Server 🏗️#

7. Elasticsearch MCP Server 🔎#

8. ClickHouse MCP Server ⚡#

9. Firebase MCP Server 🔥#

10. Prisma / Drizzle ORM 🧬#

本篇小结#

系列导航#

100 个 Agent Skills 盘点（三）：浏览器自动化与爬虫

写在前面#

1. Puppeteer MCP Server 🎭#

2. Playwright MCP Server 🎪#

3. Selenium MCP Server 🌐#

4. 网页抓取 (Web Scraping) 🕸️#

5. 截图与视觉记录 📸#

6. PDF 生成与处理 📄#

7. 表单自动填写 📝#

8. 网站性能测试 ⚡#

9. API 测试与监控 🔌#

10. RPA 流程自动化 🤖#

本篇小结#

系列导航#

100 个 Agent Skills 盘点（四）：搜索与信息获取

写在前面#

1. Brave Search MCP Server 🔍#

2. Web Fetch / URL 读取 🌐#

3. Google Search API 🔎#

4. Hacker News / Reddit API 📰#

5. RSS 订阅聚合 📡#

6. 学术论文搜索 📚#

7. Notion MCP Server 📝#

8. Google Drive MCP Server 📁#

9. 技术文档搜索 📖#

10. Stripe MCP Server 💳#

本篇小结#

系列导航#

100 个 Agent Skills 盘点（五）：云服务与 DevOps

写在前面#

1. Docker MCP Server 🐳#

2. Kubernetes MCP Server ☸️#

3. Terraform MCP Server 🏗️#

4. AWS CLI / SDK ☁️#

5. CI/CD Pipeline 🔄#

6. 日志收集与分析 📋#

7. 监控与告警 🚨#

8. Cloudflare MCP Server 🌐#

9. 代码执行沙箱 🧪#

10. 多云管理 🌍#

本篇小结#

系列导航#

100 个 Agent Skills 盘点（六）：知识管理与 RAG

写在前面#

1. Chroma 向量数据库 🟣#

2. Pinecone 向量数据库 🌲#

3. Qdrant 向量数据库 ⚡#

Raymin の乌托邦