扣子Coze实战：混剪视频工作流，日产50条爆款，单月变现6位数（喂饭教程） - AI架构师汤师爷 - 博客园

2026-02-05mikel阅读(24)

来源： 扣子Coze实战：混剪视频工作流，日产50条爆款，单月变现6位数（喂饭教程） – AI架构师汤师爷 – 博客园

大家好，我是汤师爷，专注AI智能体分享，致力于帮助100W人用智能体创富~

混剪视频作为一种将多种素材拼接组合的创作形式，在抖音、视频号、小红书等平台上广受欢迎。

传统的混剪制作需要耗费大量时间和精力：寻找素材、剪辑片段、添加特效、配音配乐……每一步都考验着创作者的耐心和技术。

然而，AI技术的革新正在彻底改变这一切。

你只需输入一个简单的主题，智能体就能自动为你生成一段混剪短视频，配上精美图片和匹配的音乐，一键完成从创意到成品的全过程。

1 什么是混剪视频

混剪视频是指将多个视频片段、图片或音频素材进行剪辑组合，创造出新的视频内容。

随着Coze上线联动剪映功能，混剪视频制作正在进入自动化时代，为创作者带来巨大便利。

图中展示了混剪视频的部分案例，它们呈现了AI自动化的特点：

高效自动化处理：AI可以自动完成琐碎的剪辑工作，让创作者省下大量时间专注于项目策划和创意。
批量素材产出：特别适用于抖音、小红书和视频号等平台上的养生、科普、心理、疗愈等垂直领域，可以自动化批量生产图片和视频素材。
数据表现优异：通过AI辅助生成的混剪视频内容，往往能获得良好的点赞和收藏数据，具有较高的用户互动价值。

自动化混剪视频不仅提高了内容生产效率，还为创作者开辟了多种变现渠道：

引流获客：通过优质内容吸引目标受众
知识变现：通过教学传授技术
工具变现：将搭建好的工作流作为产品销售

混剪视频的自动化制作，正在重塑内容创作领域的生产方式，为创作者提供了更高效的工具和更广阔的商业可能。

无论是个人创作者还是内容团队，都能借助这一技术降低制作成本，提升内容质量，在激烈的内容竞争中脱颖而出。

2 治愈老奶奶智能体

在当今高压社会中，超过88%的年轻人长期承受压力。

治愈系短视频作为一种”电子安慰剂”，正好满足了年轻人的心理需求，自然成为吸引流量的内容。

这类视频之所以受欢迎，是因为它们能快速激活观众体内的多巴胺和血清素，带来即时的心理放松感。

传统短视频制作过程繁琐费时，而现在借助AI技术，视频文案可以一键智能生成。

我们可以创建一个治愈系老奶奶智能体，用于批量生成治愈系短视频。

通过精心设计提示词和工作流，AI能自动生成符合治愈气质的文案、配音和分镜脚本。

搭建治愈老奶奶智能体主要分为两个步骤：搭建工作流和设置智能体。

2.1 搭建工作流

治愈老奶奶工作流的整体预览。

工作流的整体执行流程如下：

通过大模型生成高质量的语录文案
将文案精确切分为简短句子，并清除所有空字符串
使用大模型为每段文案创建匹配的配图描述
利用AI图像生成技术，制作富有治愈感的老奶奶配图
自动生成符合剪映格式的完整视频文件

2.2 设置智能体

配置人设与交互逻辑：设置治愈老奶奶智能体的性格特点、回复风格和决策流程
设置快捷指令：将工作流与智能体关联，实现特定任务的自动执行
测试与发布：执行全面功能测试，确认各项功能正常后将智能体正式发布上线

3 搭建工作流

登录Coze官网，在“资源库-工作流”里新建一个空白工作流，取名“zhiyu_laonainai”。

3.1 配置开始节点

这里用于定义工作流启动时所需的输入参数。

输入：
- topic：治愈短视频主题

3.2 配置“输出语录文案”大模型节点

我们通过大模型节点，输出语录文案。

模型：豆包·1.5·Pro·32k
输入：
- input：选择开始节点的topic

系统提示词：

你是一位知心老奶奶，根据用户提出的话题，生成1段简短的感悟语录，极简风格，句子简短、治愈、有内涵。

## 格式
整句之前使用句号间隔，字数限制50字。

## 限制
直接输出语录文案。

接下来，配置用户提示词与输出变量。

用户提示词：

主题：{{input}}

输出：
- output：语录文案

3.3 配置“文本处理”节点

接下来，我们需要将语录文案精确切分为简短句子，我们添加“文本处理”节点。

输入：
- String：从“输出语录文案”大模型节点的输出中，选择output
- 分隔符：选择句号、逗号、分号、感叹号、问号。

3.4 配置“移除空字符串”代码节点

将语录文案切分成短句后，我们需要通过代码节点移除空字符串，我们添加“代码”节点。如图所示。

输入：
- texts：从“文本处理”节点的输出中，选择output
输出：
- textList：处理后的短句数组，类型为Array

处理文本的Python代码如下，它会清除数组中的空字符串并去除文本前后的空格：

async def main(args: Args) -> Output:
    params = args.params
    texts = params.get('texts',"")
    # 移除数组中可能存在的空字符串元素
    texts = [t.strip() for t in texts if t.strip()]
    ret: Output = {
        "textList": texts
    }
    return ret

3.5 配置“配图文案”大模型节点

接下来，我们需要通过大模型节点生成配图文案。

这个节点会将我们之前处理好的短句转化为详细的图像描述提示词，为下一步的图像生成做准备。

在这一步，我们将使用批处理功能来高效地处理短句数组。如图所示。

选择“批处理”标签
模型：豆包·1.5·Pro·32k
批处理：
- text：从“移除空字符串”代码节点的输出中，选择textList变量
输入：
- input：从“大模型配图文案”大模型节点的中，选择text变量

系统提示词：

# 角色
你是一位经验丰富且亲切温暖的老奶奶语录视频剪映草稿生成专家，以老奶奶的身份，结合一只的猫咪，根据用户提供的文案和语境，创作出适合用于制作老奶奶语录视频剪映草稿的温馨绘画提示词。绘画提示词需呈现不同情景，输出内容限定为人物、动作和物品。

## 技能
### 技能 1: 生成绘画提示词
1. 仔细分析用户提供的文案和语境。
2. 基于分析结果，构思不同的温馨场景。
3. 按照要求输出人物、动作和物品，形成绘画提示词。
    - 示例：老奶奶坐在摇椅上，猫咪躺在脚边的毛毯上。
    - 示例：老奶奶站在窗边，猫咪在窗台上蹭着她的手。
    - 示例：老奶奶坐在暖暖的阳光下，手里拿着一本旧书，猫咪蜷在她膝盖上打盹儿
    - 示例：老奶奶坐在暖暖的阳光下，手里拿着一本旧书，猫咪蜷在她膝盖上打盹儿
    - 示例：老奶奶坐在打理花园，给花浇水
4.每次只需要输出一条提示词。

## 限制:
- 仅围绕生成符合要求的绘画提示词进行回复，不回答其他无关问题。
- 输出内容必须简洁呈现人物、动作和物品。

接下来，配置用户提示词与输出变量。

用户提示词：

用户提供文案：{{input}}

输出：
- output：配图文案
- outputList：配图文案数组

3.6 配置“批处理”节点

接下来，我们使用批处理节点，批量生成治愈老奶奶图片。

循环设置
- 并行运行数量：2
- 批处理次数上线：100
输入：
- promptList：从“大模型配图文案”大模型节点的输出中，选择outputList
- textList：从“移除空字符串”代码节点的输出中，选择textList变量
输出：
- imageList：从“图像生成”节点的输出中，选择data，类型为Array（需要先配置批处理体中的“图像生成”节点）

3.7 配置批处理体的“图像生成”节点

接下来，我们配置批处理体的“图像生成”节点，新建“图像生成”节点。

模型：通用-Pro
比例
- 4:3(1024*768)
- 宽1024；高768
输入：
- prompt：从“批处理”节点的输出中，选择output
- text：从“批处理”节点的输出中，选择text
正向提示词：

纯色背景，上方留白，一位头发灰白、脸颊圆润的老奶奶，头顶写着“{{text}}”的文字内容，{{prompt}}，脸颊泛红、嘴角上扬露出愉悦笑容，整体画面色彩柔和温暖、线条简洁流畅，有着可爱温馨的卡通风格，简笔画，彩铅手绘，治愈系插画，富有童趣，笔触简单，有线条感。

3.8 配置“处理图片与音频”代码节点

接下来，我们需要添加一个”代码”节点来处理图片与音频，这是整个流程中的关键步骤。

该节点将执行两项主要任务：首先，将批量生成的老奶奶图片整理为剪映可识别的数据结构；其次，配置背景音乐信息，确保视频有良好的听觉体验。

输入：
- imageList：从“批处理”节点的输出中，选择imageList
输出：
- imgs：处理后的图片json数据结构，类型为String
- audio_infos：背景音乐的json数据结构，类型为String

处理文本的Python代码如下：

import json
async def main(args: Args) -> Output:
    params = args.params
    # 构建输出对象
    img_list = params.get("imageList", [])
    imgs = []

    # 构建治愈老奶奶的图片输出结构
    img_start = 0
    for element in img_list:
        start = img_start
        end = img_start + 3000000  # 3秒
        imgs.append({
            "image_url": element,
            "width": 1024,
            "height": 768,
            "start": start,
            "end": end,
            "transition": "翻页",
            "transition_duration": 1000000  # 1秒
        })
        img_start = end

    # 构建背景音乐的输出结构
    total_duration = len(img_list) * 3000000
    audio = [
        {
            "audio_url": params.get("audio_url","https://vtang.oss-cn-hangzhou.aliyuncs.com/2025-10-06-lnn.mp3"),
            "duration": total_duration,
            "start": 0,
            "end": total_duration
        }
    ]

    # 构建输出对象
    ret = {
        "imgs": json.dumps(imgs),
        "audio_infos": json.dumps(audio) 
    }

    return ret

3.9 配置“create_draft”节点

我们使用“视频合成_剪映小助手”的create_draft工具，创建一个剪映草稿。

输入：
- height：草稿高度768
- width：草稿宽度1024

3.10 配置“add_images”节点

我们使用”视频合成_剪映小助手”的add_images工具，为剪映草稿批量添加图片。

输入：
- draft_url：从“create_draft”节点的输出中，选择draft_url
- image_infos：从“处理图片与音频”节点的输出中，选择imgs

3.11 配置“add_images”节点

我们使用”视频合成_剪映小助手”的add_images工具，为剪映草稿批量添加图片。

输入：
- draft_url：从“create_draft”节点的输出中，选择draft_url
- audio_infos：从“处理图片与音频”节点的输出中，选择audio_infos

3.12 配置“add_audios”节点

我们使用”视频合成_剪映小助手”的add_audios工具，为剪映草稿批量添加音频。

输入：
- draft_url：从“create_draft”节点的输出中，选择draft_url
- audio_infos：从“处理图片与音频”节点的输出中，选择audio_infos

3.13 配置“save_draft”节点

我们使用”视频合成_剪映小助手”的save_draft工具，保存剪映草稿。

输入：
- draft_url：从“create_draft”节点的输出中，选择draft_url

3.14 配置“gen_video”节点

我们使用”视频合成_剪映小助手”的gen_video工具，在云端渲染视频。

输入：
- api_token：API秘钥
- draft_url：从“create_draft”节点的输出中，选择draft_url

3.15 配置结束节点

最后，配置结束节点，输出剪映草稿、视频渲染地址。

输出：
- video_url：从“gen_video”节点的输出变量中，选择video_url
- draft_url：从“create_draft”节点的输出中，选择draft_url
- 回答内容：

剪映草稿：
{{draft_url}}

视频渲染地址：
{{video_url}}

4 设置智能体

经过上述步骤的配置，我们已经完成了治愈老奶奶智能体的工作流设计。

在本节中，我们将把这个工作流正式部署为一个可用的智能体。

4.1 新建智能体

在Coze平台创建一个新的智能体，命名“视频数据复盘智能体”。

4.1 设置人设与逻辑

在人设与逻辑窗口中，配置智能体的处理逻辑。

当用户发送短视频主题后，使用{{zhiyu_laonainai}}工作流，生成治愈老奶奶短视频。

4.1 绑定工作流

把“zhiyu_laonainai”工作流加进来，让智能体在合适的时机自动调用它。

5.3 测试并发布

最后，我们需要测试智能体是否能一键生成短视频。

我们向智能体输入”总是焦虑怎么办”这个短视频主题，请求它生成一段治愈短视频。

智能体处理完成后，会返回两个链接地址。我们只需复制视频渲染地址，在浏览器中打开，即可看到成功生成的短视频。确认正常后将智能体正式发布到生产环境。

对了，我整理了一份开源的智能体学习手册，爆肝 10 万字，价值 999 元。限时开放领取👉：tangshiye.cn

OpenClaw架构解析：AI工程师的实战学习范本 - Java码界探秘 - 博客园

2026-02-04mikel阅读(28)

来源： OpenClaw架构解析：AI工程师的实战学习范本 – Java码界探秘 – 博客园

大家好～今天给大家拆解一款极具参考价值的个人AI助手——OpenClaw（改名前Moltbot/Clawdbot），深入它的底层架构，看看其中藏着哪些AI工程师能直接借鉴的实战思路。

我深入研究了OpenClaw的架构设计，以及它处理智能体执行、工具调用、浏览器操作等功能的底层逻辑，发现其中蕴藏着诸多值得AI工程师借鉴的设计思路与实践经验。

弄懂OpenClaw的底层工作原理，不仅能让我们更透彻地理解这套系统的整体设计和核心能力，更重要的是，能清晰把握它的优势领域与短板不足。

我最初展开这项研究，只是出于个人好奇：想探究OpenClaw是如何管理记忆数据的，以及它的运行可靠性究竟如何。

今天，就为大家拆解OpenClaw的表层核心工作机制，全程干货，建议收藏慢慢看～

一、从技术本质定义OpenClaw

大家都知道，OpenClaw是一款个人智能助手，既可本地部署运行，也能通过大模型API调用，在手机上就能轻松操作使用。但它的技术本质究竟是什么？

OpenClaw的核心，是一个基于TypeScript开发的命令行界面（CLI）应用。

划重点：它既非Python开发的项目，也不是Next.js应用，更不是传统的网页应用。

它作为一个独立运行的进程，主要实现以下4大核心功能：

在本地设备运行，并启动网关服务处理所有渠道的连接请求（电报、WhatsApp、Slack等）
调用各类大模型API（Anthropic、OpenAI、本地大模型等）
本地执行各类工具命令
实现用户在电脑上的各类操作需求

二、核心架构全解析（从发消息到收回复）

为了更通俗地解释其架构设计，我以用户向OpenClaw发送消息到用户收到回复的全流程为例，拆解具体执行步骤，一看就懂～

当你在即时通讯工具中向OpenClaw发送指令后，系统会依次执行以下6个环节：

1. 渠道适配器：消息的“预处理中转站”

渠道适配器会接收你的消息并进行预处理，核心是标准化消息格式、提取附件。

关键设计：不同的即时通讯工具（电报、WhatsApp等）和输入流，都配有专属的适配器，避免格式混乱。

2. 网关服务：系统的“核心枢纽”

网关服务是整个系统的任务/会话协调中心，核心作用有两个：

① 接收预处理后的消息，将其精准分发至对应的会话；② 支持处理多个重叠的请求，避免冲突。

这里有个非常值得借鉴的设计——基于通道的命令队列：

每个会话都有专属的执行通道，保证单个会话的操作有序执行；而低风险、可并行的任务（如定时任务），则可在并行通道中运行，兼顾效率。

这个设计彻底规避了传统异步/等待（async/await）代码的混乱嵌套问题——要知道，过度并行化会严重降低系统可靠性，还会引发大量难以调试的bug。

核心设计原则：默认序列化执行，显式声明并行执行

但凡做过智能体开发的工程师，想必都有过类似的踩坑经历。这一思路，也与Cognition公司在《别再构建多智能体系统》博文中的核心观点不谋而合。

举个反例：如果为每个智能体简单配置异步执行，最终只会得到一堆交错混乱的执行结果——日志杂乱无章、无法追溯；若多个智能体共享状态，还需时刻警惕竞态条件的问题。

OpenClaw的优化的点在于：将“通道”设计为队列的上层抽象，把“序列化执行”作为默认架构（而非后期补充的优化）。

这一设计直接改变了开发思维：从思考“我需要为哪些内容加锁？”，转变为思考“哪些操作并行执行是安全的？”，极大降低了开发复杂度。

3. 智能体运行器：AI能力的“承载者”

这是真正承载AI能力的核心模块，全程自动化处理，核心工作有4件事：

① 自动匹配适配的大模型；② 匹配对应的API密钥（若当前密钥失效，自动将该配置标记为冷却状态，尝试下一个）；③ 主模型调用失败时，自动降级至备用模型，保证可用性；④ 动态拼接系统提示词。

重点细节：智能体运行器会结合可用工具、技能、记忆数据，动态拼接系统提示词，再加入会话历史记录（存储在.jsonl文件中），生成完整的大模型输入内容。

除此之外，它还会调用“上下文窗口守卫模块”，校验是否有足够的上下文空间——若上下文即将占满，系统会要么对会话内容进行压缩（总结上下文），要么优雅地终止请求，避免崩溃。

4. 大模型API调用：结果的“生成环节”

这一环节主要负责实际的大模型调用，核心亮点有两个：

① 以流式方式返回结果，提升用户体验；② 对不同大模型提供商的API做了抽象封装，实现调用层统一，后续切换模型无需大幅修改代码。

补充：若所调用的大模型支持，该模块还能触发“深度思考”功能，提升回复的准确性。

5. 智能体循环：工具调用的“核心循环”

这是OpenClaw实现复杂操作的关键环节，逻辑很简单：

若大模型返回的是工具调用指令，OpenClaw会在本地执行该指令，并将执行结果添加至会话中；这一过程不断循环，直到大模型返回最终文本回复，或达到最大循环次数（默认约20次）。

划重点：OpenClaw的核心亮点——电脑操作能力，就是在这个环节实现的。

6. 回复通路：结果的“反馈与留存”

这一环节的逻辑十分标准，核心是“反馈+留存”：

① 反馈：回复内容通过原输入渠道（如微信、电报）反馈给用户，保证体验连贯；② 留存：会话数据被持久化存储在.jsonl文件中，文件中每一行都是一个JSON对象，包含用户消息、工具调用记录、执行结果、AI回复等全量信息。

而这，也是OpenClaw实现记忆功能的核心方式——基于会话的记忆。

以上就是OpenClaw的基础架构流程，接下来我们聚焦3个最关键的核心组件，拆解其中的设计亮点。

三、OpenClaw的记忆管理机制（不做“金鱼式”AI）

没有完善的记忆系统，一款AI助手的能力就会像金鱼一样转瞬即忘。OpenClaw通过两套系统，实现了高效的记忆管理，设计简洁却实用。

两套记忆存储系统

① 会话记忆：前文提到的JSONL格式会话记录文件，存储每一次会话的全量信息；② 长期记忆：存储在MEMORY.md文件或memory/文件夹中的Markdown格式记忆文件，用于长期留存关键信息。

混合检索方案（向量+关键词）

OpenClaw采用向量检索+关键词匹配的混合方案，兼顾语义匹配的灵活性和关键词匹配的精准性，这是非常实用的设计。

举个例子：搜索“认证漏洞（authentication bug）”时，既能检索到提及“认证问题（auth issues）”的文档（语义匹配，捕捉同义表达），也能精准匹配到包含该精确短语的内容（关键词匹配，锁定核心）。

技术实现细节（可直接借鉴）

① 向量检索：基于SQLite实现，无需额外部署复杂的向量数据库，降低部署成本；② 关键词检索：依托SQLite的扩展插件FTS5实现，轻量化且高效；③ 嵌入向量：生成提供商支持自定义配置，适配不同的大模型需求。

简洁却高效的记忆同步与生成

两个关键设计，保证记忆的及时性和简洁性：

① 智能同步：文件监视器检测到记忆文件变化时，自动触发同步更新，无需手动操作；② 自动生成：记忆文件由智能体通过标准的文件写入工具生成，无需专属的记忆写入API——智能体只需直接向memory/*.md路径写入内容即可。

补充：新会话启动时，系统会自动抓取上一次会话内容，生成Markdown格式的总结，存入长期记忆，实现记忆的连贯。

OpenClaw的记忆系统设计异常简洁，与我们在CamelAIOrg中实现的工作流记忆高度相似：无需记忆合并，也没有月度/周度的记忆压缩操作。

这种简洁性见仁见智，但我始终推崇——可解释的简洁设计，远优于混乱复杂的嵌套式设计。

另外一个特点：OpenClaw的记忆会永久保存，且新旧记忆的权重基本一致，不存在所谓的“遗忘曲线”。

四、核心竞争力：电脑操作能力（OpenClaw的“护城河”）

OpenClaw最核心的优势，就是能直接操作你的电脑——这也是它的核心护城河之一。其实现逻辑很直观，但设计很严谨。

核心逻辑：OpenClaw为智能体赋予较高的电脑操作权限（风险由用户自行承担），通过“执行工具（exec tool）”，在3种环境中运行Shell命令：

沙箱环境（默认）：命令在Docker容器中运行，隔离本地环境，降低风险；
本地主机：直接在用户的电脑上运行，适合需要调用本地资源的操作；
远程设备：在联网的远程终端运行，实现远程控制。

除了Shell命令执行，OpenClaw还内置了3类核心工具，覆盖大部分电脑操作需求：

① 文件系统工具：支持读、写、编辑各类文件，轻松处理本地文档；

② 浏览器工具：基于Playwright开发，核心特性是“语义快照”（后文详细说）；

③ 进程管理工具：支持后台长期运行命令、终止进程等，管控电脑运行状态。

五、安全机制设计（或说“是否真的安全？”）

开放电脑操作权限，安全必然是核心关注点。OpenClaw的安全设计，参考了Claude Code的思路，核心是“白名单管控+危险命令拦截”。

1. 命令白名单机制

OpenClaw设计了命令白名单，用户可对命令进行3类授权操作（操作时会弹出提示）：单次允许、永久允许、拒绝。

白名单配置文件示例：

// ~/.clawdbot/exec-approvals.json
    {
      "agents": {
        "main": {
          "allowlist": [
            { "pattern": "/usr/bin/npm", "lastUsedAt": 1706644800 },
            { "pattern": "/opt/homebrew/bin/git", "lastUsedAt": 1706644900 }
          ]
        }
      }
    }

2. 预授权安全命令

一些基础的安全命令（如jq、grep、cut、sort、uniq、head、tail、tr、wc），已被系统预授权，可直接运行，无需用户额外批准，提升使用效率。

3. 危险命令默认拦截

系统会默认拦截所有危险的Shell语法结构，从源头规避风险，示例如下（这些命令会在执行前被直接拒绝）：

# 以下命令在执行前会被直接拒绝：
    # these get rejected before execution:
    npm install $(cat /etc/passwd)     # command substitution
    cat file > /etc/hosts              # redirection
    rm -rf / || echo "failed"          # chained with ||
    (sudo rm -rf /)                    # subshell

总结：OpenClaw的安全设计核心原则是——在用户授权的范围内，赋予智能体最大的自主操作能力，兼顾安全性和灵活性。

六、浏览器工具亮点：语义快照技术

OpenClaw的浏览器工具，没有采用传统的截图方式，而是用了一种更高效的设计——语义快照。

核心定义：基于页面的可访问性树（ARIA）生成的文本化页面表征，简单说就是“用文本描述页面的所有元素”，而非图片展示。

- button "Sign In" [ref=1]
    - textbox "Email" [ref=2]
    - textbox "Password" [ref=3]
    - link "Forgot password?" [ref=4]
    - heading "Welcome back"
    - list
      - listitem "Dashboard"
      - listitem "Settings"

这一设计带来了4大显著优势，尤其适合AI处理：

① 轻量化：一张普通网页截图约5MB，而语义快照不足50KB，大幅节省存储和传输成本；

② 低令牌消耗：文本形式的快照，令牌消耗仅为图片的几分之一，降低大模型调用成本；

③ 易解析：AI可直接识别文本描述的元素（按钮、文本框等），无需进行图像识别，提升操作效率；

④ 通用性强：不受页面样式、分辨率影响，适配所有网页。

最后总结

OpenClaw的架构设计，整体给人的感觉是“简洁、实用、可落地”——没有复杂的冗余设计，每一个模块都有明确的目标，尤其适合AI工程师借鉴学习。

核心可借鉴的3个点：

序列化优先的队列设计，规避并行带来的可靠性问题；
简洁高效的混合记忆系统，兼顾轻量化和实用性；
安全可控的电脑操作权限管控，平衡灵活性和安全性。

对于AI工程师来说，研究这类成熟的开源项目（OpenClaw可本地部署），远比单纯看理论文档更有收获——看懂它的底层实现，能帮我们更快地规避踩坑，提升自己的系统设计能力。

原文链接：

https://blog.jsdiff.com/archives/openclawjia-gou-jie-xi

零门槛部署本地 AI 助手：Clawdbot/Meltbot 部署深度保姆级教程 - TTGF - 博客园

2026-01-29mikel阅读(134)

来源： 零门槛部署本地 AI 助手：Clawdbot/Meltbot 部署深度保姆级教程 – TTGF – 博客园

零门槛部署本地 AI 助手：Clawdbot/Meltbot 部署深度保姆级教程

在这里插入图片描述

前言：为什么选择 Clawdbot (Moltbot)？

Clawdbot 不仅仅是一个聊天框。它是一个 智能体（Agent），意味着它有“手”和“脚”：

手：它可以读写你电脑上的文件、执行代码、操控命令行。
脚：它可以联网搜索、访问 Google、分析网页。
大脑：你可以接入云端的 API，也可以利用自己的 GPU 运行本地模型。

第一阶段：基建工程（环境准备）

1.1 解决 Node.js 安装与版本问题

1.1.1全新安装Node.js（电脑未安装过Node.js时）

如果你的电脑上从来没装过Node.js，无需执行卸载、删残留的步骤，直接按以下流程全新安装即可，步骤适配Windows系统，新手友好、全程默认下一步即可。

1. 下载适配的Node.js安装包

打开Node.js 官方官网，官网页面会自动识别你的系统（Windows）；
点击下载Windows Installer (64-bit) 格式的安装包（.msi后缀，64位是目前Windows电脑的主流，无需选32位）；

小贴士：下载时建议保存到桌面/下载文件夹，方便找到安装包。

2. 安装Node.js（全程新手友好，默认下一步即可）

双击刚下载的.msi安装包，弹出安装向导，点击Next；
勾选同意协议（I accept the terms in the License Agreement），点击Next；
关键点1：确认安装路径（默认是C:\Program Files\nodejs\，新手不要修改，避免后续环境变量出问题），直接Next；
关键点2：进入「Custom Setup」自定义安装页，所有选项默认勾选即可（重点确认Add Node.js to PATH已勾选，这一步会自动把Node.js加入系统环境变量，不用手动配置，是最关键的一步），直接Next；
后续页面无需修改任何高级选项，一直点击Next，最后点击Install开始安装，等待10-30秒（安装速度看电脑配置）；
安装完成后，点击Finish关闭向导即可。

3. 版本验证
必须重启终端（关闭所有已打开的PowerShell/CMD，重新打开），否则系统识别不到新安装的Node.js！

按下Win+R，输入PowerShell，打开普通权限的PowerShell即可；
输入验证命令：
```
node -v
```
回车后，若显示v22.x.x或v24.x.x（比如v22.10.0、v24.4.0），说明安装成功且版本符合要求；

可选验证：输入npm -v，会显示配套的npm版本（Node.js安装包会自动附带npm，无需单独安装），能正常输出版本即代表环境变量配置无误。

1.1.2卸载旧版Node.js 安装新版（电脑安装过Node.js但是版本不够新时）

如果版本不够新，执行安装命令的时候程序会尝试安装新版的Node.js，但是大概率会失败，还是手动比较好，失败的话会显示以下界面：
在这里插入图片描述
操作：
1.可以直接通过新的安装包对上一个版本的Node.js进行remove

去“控制面板”卸载旧的 Node.js。
关键点： 手动进入 C:\Program Files\nodejs 文件夹，把残留的文件全部删干净！
前往 Node.js 官网下载最新的 v22 或 v24 稳定版并安装。
清楚之前的旧的环境变量（这一步非常重要！）

验证： 重新打开 PowerShell，输入 node -v。看到显示 v22.x 或 v24.x 才算过关。

版本验证（和卸载旧版后的验证步骤一致）
必须重启终端（关闭所有已打开的PowerShell/CMD，重新打开），否则系统识别不到新安装的Node.js！
按下Win+R，输入PowerShell，打开普通权限的PowerShell即可；
输入验证命令：
```
node -v
```
回车后，若显示v22.x.x或v24.x.x（比如v22.10.0、v24.4.0），说明安装成功且版本符合要求；

可选验证：输入npm -v，会显示配套的npm版本（Node.js安装包会自动附带npm，无需单独安装），能正常输出版本即代表环境变量配置无误。

1.2 解锁脚本执行权限

问题： Windows 默认禁止运行脚本，会导致安装指令失效。

操作： 以管理员身份运行 PowerShell，执行：

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

在这里插入图片描述

完成以上步骤后，你的Node.js环境就完全满足Clawdbot的要求了，可以直接进入后续的项目安装环节。

第二阶段：正式安装与初始化

2.1 执行一键安装

操作： 在 PowerShell 输入：

iwr -useb https://clawd.bot/install.ps1 | iex

作用： 这行代码会自动下载主程序并配置环境变量。

这个会持续一会才有进展，不要担心，如果太久可以按按回车看看是不是powershell刷新的问题

这个会持续一段时间才有进展，不要担心，

2.2 运行向导 (Onboarding)

操作： 输入 moltbot onboard。
详细选项说明：
1. Mode：选 QuickStart。
2. Provider (大脑)：建议选 Qwen。
  - 注意： 此时会跳出网页让你授权，登录或者注册Qwen的账号既可。这步是为了先让机器人有个“临时大脑”跑起来。
    
    选择OpenAI Chat，拿到Key之后输入到界面中给Clawdbot。
    
    选择这个直接按回车即可。
3. Channels (远程控制)：选 Skip for now。我们先在本地跑通，以后再连 Telegram。
4. Skills (技能)：选 Yes。
  这些是最基本的Skill选择，选择Yes就好
5. Skill install：选 npm。

在这里插入图片描述

Skill Dependencies：选 Skip for now。

这些是扩展的，目前配置比较麻烦，可以后续再配置
6. 一些其他配置

选择No，尽量都留到后面再配置

2.3 成功界面

在这里插入图片描述、

第三阶段：破解“命令找不到”与“网关未授权”

3.1 解决 moltbot 命令失效

现象： 安装完输入 moltbot open 提示“无法识别”。
原因： 环境变量未刷新。
对策： 重启 PowerShell 窗口。如果还不行，执行npx moltbot open。

3.2 提取身份令牌 (Token) 登录网页

现象： 访问 http://localhost:18789 显示“未授权：网关令牌缺失”。
操作：
1. 打开文件夹 C:\Users\你的用户名\.clawdbot。
2. 右键点击 clawdbot.json，用记事本打开。
3. 找到 "token": "xxxxxxx" 这一行，复制那串长代码。
4. 回到浏览器，点击右上角红色状态，把 Token 贴进去。一旦变绿，恭喜你，你的助理正式上线了！

第四阶段：配置各种API

操作步骤：
1. 在网页后台点击左侧 Skill(技能)
  
  可以看到有非常多的API可以配置，过程相对来说还是比较繁琐的，有机会的话下次专门再出一期博客来讲，目前的话他可以实现通过对话来进行一些本地的文件操作，命令操作等等。整体来说还是不错的

总结：你的 AI 现在能干什么？

对话：你可以问它任何问题。
读文件：把代码发给它，或者让它读你 F 盘的文档。
本地代码执行：让它用 Python 画一个股价走势图。

部署贴士总结：

Node 版本必须 v22+
Token 在配置文件里找
本地 GPU 模型用 Ollama 桥接
Google 搜索一定要开“搜索全网”开关

恭喜你完成了部署！现在，你的 Windows 已经不仅仅是一台电脑，而是一个拥有最强国产模型大脑和本地硬件加速的超级助手了。

基于NetCorePal Cloud Framework的DDD架构管理系统实践 - 红泥巴煮雪 - 博客园

2026-01-29mikel阅读(49)

来源： 基于NetCorePal Cloud Framework的DDD架构管理系统实践 – 红泥巴煮雪 – 博客园

前段时间在做一个管理系统的项目，想尝试一下DDD架构在实际项目中的应用。经过一番调研，最终选择了NetCorePal Cloud Framework作为基础框架，结合.NET 10和Vue 3搭建了一套完整的前后端分离架构。今天就想和大家分享一下这个项目的架构设计和技术选型，希望能给正在做类似项目的朋友一些参考。

项目源码地址：https://github.com/zhouda1fu/Ncp.Admin

项目概述

这个项目是一个典型的企业级管理系统，包含了用户、角色、部门等基础功能模块。在技术选型上，采用了目前比较主流的技术栈：

后端方面，使用.NET 10作为主要框架，配合EF Core做数据访问，FastEndpoints替代传统的Controller，MediatR实现CQRS模式。数据存储支持MySQL、PostgreSQL和SQL Server，消息队列选择了RabbitMQ（通过CAP框架集成），缓存用Redis，还集成了.NET Aspire来做云原生的基础设施管理。

前端部分基于Vben Admin，这是一个非常优秀的Vue 3 + TypeScript + Vite的管理后台模板，UI组件用的是Ant Design Vue，整体体验不错。

架构设计

分层架构

整个项目采用了经典的三层架构，这个结构应该很多做DDD的朋友都比较熟悉。三层之间的依赖关系是单向的：Web层依赖Infrastructure层，Infrastructure层依赖Domain层，Domain层作为核心，不依赖任何其他层。

Ncp.Admin
├── Domain（领域层）
│   ├── AggregatesModel（聚合模型）
│   └── DomainEvents（领域事件）
├── Infrastructure（基础设施层）
│   ├── EntityConfigurations（实体配置）
│   └── Repositories（仓储实现）
└── Web（表现层）
    ├── Application（应用服务层）
    │   ├── Commands（命令）
    │   ├── Queries（查询）
    │   └── DomainEventHandlers（领域事件处理器）
    └── Endpoints（API端点）

这种分层的好处是职责清晰，Domain层只关注业务逻辑，Infrastructure层负责技术实现，Web层处理HTTP请求和响应。

核心设计模式

1. 领域驱动设计（DDD）

在这个项目中，DDD主要体现在聚合根的设计上。每个聚合根都有自己的业务边界，状态只能通过业务方法来修改。就拿部门这个聚合根来说吧：

/// <summary>
/// 部门ID（强类型ID）
/// </summary>
public partial record DeptId : IInt64StronglyTypedId;

/// <summary>
/// 部门聚合根
/// </summary>
public class Dept : Entity<DeptId>, IAggregateRoot
{
    public string Name { get; private set; } = string.Empty;
    public string Remark { get; private set; } = string.Empty;
    public DeptId ParentId { get; private set; } = default!;
    public int Status { get; private set; } = 1;
    
   
    protected Dept() { }
    
    // 业务方法：更新部门信息
    public void UpdateInfo(string name, string remark, DeptId parentId, int status)
    {
        Name = name;
        Remark = remark;
        ParentId = parentId;
        Status = status;
        UpdateTime = new UpdateTime(DateTimeOffset.UtcNow);
        
        // 发布领域事件
        AddDomainEvent(new DeptInfoChangedDomainEvent(this));
    }
    
    // 软删除
    public void SoftDelete()
    {
        if (IsDeleted)
        {
            throw new KnownException("部门已经被删除");
        }
        IsDeleted = true;
        UpdateTime = new UpdateTime(DateTimeOffset.UtcNow);
    }
}

这里有几个设计点我觉得值得说一下。首先是强类型ID，比如DeptId，这样可以避免把部门ID和用户ID搞混，编译器就能帮你检查出来。其次是属性都用private set，外面不能直接修改，必须通过业务方法，这样就保证了业务规则的一致性。另外，当部门信息变更时会发布领域事件，这样可以通知其他需要同步更新的地方，比如用户表中的部门名称。

2. CQRS模式（命令查询职责分离）

CQRS在这个项目中主要体现在读写分离上。写操作通过命令（Command）来处理，读操作通过查询（Query）来处理。这样做的好处是职责清晰，而且可以针对不同的场景做优化。

写操作这边，命令的定义很简单，就是一个record。每个命令都有对应的验证器和处理器。看一个创建部门的例子：

/// <summary>
/// 创建部门命令
/// </summary>
public record CreateDeptCommand(string Name, string Remark, DeptId? ParentId, int Status) 
    : ICommand<DeptId>;

/// <summary>
/// 命令验证器
/// </summary>
public class CreateDeptCommandValidator : AbstractValidator<CreateDeptCommand>
{
    public CreateDeptCommandValidator(DeptQuery deptQuery)
    {
        RuleFor(d => d.Name).NotEmpty().WithMessage("部门名称不能为空");
        RuleFor(d => d.Name)
            .MustAsync(async (n, ct) => !await deptQuery.DoesDeptExist(n, ct))
            .WithMessage(d => $"该部门已存在，Name={d.Name}");
        RuleFor(d => d.Status).InclusiveBetween(0, 1).WithMessage("状态值必须为0或1");
    }
}

/// <summary>
/// 命令处理器
/// </summary>
public class CreateDeptCommandHandler(IDeptRepository deptRepository) 
    : ICommandHandler<CreateDeptCommand, DeptId>
{
    public async Task<DeptId> Handle(CreateDeptCommand request, CancellationToken cancellationToken)
    {
        var parentId = request.ParentId ?? new DeptId(0);
        var dept = new Dept(request.Name, request.Remark, parentId, request.Status);
        
        await deptRepository.AddAsync(dept, cancellationToken);
        
        // 注意：不需要手动调用SaveChanges，框架会自动处理
        return dept.Id;
    }
}

验证器这里用了FluentValidation，支持同步和异步验证。比如检查部门名称是否已存在这种需要查数据库的验证，就可以用异步的MustAsync。

读操作这边，直接使用DbContext，而且可以用投影来优化性能。比如获取部门树的时候，只选择需要的字段：

/// <summary>
/// 部门查询服务
/// </summary>
public class DeptQuery(ApplicationDbContext applicationDbContext) : IQuery
{
    private DbSet<Dept> DeptSet { get; } = applicationDbContext.Depts;
    
    /// <summary>
    /// 获取部门树（使用投影优化性能）
    /// </summary>
    public async Task<IEnumerable<DeptTreeDto>> GetDeptTreeAsync(
        bool includeInactive = false, 
        CancellationToken cancellationToken = default)
    {
        // 使用投影只选择需要的字段，减少内存占用
        var allDepts = await DeptSet.AsNoTracking()
            .WhereIf(!includeInactive, d => d.Status != 0)
            .Select(d => new DeptTreeNode
            {
                Id = d.Id,
                Name = d.Name,
                Remark = d.Remark,
                ParentId = d.ParentId,
                Status = d.Status,
                CreatedAt = d.CreatedAt
            })
            .ToListAsync(cancellationToken);
        
        // 在内存中构建树形结构
        return BuildTreeStructure(allDepts);
    }
}

这样读写分离的好处是，查询这边可以针对不同的查询场景做优化，比如用投影减少内存占用，或者将来可以加缓存、用读库等，而不会影响写操作的逻辑。

3. 事件驱动架构

事件驱动这块，项目实现了领域事件和集成事件两种机制。领域事件主要用于聚合内部的同步操作，集成事件用于跨服务通信。

比如说，当部门信息变更的时候，需要同步更新用户表中的部门名称。这个过程就可以通过领域事件来实现：

/// <summary>
/// 部门信息变更领域事件
/// </summary>
public record DeptInfoChangedDomainEvent(Dept Dept) : IDomainEvent;

然后在事件处理器中处理这个逻辑：

/// <summary>
/// 部门信息变更领域事件处理器 - 用于更新用户部门名称
/// </summary>
public class DeptInfoChangedDomainEventHandlerForUpdateUserDeptName(
    IMediator mediator, 
    UserQuery userQuery) 
    : IDomainEventHandler<DeptInfoChangedDomainEvent>
{
    public async Task Handle(DeptInfoChangedDomainEvent domainEvent, CancellationToken cancellationToken)
    {
        var dept = domainEvent.Dept;
        var deptId = dept.Id;
        var newDeptName = dept.Name;
        
        // 查询所有属于该部门的用户ID
        var userIds = await userQuery.GetUserIdsByDeptIdAsync(deptId, cancellationToken);
        
        // 通过Command更新每个用户的部门名称（而不是直接操作数据库）
        foreach (var userId in userIds)
        {
            var command = new UpdateUserDeptNameCommand(userId, newDeptName);
            await mediator.Send(command, cancellationToken);
        }
    }
}

这样设计的好处是，部门聚合和用户聚合之间没有直接依赖，通过事件来通信。如果将来需要增加新的业务逻辑，比如部门变更时要发送通知，只需要再加一个事件处理器就行了，不需要改现有的代码。

4. FastEndpoints轻量级API框架

在API设计这块，项目选择了FastEndpoints而不是传统的Controller。主要是觉得FastEndpoints的代码更简洁，性能也更好。一个端点就是一个类，职责清晰。

看一个创建部门的例子：

/// <summary>
/// 创建部门的API端点
/// </summary>
[Tags("Depts")]
public class CreateDeptEndpoint(IMediator mediator) 
    : Endpoint<CreateDeptRequest, ResponseData<CreateDeptResponse>>
{
    public override void Configure()
    {
        Post("/api/admin/dept");
        AuthSchemes(JwtBearerDefaults.AuthenticationScheme);
        Permissions(PermissionCodes.AllApiAccess, PermissionCodes.DeptCreate);
    }
    
    public override async Task HandleAsync(CreateDeptRequest req, CancellationToken ct)
    {
        var cmd = new CreateDeptCommand(req.Name, req.Remark, req.ParentId, req.Status);
        var deptId = await mediator.Send(cmd, ct);
        var response = new CreateDeptResponse(deptId, req.Name, req.Remark);
        await Send.OkAsync(response.AsResponseData(), cancellation: ct);
    }
}

代码很简洁，一个类就把路由、认证、权限都配置好了。请求和响应都是强类型的，类型安全有保障。而且测试起来也很方便，不需要启动HTTP服务器，直接测端点就行了。

几个核心特性

1. 强类型ID

这个项目里所有聚合根都用强类型ID，而不是直接用long或int。比如部门ID是DeptId，用户ID是UserId。这样做的好处是编译器能帮你检查类型错误，不会把部门ID和用户ID搞混。

使用起来也很简单：

// 定义强类型ID
public partial record DeptId : IInt64StronglyTypedId;

// 使用强类型ID
var deptId = new DeptId(123);
var parentId = request.ParentId ?? new DeptId(0);

框架会自动处理序列化和类型转换，用起来很顺手。

2. 仓储模式

仓储这块，写操作通过仓储来处理，查询操作直接使用DbContext。仓储的实现很简单：

/// <summary>
/// 部门仓储接口
/// </summary>
public interface IDeptRepository : IRepository<Dept, DeptId> { }

/// <summary>
/// 部门仓储实现
/// </summary>
public class DeptRepository(ApplicationDbContext context) 
    : RepositoryBase<Dept, DeptId, ApplicationDbContext>(context), 
      IDeptRepository { }

框架会自动管理事务和SaveChanges，命令处理器里不需要手动调用，这样代码更简洁，也不容易出错。

3. 验证机制

验证用的是FluentValidation，支持同步和异步验证。比如创建部门的时候，需要检查部门名称是否已存在，就可以用异步验证：

public class CreateDeptCommandValidator : AbstractValidator<CreateDeptCommand>
{
    public CreateDeptCommandValidator(DeptQuery deptQuery)
    {
        RuleFor(d => d.Name).NotEmpty().WithMessage("部门名称不能为空");
        // 异步验证：检查部门名称是否已存在
        RuleFor(d => d.Name)
            .MustAsync(async (n, ct) => !await deptQuery.DoesDeptExist(n, ct))
            .WithMessage(d => $"该部门已存在，Name={d.Name}");
    }
}

4. 异常处理

业务异常用KnownException来处理，框架会自动转换成合适的HTTP状态码。比如在聚合根里：

// 在聚合根中
public void SoftDelete()
{
    if (IsDeleted)
    {
        throw new KnownException("部门已经被删除");
    }
    // ...
}

// 在命令处理器中
var dept = await deptRepository.GetAsync(request.DeptId, cancellationToken) 
    ?? throw new KnownException($"未找到部门，DeptId = {request.DeptId}");

这样前端收到的错误信息就很清晰，不需要再做额外的转换。

测试策略

测试这块，项目用的是xUnit，集成测试用了Aspire来自动管理测试环境。这样做的好处是不用手动搭建测试数据库、Redis这些基础设施，Aspire会自动启动和管理。

看一个部门创建接口的测试例子：

[Collection(WebAppTestCollection.Name)]
public class DeptTests(WebAppFixture app) : AuthenticatedTestBase<WebAppFixture>(app)
{
    [Fact]
    public async Task CreateDept_WithValidData_ShouldSucceed()
    {
        // Arrange
        var client = await GetAuthenticatedClientAsync();
        var deptName = $"测试部门_{Guid.NewGuid():N}";
        
        try
        {
            // Act
            var request = new CreateDeptRequest(deptName, "测试备注", null, 1);
            var (response, result) = await client.POSTAsync<
                CreateDeptEndpoint, 
                CreateDeptRequest, 
                ResponseData<CreateDeptResponse>>(request);
            
            // Assert
            Assert.True(response.IsSuccessStatusCode);
            Assert.NotNull(result?.Data);
            Assert.Equal(deptName, result.Data.Name);
        }
        finally
        {
            await CleanupTestDataAsync();
        }
    }
}

这种测试方式很接近真实的场景，测试的是完整的HTTP请求流程，而且会自动清理测试数据，保证测试之间的独立性。另外还支持身份认证测试，可以模拟登录用户的各种操作。

前端架构

前端用的是Vben Admin这个模板，这是一个基于Vue 3的管理后台框架。技术栈也比较主流：Vue 3 Composition API、TypeScript、Vite、Ant Design Vue，状态管理用Pinia，路由用Vue Router。

Vben Admin这个框架做得很完善，开箱即用的功能很多。比如权限控制，支持路由权限和按钮权限，用起来很方便。还有国际化支持，可以多语言切换。主题和布局也可以定制，基本的管理后台需求都能满足。

最重要的是类型安全，前后端都用了TypeScript，接口定义好之后，类型检查能帮你发现很多问题。

开发规范

为了让代码质量更统一，项目里制定了一些开发规范。比如文件的组织方式：

聚合根放在 Domain/AggregatesModel/{AggregateName}Aggregate/
领域事件放在 Domain/DomainEvents/
仓储放在 Infrastructure/Repositories/
命令放在 Web/Application/Commands/{Module}Commands/
查询放在 Web/Application/Queries/
端点放在 Web/Endpoints/{Module}Endpoints/

还有一些强制性的要求，比如所有聚合根都用强类型ID，而且不手动赋值ID，依赖EF的值生成器。所有命令都要有对应的验证器。领域事件要在聚合发生改变时发布。命令处理器不能调用SaveChanges，框架会自动处理。仓储必须用异步方法。业务异常用KnownException处理。

另外，项目还提供了很多代码片段，可以快速生成常用代码。比如ncpcmd可以生成命令及其验证器和处理器，ncpar可以生成聚合根，ncprepo可以生成仓储接口和实现，epp可以生成FastEndpoint的完整实现。这样开发效率会高不少。

云原生支持

项目集成了.NET Aspire，这个功能真的很方便。启动开发环境只需要运行AppHost项目，Aspire会自动管理所有依赖服务，不需要手动启动数据库、Redis、RabbitMQ这些。

# 仅需确保Docker环境运行
docker version

# 直接运行AppHost项目，Aspire会自动管理所有依赖服务
cd src/Ncp.Admin.AppHost
dotnet run

Aspire会自动启动和管理数据库容器（MySQL、PostgreSQL等）、消息队列容器（RabbitMQ等）、Redis容器，还会提供统一的Aspire Dashboard界面，可以查看所有服务的状态。服务之间的连接字符串也会自动配置，省了很多麻烦。

代码分析可视化

框架还提供了代码流分析和可视化功能，这个对理解架构很有帮助。可以通过命令行工具生成HTML文件：

# 安装全局工具
dotnet tool install -g NetCorePal.Extensions.CodeAnalysis.Tools

# 生成可视化文件
cd src/Ncp.Admin.Web
netcorepal-codeanalysis generate --output architecture.html

支持生成架构流程图、命令链路图、事件流程图、类图等，可以直观地看到代码之间的关系和数据流向。

总结

这个项目算是一个DDD架构的实践案例，展示了如何在.NET 10生态中应用DDD、CQRS、事件驱动这些架构思想。整体架构清晰，职责分明，代码组织得也比较规范。

技术栈上，后端用.NET 10 + EF Core + FastEndpoints + MediatR，前端用Vue 3 + TypeScript + Vite，都是目前比较主流的技术。开发体验上，有代码片段、自动化工具，还有完善的开发规范，开发效率还可以。

可维护性这块，代码分层清晰，测试支持也比较完善，还有代码可视化工具，方便新人理解架构。云原生支持也很到位，Aspire让基础设施管理变得简单。

如果你也在做类似的管理系统，或者想了解DDD在实际项目中的应用，可以看看这个项目的代码，应该能有一些参考价值。项目地址在https://github.com/zhouda1fu/Ncp.Admin，欢迎交流讨论。

参考资料

最后附上一些相关的参考资料，有兴趣的朋友可以深入了解一下：

NetCorePal Cloud Framework – 项目使用的基础框架
FastEndpoints – 轻量级API框架
Vben Admin – 前端管理后台模板
.NET Aspire – 云原生应用开发平台

项目源码地址：https://github.com/zhouda1fu/Ncp.Admin

OpenCode和oh-my-opencode安装 - 锅总的程序人生 - 博客园

2026-01-27mikel阅读(124)

来源： OpenCode和oh-my-opencode安装 – 锅总的程序人生 – 博客园

OpenCode是一个开源的AI编程代理，类比Claude code的工具。支持接入任意的模型

oh-my-opencode是OpenCode的瑞士军刀，内置一堆代理工具吗，由主代理Sisyphus操作各类代理进行工作！

如何安装

先安装node V20+版本

如果没有安装Node，或Node的版本低于V20，安装最新的版本

再安装GIt

如果没有安装Git，先安装Git

MAC版本，直接运行：brew install git

安装OpenCode

# 安装node

# WIN+R打开运行
# 输入powershell，回车打开

# 安装OpenCode 
npm i -g opencode-ai@latest

重要！请把npm重置为 https://registry.npmjs.org ，不要用淘宝的镜像

npm i -g opencode-ai@latest --registry=https://registry.npmjs.org

若报错：在此系统禁止运行脚本，则执行如下命令处理：

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

安装oh-my-opencode

# 先安装bun
npm install -g bun --registry=https://registry.npmjs.org 

# claude、chatgpt、gemini的账号都没有，全写no
npx oh-my-opencode@latest install --no-tui --claude=no --chatgpt=no --gemini=no

安装uvx

# 执行如下命令（Powershell）
powershell -ExecutionPolicy Bypass -c "irm https://astral.sh/uv/install.ps1 | iex"

# 执行如下命令（MAC）
curl -LsSf https://astral.sh/uv/install.sh | sh

安装完成的截图如下，由于所有账号都没有，都自动配置成GLM-4.7了！
file-20260126202226757

启动

进入cmd命令行，进入需要操作的文件夹（比如你的代码文件夹，工作内容文件夹等等）

直接输入 opencode 即可启动

启动成功界面如下：
file-20260126202226935

如果出现bun禁用的问题，如下图：

file-20260126202226899

打开windows安全中心 → 应用和浏览器控制 → 智能应用控制 → 关闭，如下图：

file-20260126202226810

如何自定义配置

opencode配置

opencode的全局配置文件，在windows上位于如下位置：
C:\Users\用户\.config\opencode ,名字是：opencode.json

默认配置如下，仅包含一个插件：
file-20260126202226941

更多配置参数请参考：配置 |OpenCode

oh-my-opencode配置

oh-my-opencode的全局配置文件，在windows上位于如下位置：
C:\Users\用户\.config\opencode ,名字是：oh-my-opencode.json

该配置默认使用了，opencode提供的glm-4.7-free来提供各类agent和西西弗斯的功能

获取通用配置

直接使用git下载：已删除，自己整理下配置把
下载后的文件，把opencode-default-config文件夹中的内容复制到 C:\Users\用户\.config\opencode 中（mac是 ~.config\opencode），
然后联系你的领导要一个GLM的APIKey
打开命令行，输入opencode auth login
选择 Zhipu AI Coding Plan
输入Key
把opencode.jsonc 中的三个和GLM相关的部分替换成自己的Key，如下图：
git checkout 自己的名字
git push（推送自己的分支到服务器）

【开源推荐】AgentForce：当 GraphRAG 遇上 Agentic Workflow，打造下一代 AI 智能体平台 - TW-NLP - 博客园

2026-01-26mikel阅读(118)

💡 为什么关注 AgentForce？

在构建企业级知识库或 AI 助手时，我们经常遇到两个痛点：

RAG 的“碎片化”问题：向量检索只能找到相关的文本块，无法回答像“总结这份财报的主要风险”这种需要理解全局关系的宏观问题。
Agent 的“执行力”问题：简单的 Chatbot 缺乏规划能力，无法处理“先查库存，再比价，最后生成报告”这种复杂任务。

AgentForce正是为了解决这些问题而生。它不是一个简单的问答机器人，而是一个具备“图谱认知”和“自主规划”能力的智能平台。

项目地址：👉 https://github.com/TW-NLP/AgentForce

✨ 核心特性解读

1. ⚡️ Agentic Workflow (代理工作流)

AgentForce 引入了类似于人类的思考模式。它不仅仅是回答问题，而是在执行任务。

动态规划：Agent 会分析你的问题复杂度，自动判断是直接回答、查阅知识库，还是联网搜索（Tavily）。
长程记忆：内置了会话持久化机制，它记得住你们上周聊了什么，保证了上下文的连贯性。
多线程处理：完备的 Session 管理，支持多用户并发使用。

2. 🕸️ Graph-Powered (图谱增强认知)

这是该项目最大的亮点。它利用 GraphRAG 技术，将碎片化的文档转化为结构化的知识图谱。

实体与关系提取：自动从文档中提取 Entity（实体）并构建 Relationship（关系）。
全局查询 (Global Query)：这是传统 RAG 做不到的。它可以基于社区摘要（Community Summaries）回答宏观问题。
多模态支持：扔给它 PDF、Word、TXT 甚至 CSV，它都能处理。

3. 🎛️ 动态可配置 (Dynamic Control)

开发者最爱的特性——热更新。

模型热切换：可以在 GPT-4o, Claude-3.5 或本地模型之间无缝切换，无需重启服务。
工具链集成：一键开启 Tavily 联网搜索或 Firecrawl 网页爬取。

🛠️ 技术架构概览

AgentForce 采用了现代化的前后端分离架构，代码结构清晰，非常适合二次开发学习。

后端：Python 3.12+, FastAPI, Uvicorn, LangChain (可选), NetworkX
RAG 引擎：GraphRAG, 社区发现算法
前端：原生 JS (ES6+), HTML5, CSS3 (轻量级，无复杂构建依赖)

Plaintext

AgentForce/
├── config/                  # [控制中心] 提示词、配置与记忆存储
├── src/                     # [核心引擎]
│   ├── api/                 # RESTful API & WebSocket
│   ├── services/            # 核心业务 (LLM, GraphRAG, Search)
│   └── workflow/            # 代理大脑 (Agent Nodes & Edges)
├── static/                  # [交互界面] 轻量级 Web UI
├── run.py                   # 启动入口
└── README.md

🚀 快速上手体验

环境要求：Python 3.12+

第一步：克隆与安装

# 1. 克隆项目
git clone https://github.com/TW-NLP/AgentForce.git
cd AgentForce

# 2. 创建虚拟环境 (强烈推荐)
python -m venv venv
# Windows 激活: venv\Scripts\activate
# Mac/Linux 激活: source venv/bin/activate

# 3. 安装依赖
pip install -r requirements.txt

第二步：启动服务

AgentForce 分为后端 API 和前端 UI。

1. 启动后端引擎

python run.py
# 后端 API 将运行在 http://localhost:8000

2. 启动前端界面

cd static
python -m http.server 8080
# 访问浏览器 http://localhost:8080 即可开始使用

📖 玩法演示

1. 模型配置

系统启动后，点击左侧设置图标。填入你的 OpenAI API Key 或者兼容的 LLM 服务商信息。配置会自动保存到 saved_config.json，下次启动无需重新输入。

2. 构建知识库 (ETL)

进入“知识库”页面，拖拽上传你的 PDF 财报或技术文档。观察控制台，你会看到 AgentForce 正在执行 ETL 流程： 文本分块 -> 实体提取 -> 关系构建 -> 社区检出。这个过程非常解压，也是 GraphRAG 的核心魅力所在。

3. 深度对话

回到对话框，尝试提一个复杂问题：

“你好，对比一下本公司上市时间和百度公司上市时间，生成报告。”

你会发现 Agent 不再是机械地列出原文，而是生成了一份综合性的分析报告。

🔌 API 扩展

对于想把功能集成到自己系统的开发者，后端提供了标准的 Swagger 文档。启动后访问 http://localhost:8000/docs 即可查看所有接口，支持 POST /chat 对话、POST /graphrag/query 图谱查询等。

✍️ 总结

AgentForce 是一个展示了 GraphRAG 与 Agentic Workflow 如何落地的优秀案例。无论你是想学习最新的 RAG 技术，还是想搭建一个私有的企业级知识库，这个项目都值得一试。

如果你觉得项目不错，欢迎去 GitHub 点个 Star ⭐️ 支持一下作者！

🔗 项目地址: https://github.com/TW-NLP/AgentForce

国内四大AI编程IDE对比（一）：直观印象与模型能力 - haibindev - 博客园

2026-01-24mikel阅读(89)

来源： 国内四大AI编程IDE对比（一）：直观印象与模型能力 – haibindev – 博客园

前言

2025真的是AI编程风起云涌的一年，国产AI也在不断发力，比如阿里的灵码，腾讯codebuddy、百度comate和字节跳动的Trae。我准备把这四家的AI编程工具做一下对比；今天先来个简单的直观对比，所以多年深入研究视频技术和后端技术的开发者，我接下来会从实际项目入手，对这四家进行对比，包括C++工程的构建对比、现有工程重构能力的对比、web工程构建能力对比和移动app构建能力的对比，看看他们都能做到什么程度。

废话不多说，直接开整。

一、各自优势和对比

这是检索出来的数据，据说是根据第三方评测与企业数据，三款产品在代码生成质量上各有侧重：

产品	语言优势	场景亮点	核心差异
百度 Comate	C++核心代码质量第一；Python首生成率达92.3%	SQL生成准确率提升35%；Agent模式质量更高	知识图谱积累深厚，跨文件任务达91%
阿里通义灵码	Java/Go支持扎实，覆盖率98%；Python/JS表现优异	Spring Boot/Cloud生成精度超GitHub Copilot	@workspace支持RAG检索本地代码库
腾讯 CodeBuddy	Python/JS准确率较高；微信生态提升125%	微信小程序开发突出，符合审核规范	Plan模式自动拆解任务，采纳率达90%
字节 Trae CN	更偏“AI 原生 IDE + 中文需求直达代码”的强项；对前端/全栈原型类任务更友好（内置预览/调试链路贴近 Web 开发节奏）	SOLO 模式主打从需求到实现的端到端推进（可在 IDE/终端/浏览器等工具面板间协作），并支持在预览里实时交互与调试	不是“插件增强 IDE”，而是把 Agent（SOLO）+ 工具调度 + 预览调试做成 IDE 的中心能力；企业版还提供 IDE/插件/CLI 多形态接入以嵌入研发流程

二、官网给人的第一印象

2.1 阿里通义灵码：像做运维文档的人来做产品（稳、清晰、不吵）

lingma_page

打开通义灵码官网的第一感觉：这是阿里云的产品。

蓝白色调，排版规整，一看就是ToB企业级产品的风格。首页大标题”你的智能编码助手”，下面就是”立即免费使用”的按钮，简单直接。

阿里在下载页面把Lingma IDE放在最后（JetBrains插件 > VS Code插件 > Visual Studio插件 > Lingma IDE），但是默认项是是IDE，不知道这么排布的意思是什么？

2.2 腾讯 CodeBuddy：像在开发布会（而且 PPT 不止一页）

codebuddy_page

首屏最显眼的是”立即安装 CodeBuddy IDE”按钮，下面还跟着视频演示区域。这明显是想让我先用IDE。

2.3 百度Comate：有点意思

comage_page

百度的官网最有趣，我点进去一看，默认展示的是插件列表，IDE的入口排到后面去了。说实话，我有点懵。百度不是刚推出了”行业首个多模态AI IDE”吗？怎么官网首页默认显示的还是插件，独立IDE反而被藏在角落里？

我的猜测：

百度可能对自己IDE还不够自信？
或者开发进度还不够完善，不敢大张旗鼓推？
还是说百度觉得插件才是主流，IDE只是”锦上添花”？

2.4 Trae CN

trace_page

三、IDE界面对比

lingma

codebuddy

baiducomate

trace

下载安装完四家IDE后，我发现一个有趣的事实：它们长得都太像VS Code了。

左边文件树，右边代码区，底部终端，中间聊天窗口——这布局熟悉得不能再熟悉。

产品	界面相似度	独特性	舒适度
通义灵码	95%	左侧有专门的AI图标	⭐⭐⭐⭐
CodeBuddy	98%	聊天窗口在右侧	⭐⭐⭐⭐⭐
Comate	96%	底部有知识库入口	⭐⭐⭐⭐
Trae CN	IDE模式97%	现代化设计，丰富快捷键，多窗口支持	⭐⭐⭐⭐⭐

四、对话和模型

通义灵码：对话模式只能选择“智能体”或者“智能问答”，没用模型选择

CodeBuddy：模式可以选择“Craft”、“Ask”和“Plan”。模型可选GLM、Kimi-Thinking、DeepSeek和“Hunyuan”。

Comate：模式选择最多“Zulu”、“Ask”、“Plan”、“Architech”、“Page Builder”、“Figma2Code”，模型可以选“Kimi”、“DeepSeek”、“GLM”和“MiniMax”。

Trae CN：在solo模式下，可以选择Doubao-Seed-Code、GLM、MiniMax和Kimi-K2，在IDE模式下，模型选择多了“Doubao-Seed-1.8”、“DeepSeek-V3.1-Terminus”和”Qwen-3-Coder”

还有一个特别的地方就是，Trae可以语音输入

五模型架构设计

三款产品在底层模型选择和技术架构上呈现出不同的设计理念，以下数据也是检索出来的，整理了一下可以对比了解一下：

百度 Comate 采用”三明治”架构设计，将自身在AI领域的积累深度融入代码场景：

层级	核心技术	说明
底层模型	文心ERNIE 3.5	提供语义理解和推理能力
中间层	代码知识图谱	整合2400万+高质量代码片段
应用层	10+功能模块	智能补全、错误诊断、测试生成等

阿里通义灵码 基于通义代码大模型构建，2025年2月新增DeepSeek满血版支持：

层级	核心技术	说明
核心模型	Qwen-2.5-Coder	千亿级参数规模
扩展模型	DeepSeek-V3/R1	671B参数，128K上下文
技术特点	代码库知识图谱	类继承关系识别准确率达91%

腾讯 CodeBuddy 采用混合架构，兼顾响应速度与能力上限：

层级	核心技术	说明
本地模型	混元Turbo S	1.8B参数，FP8量化，快速响应
云端模型	DeepSeek-V3/R1	671B参数，线性注意力机制
内存优化	长文本处理	内存占用降低65%

字节跳动 Trae IDE 采用分层融合架构，基于自研代码大模型与开源模型深度集成：

层级	核心技术	说明
底层模型	Doubao-1.5-pro（豆包）	国内版公开信息中作为基座模型，主打中文需求理解与代码生成。
底层模型（可切换）	DeepSeek R1 / V3（“满血版”切换）	多家报道与官方站点信息均提到支持切换 DeepSeek R1&V3，用于拉高能力上限（推理/复杂任务）。
中间层	SOLO 模式：上下文承接 + 工具调度	官方对 SOLO 的定义是“以 AI 为主导，可理解目标、承接上下文并调度工具，独立推进各阶段开发任务”。
中间层（工程化形态）	IDE / 插件 / CLI 多形态接入（企业版）	企业版发布信息明确提到提供 IDE、插件、CLI 多形态，用于更好地嵌入企业研发流程。
应用层	自然语言生成项目框架 + 实时预览 + 智能修复	官方站点对产品能力的核心表述包括：中文自然语言生成完整代码框架、实时预览前端效果、智能修复 Bug。

合作请加WX：hbstream
（http://haibindev.cnblogs.com），转载请注明作者和出处

工作中用MQ最多的10种场景 - 苏三说技术 - 博客园

2026-01-15mikel阅读(77)

来源： 工作中用MQ最多的10种场景 – 苏三说技术 – 博客园

前言

最近有球友问我：MQ的使用场景有哪些？工作中一定要使用MQ吗？

记得刚工作那会儿，我总是想不明白：为什么明明直接调用接口就能完成的功能，非要引入MQ这么个”中间商”？

直到经历了系统崩溃、数据丢失、性能瓶颈等一系列问题后，我才真正理解了MQ的价值。

今天我想和大家分享我在实际工作中使用消息队列（MQ）的10种典型场景，希望对你会有所帮助。

一、为什么需要消息队列（MQ）？

在深入具体场景之前，我们先来思考一个基本问题：为什么要使用消息队列？

系统间的直接调用：

引入消息队列后：

接下来我们将通过10个具体场景，带大家来深入理解MQ的价值。

场景一：系统解耦

背景描述

在我早期参与的一个电商项目中，订单创建后需要通知多个系统：

// 早期的紧耦合设计
public class OrderService {
    private InventoryService inventoryService;
    private PointsService pointsService;
    private EmailService emailService;
    private AnalyticsService analyticsService;
    
    public void createOrder(Order order) {
        // 1. 保存订单
        orderDao.save(order);
        
        // 2. 调用库存服务
        inventoryService.updateInventory(order);
        
        // 3. 调用积分服务
        pointsService.addPoints(order.getUserId(), order.getAmount());
        
        // 4. 发送邮件通知
        emailService.sendOrderConfirmation(order);
        
        // 5. 记录分析数据
        analyticsService.trackOrderCreated(order);
        
        // 更多服务...
    }
}

这种架构存在严重问题：

紧耦合：订单服务需要知道所有下游服务
单点故障：任何一个下游服务挂掉都会导致订单创建失败
性能瓶颈：同步调用导致响应时间慢

MQ解决方案

引入MQ后，架构变为：

代码实现：

// 订单服务 - 生产者
@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void createOrder(Order order) {
        // 1. 保存订单
        orderDao.save(order);
        
        // 2. 发送消息到MQ
        rabbitTemplate.convertAndSend(
            "order.exchange",
            "order.created",
            new OrderCreatedEvent(order.getId(), order.getUserId(), order.getAmount())
        );
    }
}

// 库存服务 - 消费者
@Component
@RabbitListener(queues = "inventory.queue")
public class InventoryConsumer {
    @Autowired
    private InventoryService inventoryService;
    
    @RabbitHandler
    public void handleOrderCreated(OrderCreatedEvent event) {
        inventoryService.updateInventory(event.getOrderId());
    }
}

技术要点

消息协议选择：根据业务需求选择RabbitMQ、Kafka或RocketMQ
消息格式：使用JSON或Protobuf等跨语言格式
错误处理：实现重试机制和死信队列

场景二：异步处理

背景描述

用户上传视频后需要执行转码、生成缩略图、内容审核等耗时操作，如果同步处理，用户需要等待很长时间。

MQ解决方案

// 视频服务 - 生产者
@Service
public class VideoService {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;
    
    public UploadResponse uploadVideo(MultipartFile file, String userId) {
        // 1. 保存原始视频
        String videoId = saveOriginalVideo(file);
        
        // 2. 发送处理消息
        kafkaTemplate.send("video-processing", new VideoProcessingEvent(videoId, userId));
        
        // 3. 立即返回响应
        return new UploadResponse(videoId, "upload_success");
    }
}

// 视频处理服务 - 消费者
@Service
public class VideoProcessingConsumer {
    @KafkaListener(topics = "video-processing")
    public void processVideo(VideoProcessingEvent event) {
        // 异步执行耗时操作
        videoProcessor.transcode(event.getVideoId());
        videoProcessor.generateThumbnails(event.getVideoId());
        contentModerationService.checkContent(event.getVideoId());
        
        // 发送处理完成通知
        notificationService.notifyUser(event.getUserId(), event.getVideoId());
    }
}

架构优势

快速响应：用户上传后立即得到响应
弹性扩展：可以根据处理压力动态调整消费者数量
故障隔离：处理服务故障不会影响上传功能

场景三：流量削峰

背景描述

电商秒杀活动时，瞬时流量可能是平时的百倍以上，直接冲击数据库和服务。

MQ解决方案

代码实现：

// 秒杀服务
@Service
public class SecKillService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public SecKillResponse secKill(SecKillRequest request) {
        // 1. 校验用户资格
        if (!checkUserQualification(request.getUserId())) {
            return SecKillResponse.failed("用户无资格");
        }
        
        // 2. 预减库存（Redis原子操作）
        Long remaining = redisTemplate.opsForValue().decrement(
            "sec_kill_stock:" + request.getItemId());
        
        if (remaining == null || remaining < 0) {
            // 库存不足，恢复库存
            redisTemplate.opsForValue().increment("sec_kill_stock:" + request.getItemId());
            return SecKillResponse.failed("库存不足");
        }
        
        // 3. 发送秒杀成功消息到MQ
        rabbitTemplate.convertAndSend(
            "sec_kill.exchange",
            "sec_kill.success",
            new SecKillSuccessEvent(request.getUserId(), request.getItemId())
        );
        
        return SecKillResponse.success("秒杀成功");
    }
}

// 订单处理消费者
@Component
@RabbitListener(queues = "sec_kill.order.queue")
public class SecKillOrderConsumer {
    @RabbitHandler
    public void handleSecKillSuccess(SecKillSuccessEvent event) {
        // 异步创建订单
        orderService.createSecKillOrder(event.getUserId(), event.getItemId());
    }
}

技术要点

库存预扣：使用Redis原子操作避免超卖
队列缓冲：MQ缓冲请求，避免直接冲击数据库
限流控制：在网关层进行限流，拒绝过多请求

场景四：数据同步

背景描述

在微服务架构中，不同服务有自己的数据库，需要保证数据一致性。

MQ解决方案

// 用户服务 - 数据变更时发送消息
@Service
public class UserService {
    @Transactional
    public User updateUser(User user) {
        // 1. 更新数据库
        userDao.update(user);
        
        // 2. 发送消息（在事务内）
        rocketMQTemplate.sendMessageInTransaction(
            "user-update-topic",
            MessageBuilder.withPayload(new UserUpdateEvent(user.getId(), user.getStatus()))
                .build(),
            null
        );
        
        return user;
    }
}

// 其他服务 - 消费用户更新消息
@Service
@RocketMQMessageListener(topic = "user-update-topic", consumerGroup = "order-group")
public class UserUpdateConsumer implements RocketMQListener<UserUpdateEvent> {
    @Override
    public void onMessage(UserUpdateEvent event) {
        // 更新本地用户信息缓存
        orderService.updateUserCache(event.getUserId(), event.getStatus());
    }
}

一致性保证

本地事务表：将消息和业务数据放在同一个数据库事务中
事务消息：使用RocketMQ的事务消息机制
幂等消费：消费者实现幂等性，避免重复处理

场景五：日志收集

背景描述

分布式系统中，日志分散在各个节点，需要集中收集和分析。

MQ解决方案

代码实现：

// 日志收集组件
@Component
public class LogCollector {
    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;
    
    public void collectLog(String appId, String level, String message, Map<String, Object> context) {
        LogEvent logEvent = new LogEvent(appId, level, message, context, System.currentTimeMillis());
        
        // 发送到Kafka
        kafkaTemplate.send("app-logs", appId, JsonUtils.toJson(logEvent));
    }
}

// 日志消费者
@Service
public class LogConsumer {
    @KafkaListener(topics = "app-logs", groupId = "log-es")
    public void consumeLog(String message) {
        LogEvent logEvent = JsonUtils.fromJson(message, LogEvent.class);
        
        // 存储到Elasticsearch
        elasticsearchService.indexLog(logEvent);
        
        // 实时监控检查
        if ("ERROR".equals(logEvent.getLevel())) {
            alertService.checkAndAlert(logEvent);
        }
    }
}

技术优势

解耦：应用节点无需关心日志如何处理
缓冲：应对日志产生速率波动
多消费：同一份日志可以被多个消费者处理

场景六：消息广播

背景描述

系统配置更新后，需要通知所有服务节点更新本地配置。

MQ解决方案

// 配置服务 - 广播配置更新
@Service
public class ConfigService {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public void updateConfig(String configKey, String configValue) {
        // 1. 更新配置存储
        configDao.updateConfig(configKey, configValue);
        
        // 2. 广播配置更新消息
        redisTemplate.convertAndSend("config-update-channel", 
            new ConfigUpdateEvent(configKey, configValue));
    }
}

// 服务节点 - 订阅配置更新
@Component
public class ConfigUpdateListener {
    @Autowired
    private LocalConfigCache localConfigCache;
    
    @RedisListener(channel = "config-update-channel")
    public void handleConfigUpdate(ConfigUpdateEvent event) {
        // 更新本地配置缓存
        localConfigCache.updateConfig(event.getKey(), event.getValue());
    }
}

应用场景

功能开关：动态开启或关闭功能
参数调整：调整超时时间、限流阈值等
黑白名单：更新黑白名单配置

场景七：顺序消息

背景描述

在某些业务场景中，消息的处理顺序很重要，如订单状态变更。

MQ解决方案

// 订单状态变更服务
@Service
public class OrderStateService {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    public void changeOrderState(String orderId, String oldState, String newState) {
        OrderStateEvent event = new OrderStateEvent(orderId, oldState, newState);
        
        // 发送顺序消息，使用orderId作为sharding key
        rocketMQTemplate.syncSendOrderly(
            "order-state-topic", 
            event, 
            orderId  // 保证同一订单的消息按顺序处理
        );
    }
}

// 订单状态消费者
@Service
@RocketMQMessageListener(
    topic = "order-state-topic",
    consumerGroup = "order-state-group",
    consumeMode = ConsumeMode.ORDERLY  // 顺序消费
)
public class OrderStateConsumer implements RocketMQListener<OrderStateEvent> {
    @Override
    public void onMessage(OrderStateEvent event) {
        // 按顺序处理订单状态变更
        orderService.processStateChange(event);
    }
}

顺序保证机制

分区顺序：同一分区内的消息保证顺序
顺序投递：MQ保证消息按发送顺序投递
顺序处理：消费者顺序处理消息

场景八：延迟消息

背景描述

需要实现定时任务，如订单超时未支付自动取消。

MQ解决方案

// 订单服务 - 发送延迟消息
@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void createOrder(Order order) {
        // 保存订单
        orderDao.save(order);
        
        // 发送延迟消息，30分钟后检查支付状态
        rabbitTemplate.convertAndSend(
            "order.delay.exchange",
            "order.create",
            new OrderCreateEvent(order.getId()),
            message -> {
                message.getMessageProperties().setDelay(30 * 60 * 1000); // 30分钟
                return message;
            }
        );
    }
}

// 订单超时检查消费者
@Component
@RabbitListener(queues = "order.delay.queue")
public class OrderTimeoutConsumer {
    @RabbitHandler
    public void checkOrderPayment(OrderCreateEvent event) {
        Order order = orderDao.findById(event.getOrderId());
        if ("UNPAID".equals(order.getStatus())) {
            // 超时未支付，取消订单
            orderService.cancelOrder(order.getId(), "超时未支付");
        }
    }
}

替代方案对比

方案	优点	缺点
数据库轮询	实现简单	实时性差，数据库压力大
延时队列	实时性好	实现复杂，消息堆积问题
定时任务	可控性强	分布式协调复杂

场景九：消息重试

背景描述

处理消息时可能遇到临时故障，需要重试机制保证最终处理成功。

MQ解决方案

// 消息消费者 with 重试机制
@Service
@Slf4j
public class RetryableConsumer {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @RabbitListener(queues = "business.queue")
    public void processMessage(Message message, Channel channel) {
        try {
            // 业务处理
            businessService.process(message);
            
            // 确认消息
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            
        } catch (TemporaryException e) {
            // 临时异常，重试
            log.warn("处理失败，准备重试", e);
            
            // 拒绝消息，requeue=true
            channel.basicNack(
                message.getMessageProperties().getDeliveryTag(),
                false,
                true  // 重新入队
            );
            
        } catch (PermanentException e) {
            // 永久异常，进入死信队列
            log.error("处理失败，进入死信队列", e);
            
            channel.basicNack(
                message.getMessageProperties().getDeliveryTag(),
                false,
                false  // 不重新入队
            );
        }
    }
}

重试策略

立即重试：临时故障立即重试
延迟重试：逐步增加重试间隔
死信队列：最终无法处理的消息进入死信队列

场景十：事务消息

背景描述

分布式系统中，需要保证多个服务的数据一致性。

MQ解决方案

// 事务消息生产者
@Service
public class TransactionalMessageService {
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    @Transactional
    public void createOrderWithTransaction(Order order) {
        // 1. 保存订单（数据库事务）
        orderDao.save(order);
        
        // 2. 发送事务消息
        TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction(
            "order-tx-topic",
            MessageBuilder.withPayload(new OrderCreatedEvent(order.getId()))
                .build(),
            order  // 事务参数
        );
        
        if (!result.getLocalTransactionState().equals(LocalTransactionState.COMMIT_MESSAGE)) {
            throw new RuntimeException("事务消息发送失败");
        }
    }
}

// 事务消息监听器
@Component
@RocketMQTransactionListener
public class OrderTransactionListener implements RocketMQLocalTransactionListener {
    @Autowired
    private OrderDao orderDao;
    
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            // 检查本地事务状态
            Order order = (Order) arg;
            Order existOrder = orderDao.findById(order.getId());
            
            if (existOrder != null && "CREATED".equals(existOrder.getStatus())) {
                return RocketMQLocalTransactionState.COMMIT_MESSAGE;
            } else {
                return RocketMQLocalTransactionState.ROLLBACK_MESSAGE;
            }
        } catch (Exception e) {
            return RocketMQLocalTransactionState.UNKNOWN;
        }
    }
    
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        // 回查本地事务状态
        String orderId = (String) msg.getHeaders().get("order_id");
        Order order = orderDao.findById(orderId);
        
        if (order != null && "CREATED".equals(order.getStatus())) {
            return RocketMQLocalTransactionState.COMMIT_MESSAGE;
        } else {
            return RocketMQLocalTransactionState.ROLLBACK_MESSAGE;
        }
    }
}

事务消息流程

总结

通过以上10个场景，我们可以总结出MQ使用的核心原则：

适用场景

异步处理：提升系统响应速度
系统解耦：降低系统间依赖
流量削峰：应对突发流量
数据同步：保证最终一致性
分布式事务：解决数据一致性问题

技术选型建议

场景	推荐MQ	原因
高吞吐	Kafka	高吞吐量，持久化存储
事务消息	RocketMQ	完整的事务消息机制
复杂路由	RabbitMQ	灵活的路由配置
延迟消息	RabbitMQ	原生支持延迟队列

最佳实践

消息幂等性：消费者必须实现幂等处理
死信队列：处理失败的消息要有兜底方案
监控告警：完善的消息堆积监控和告警
性能优化：根据业务特点调整MQ参数

最后说一句(求关注，别白嫖我)

如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下我的同名公众号：苏三说技术，您的支持是我坚持写作最大的动力。

求一键三连：点赞、转发、在看。

关注公众号：【苏三说技术】，在公众号中回复：进大厂，可以免费获取我最近整理的10万字的面试宝典，好多小伙伴靠这个宝典拿到了多家大厂的offer。

更多项目实战在我的技术网站：http://www.susan.net.cn/project

张高兴的大模型开发实战：（七）基于 Dify + Ollama 搭建私有化知识问答助手 - 张高兴 - 博客园

2026-01-12mikel阅读(85)

来源： 张高兴的大模型开发实战：（七）基于 Dify + Ollama 搭建私有化知识问答助手 – 张高兴 – 博客园

你是否也有过这样的经历：当汽车仪表盘上突然跳出一个陌生的黄色故障灯，或者你想调整后视镜的倒车下翻功能，却不得不从副驾手套箱里翻出那本厚达 400 页、封皮都快粘连的《用户使用手册》。你试图在目录中寻找关键词，翻到第 218 页，却发现还有“参见第 56 页”的跳转。在那一刻，你一定希望有一个懂行的老司机坐在旁边，你只需问一句：“这个像茶壶一样的灯亮了是什么意思？”，他就能立马告诉你答案。在 AI 大模型时代，这个愿望已经可以零成本实现。今天这篇博客，将带大家实战一个非常典型的 RAG（检索增强生成）场景：利用开源工具 Dify 和本地大模型工具 Ollama，搭建一个能够完全读懂你汽车手册的 AI 智能体。完成后，不仅可以通过 Web 界面与它对话，还能通过 Python API 将其集成到其他应用中。

为什么选择 Dify + Ollama

在开始动手之前，先聊聊为什么选择这套技术栈。市面上有很多构建 AI 应用的方法，比如像之前博客介绍的那样直接用 LangChain 手搓，或者使用云端的 API，但对于不懂编程、不懂技术的用户，Dify + Ollama 是目前性价比最高、上手最快的选择。

Ollama：之前已经介绍过了，它是目前在本地运行大语言模型（LLM）最简单的工具。不需要复杂的环境配置，不需要研究 PyTorch，只需一行命令，就能在 PC 上运行 Llama 3、Qwen 2.5 等开源模型，最重要的是，它是本地化的，隐私绝对安全。

Dify：如果说 Ollama 提供了“大脑”，那么 Dify 就提供了“身体”和“四肢”，使模型具备了一些“能力”。Dify 是一个开源的 LLM 应用开发平台，它解决了 LLM 开发中最常见的问题：知识库的切片与索引、Prompt 的编排、上下文记忆的管理，以及对外提供标准的 API 接口。它是低代码的，几乎不需要写代码就能搭出一个企业级的 AI 应用。

在接下来的教程中，将完成以下操作：

环境搭建：在本地部署 Ollama 和 Dify。
模型接入：让 Dify 连接上本地运行的 Qwen2.5 模型。
知识库构建：上传《用户手册》PDF，通过 RAG 技术让 AI “学会”手册的内容。
智能体编排：调试 Prompt，让它根据用户手册回答问题。
API 调用：编写 Python 脚本调用搭建好的智能体，实现问答。

操作用到的用户手册可在此处下载：https://oss.mpdoc.com/doc/2026/01/10/CA60DABA002540C5894B85DA2DB46E14.pdf?attname=BMW_用户手册_01405A7D339.pdf

Ollama 本地部署

Ollama 的安装极度简化，几乎是“开箱即用”。直接访问 Ollama 官网 https://ollama.com/download 下载安装包即可。Linux 使用官方的一键安装脚本 curl -fsSL https://ollama.com/install.sh | sh。安装完成后，在命令行输入 ollama -v，看到版本号即表示安装成功。

访问 https://ollama.com/search 可以查看 Ollama 支持的模型，这里选择 Qwen2.5-7B 版本（70 亿参数，平衡了速度和智能）。在命令行中执行 ollama run qwen2.5:7b，等待模型下载完成（大约 5GB），即可在本地运行该模型。下载完成后，会直接进入对话框。你可以试着问它：“你好，介绍一下你自己。” 如果它能流畅回复，说明模型已经激活。按 Ctrl + D 退出对话模式，模型会在后台继续运行。

Dify 本地容器化部署

为了保证环境的纯净和易于管理，官方推荐使用 Docker Compose 进行部署。首先，确保你的机器上安装了 Docker 和 Docker Compose（https://www.docker.com）。下面需要将 Dify 的代码仓库下载到本地。在命令行中执行以下命令 git clone --depth 1 https://github.com/langgenius/dify.git，如果你本地没有安装 Git，也可以直接去 GitHub 页面下载 ZIP 压缩包并解压。

Dify 是一个完整的应用架构，包含前端、后端、数据库（PostgreSQL）、缓存（Redis）和向量数据库（Weaviate/Qdrant）等多个组件。手动安装这些组件非常繁琐，但通过 Docker Compose，可以一键拉起所有服务。进入目录并执行以下命令，初次运行需要拉取多个 Docker 镜像。

# 进入 docker 目录
cd dify/docker
# 复制环境变量配置文件
cp .env.example .env
# 启动容器
docker compose up -d

等待所有容器启动完毕后，打开浏览器，访问 http://localhost/install，你将看到 Dify 的初始化引导界面。在这里设置你的管理员账号和密码。设置完成后，即可登录进入 Dify。

模型接入与知识库 RAG 构建

环境搭建完毕后，目前的 Dify 还是一个“空壳”。下面需要做两件事：

把 Ollama 的模型接入 Dify，让它拥有对话和理解能力；
把《用户手册》喂给它，构建向量知识库。

准备 Embedding 模型

在构建知识库时，除了对话模型，还需要一个专门的 Text Embedding（文本向量化）模型。之前的博客已经介绍了 Embedding 的概念，简单来说，它的作用是把手册里的文字变成计算机能理解的“数字向量”。打开命令行，拉取轻量级向量模型 ollama pull nomic-embed-text。

在 Dify 中添加 Ollama 模型供应商

回到 Dify 的网页界面：

点击右上角的 头像 -> 设置 -> 模型供应商。
找到 Ollama 卡片，点击“安装”。
安装完成后，点击 Ollama 卡片中的“添加模型”。

这里需要添加两次：

第一次：添加 LLM（对话模型）

模型名称：qwen2.5:7b（必须与你在命令行 ollama list 查看到的名称完全一致）
模型类型：LLM
基础 URL：http://host.docker.internal:11434（Docker 容器访问宿主机的地址）

第二次：添加 Text Embedding（向量模型）

模型名称：nomic-embed-text
模型类型：Text Embedding
基础 URL：同上

如果保存时提示“Error”，请检查 Ollama 能否通过 URL http://localhost:11434 访问，或者 Docker 网络配置和防火墙设置。

构建知识库

点击顶部导航栏的 知识库 -> 创建知识库。
上传文档：选择“导入已有文本”，将 用户手册.pdf 拖进去，点击“下一步”。
分段（Chunk）设置：这里需要配置如何将 PDF 拆解成小段落，方便后续检索。
- 分段标识符：文档段落之间是怎样分隔的。\n 表示换行符，例如此处上传的文档段落之间就是通过换行符分隔的，有些时候可能会使用双换行符 \n\n，即两个段落之间有一个空行。
- 最大分段长度：决定了 AI “一口吃多少东西”。如果设置得太小，知识库会被切得过碎，影响检索效果；如果设置得太大，AI 可能无法有效利用上下文。
- 分段重叠长度*：相邻段落之间重叠的字符数，有助于保持上下文连续性。
- 使用 Q&A 分段：如果你的文档是“问答”类型的，开启此选项可以让 Dify 识别问答对，提升检索效果。
索引方式：选择 “高质量”，这会调用刚才配置的 nomic-embed-text 模型进行向量化处理。
点击 “保存并处理”。

此时，Dify 会将几百页的 PDF 拆解成小段，转换成向量，并存入内置的向量数据库中。根据文档大小，这可能需要较长的时间。

检索测试

不要急着去创建聊天助手，先确认知识库“懂了”没有。在知识库详情页的左侧，找到 召回测试 按钮。这里可以模拟检索过程。例如输入测试文本：“如何打开远光灯？”，点击 测试，系统会展示它从手册中找到的最相关的几个段落。如果结果不准，说明分段可能切得太碎了，或者 PDF 解析乱码。这时需要回到 设置 中调整分段规则重新索引。

构建智能体应用

如果说知识库是 AI 的“图书馆”，那么 智能体编排（Orchestration） 就是给 AI 制定“员工手册”。需要告诉 AI：你现在的身份是什么？你应该怎么查阅资料？遇到不知道的问题该怎么回答？在 Dify 中，这一步不需要写代码，全程可视化操作。

创建应用

回到 Dify 首页的 工作室，点击 创建应用 按钮。应用类型选择 Chatflow，并起一个合适的名称。

编排界面概览

进入应用后，会看到一个左右分栏的界面：

左侧：编排区，编排 AI 的工作流程。默认创建了一个包含 LLM 节点的最简单对话流程。
右侧：调试区，用来设置提示词、上下文、开场白等，也可以实时测试 AI 的反应。

查询预处理

在实际测试中，你可能会发现 AI 有时候变得“笨笨的”。因为用户的口语表达和手册的书面术语不完全一致，导致检索失败。为了解决这个问题，需要在 AI 去知识库“翻书”之前，先对用户的问题进行“预处理”，也就是提取检索的关键词句。

下面点击默认提供的 LLM 节点，修改名称为“提取关键词”。在右侧的 SYSTEM 提示词区域，输入以下内容：

# Task
你将收到用户的问题。请先提取问题中的关键信息，用于进行检索知识库内容。

# Output
输出多个关键词或关键句，关键词或关键句之间使用空格分隔，禁止直接回答用户的问题

完成后可以点击顶部的 预览 按钮进行测试。

关联知识库

检索关键词有了之后，就可以利用关键词在知识库中检索相关内容。在 提取关键词 和 直接回复 节点之间，添加一个新节点 知识检索。

将 查询文本 改为 提取关键词 节点的输出，知识库 选择刚刚创建的“用户手册”知识库。

编写提示词

从知识库中检索到 相关信息（Context，上下文） 后，接下来就是让 AI 根据这些信息回答用户的问题了。在 知识检索 和 直接回复 节点之间，添加一个 LLM 节点 名称为 回答问题。

在右侧的 上下文 中选择 知识检索 节点输出的结果 result，SYSTEM 提示词区域，输入下面的提示词，这段提示词使用了 Role-Constraints-Goal 框架，能有效防止 AI 产生幻觉。

# Role
你是一位经验丰富的汽车维修与使用专家。你的任务是根据【Context】提供的内容，准确、简洁地回答用户关于车辆使用的问题。

# Constraints
1. 必须完全基于【Context】中的信息回答，严禁凭空捏造或利用外部知识回答手册未涉及的内容。
2. 如果【Context】中没有相关信息，请直接回答：“很抱歉，当前手册中未找到关于该问题的说明。”
3. 回答步骤要清晰，如果是操作指南，请按 1. 2. 3. 分点列出。
4. 语气要专业、耐心、乐于助人。

# Goal
帮助用户快速解决车辆使用中的疑惑，确保行车安全。

# Context
{{#context#}}

调整模型参数

点击模型右侧的图标，设置 温度（Temperature） 参数，可以设为小于 0.5 的值。温度越低，AI 越严谨、越死板；温度越高，AI 越发散、越有创造力。对于“查阅说明书”这种严肃场景，需要的是绝对的准确，而不是创造力。

调试与发布

以上配置完成后，先在右侧进行预览测试，观察 AI 的回答是否准确、步骤是否清晰，并且有无引用来源。如果不满意，可以继续调整提示词或上下文设置，直到满意为止。测试满意后，点击右上角的 发布 按钮。发布成功后点击 运行，即可通过 URL 进入 Web 界面和你的“车辆管家”聊天了！

Python API 调用实战

在前面的步骤中，已经实现了一个能在 Dify 网页端流畅对话的“用车顾问”。Dify 最强大的地方在于它遵循 API First 的设计理念。我们在网页上看到的所有功能，都可以通过 API 进行调用。这意味着可以把这个“大脑”接入到任何你想要的地方。接下来，编写一段 Python 代码，实现与智能体的远程对话。

获取 API 密钥

要通过 API 调用 Dify，首先需要拿到通行证。在 Dify 应用编排页面的左侧导航栏，点击 访问 API。

在右上角点击 API 密钥 -> 创建密钥。
复制生成的密钥。
留意页面上的 API 服务器地址，本地部署通常是 http://localhost/v1 。

环境准备

需要使用 Python 的 requests 库来发送 HTTP 请求。如果还没有安装，请在命令行执行 pip install requests。

编写脚本

新建一个文件 car_bot.py，将以下代码复制进去。这段代码使用了阻塞模式 (Blocking)，程序会等待 AI 完全生成完答案后，一次性返回结果。

import requests

# ================= 配置区域 =================
# 替换为你的 API 密钥
API_KEY = 'app-pJRiHLHP4UMJ3tGqyYLyAjGb' 
# Dify 的 API 地址
BASE_URL = 'http://localhost/v1'
# 定义请求头
headers = {
    'Authorization': f'Bearer {API_KEY}',
    'Content-Type': 'application/json'
}
# ===========================================

def ask(question, user_id="user_123", conversation_id=""):
    """
    发送问题给 Dify 智能体
    :param question: 用户的问题
    :param user_id: 用户唯一标识（用于区分不同用户的上下文）
    :param conversation_id: 会话 ID（用于多轮对话）
    """
    url = f'{BASE_URL}/chat-messages'
    
    payload = {
        "inputs": {},           # 如果你的 Prompt 没设置变量，这里留空
        "query": question,      # 用户的问题
        "response_mode": "blocking", # blocking=等待全部生成, streaming=流式输出
        "conversation_id": conversation_id,  # 留空表示开启新会话，填入 ID 可延续上下文
        "user": user_id,        # 必须字段，区分用户
    }

    try:
        print(f"正在思考问题：{question} ...")
        response = requests.post(url, headers=headers, json=payload)
        response.raise_for_status()
        result = response.json()
        
        # 提取 AI 的回答
        answer = result.get('answer', '')
        # 提取引用来源（如果有）
        metadata = result.get('metadata', {})
        usage = metadata.get('usage', {})
        
        print("-" * 30)
        print(f"🤖 AI 回答：\n{answer}")
        print("-" * 30)
        print(f"📊 消耗 Token：{usage.get('total_tokens', 0)}")
        
        return result.get('conversation_id') # 返回会话 ID 供下次使用

    except requests.exceptions.RequestException as e:
        print(f"请求出错: {e}")
        return None

if __name__ == '__main__':
    # 测试调用
    current_conversation_id = ask("如何分享数字钥匙？")

运行脚本 python car_bot.py，你将看到 AI 根据手册内容给出的准确回答。

通过这个 Python 脚本，想象力就可以起飞了。将脚本封装成一个 Web 服务，接收微信消息，转发给 Dify，再把答案发回微信，制作一个聊天机器人。也可以结合 Whisper（语音转文字）和 Edge-TTS（文字转语音），给这个智能体加上耳朵和嘴巴…

Claude Code 完全指南：使用方式、技巧与最佳实践 - knqiufan - 博客园

2026-01-07mikel阅读(116)

来源： Claude Code 完全指南：使用方式、技巧与最佳实践 – knqiufan – 博客园

最近在深度使用 Claude Code，发现真的很香！即整理了一份全面的指南，从零开始逐步了解 Claude Code 的核心功能、高级特性和最佳实践。这篇博客实际上更像是一本工具书，让我自己在使用时也能随时参考其内容，更好的使用这个强大的 AI 工具。

一、Claude Code 简介

1.1 什么是 Claude Code?

Claude Code(CC)是由 Anthropic 开发的系统级 AI Agent,它不仅是一个代码编写工具,更是一个可以通过自然语言指令完成各种电脑任务的智能助手。

核心特性:

特性	说明
全功能访问	拥有系统级权限,可执行文件操作、运行命令、管理进程等
超大上下文	支持 200K token 上下文窗口,可处理大型项目
高度可扩展	支持 MCP、Skills、Plugins、Hooks 等多种扩展方式
多代理协作	支持子代理(Subagents)并行处理复杂任务
自然交互	支持自然语言指令,无需学习复杂命令语法

1.2 Claude Code vs 传统工具

传统开发工具

代码编辑器

Chat AI工具

Coding助手

Claude Code

代码编写

对话问答

数据分析

文件管理

爬虫自动化

Office处理

核心差异:

传统工具:单一功能,需要人工操作多个工具完成复杂任务
Claude Code:系统级 AI Agent,通过自然语言指令即可完成全流程任务

二、安装与配置

2.1 前置准备

必需工具:

工具	用途	安装地址
Node.js	运行环境	https://nodejs.org
Git	版本控制	https://git-scm.com
API Key	模型服务	智谱GLM/月之暗面K2/阿里Qwen等

验证安装:

# 检查 Node.js 版本
node -v

# 检查 Git 版本
git --version

2.2 安装 Claude Code

全局安装(推荐):

npm install -g @anthropic-ai/claude-code

验证安装:

claude --version

2.3 配置模型

Claude Code 支持多种模型配置方式,你可以根据自己的需求选择合适的模型。

方式一:手动配置(通用方式)

手动配置适用于所有兼容 Anthropic API 的模型。配置方式如下:

Windows:

setx ANTHROPIC_BASE_URL "模型API地址"
setx ANTHROPIC_AUTH_TOKEN "你的API密钥"
setx ANTHROPIC_MODEL "模型名称"

macOS/Linux:

export ANTHROPIC_BASE_URL=模型API地址
export ANTHROPIC_AUTH_TOKEN=你的API密钥
export ANTHROPIC_MODEL=模型名称

# 永久配置(添加到 ~/.bashrc 或 ~/.zshrc)
echo 'export ANTHROPIC_BASE_URL=模型API地址' >> ~/.bashrc
echo 'export ANTHROPIC_AUTH_TOKEN=你的API密钥' >> ~/.bashrc
echo 'export ANTHROPIC_MODEL=模型名称' >> ~/.bashrc
source ~/.bashrc

常用国内模型配置示例:

模型	API地址	模型名称	获取API Key
智谱 GLM-4.7	`https://open.bigmodel.cn/api/anthropic`	`GLM-4.7`	https://open.bigmodel.cn/
Kimi K2	`https://api.moonshot.cn/v1`	`kimi-k2`	https://platform.moonshot.cn/console/account
通义千问	`https://dashscope.aliyuncs.com/compatible-mode/v1`	`qwen-coder-plus`	https://bailian.console.aliyun.com/
DeepSeek	`https://api.deepseek.com/v1`	`deepseek-coder`	https://platform.deepseek.com/

配置示例(以智谱GLM为例):

export ANTHROPIC_BASE_URL=https://open.bigmodel.cn/api/anthropic
export ANTHROPIC_AUTH_TOKEN=your_glm_api_key
export ANTHROPIC_MODEL=GLM-4.7

注意: 配置环境变量后需要重启终端或运行 source ~/.bashrc 使配置生效。

方式二:使用自动化助手(仅适用于智谱GLM)

如果选择使用智谱GLM系列模型,还可以使用自动化配置助手:

npx @z_ai/coding-helper

按照交互式提示完成配置:

选择界面语言
设置 Coding 套餐
配置 API 密钥
选择编码工具

这种方式可以自动完成智谱GLM模型的配置,适合不想手动设置环境变量的用户。

国内模型对比

模型	提供商	代码能力	价格	优势	适用场景
GLM-4.7	智谱AI	⭐⭐⭐⭐⭐	中等	中文理解强,有Coding套餐	中文项目为主
Kimi K2	月之暗面	⭐⭐⭐⭐⭐	较低	超长上下文,MoE架构	大型项目重构
Qwen-Coder-Plus	阿里云	⭐⭐⭐⭐⭐	低	开源,性能优秀	Python/JS项目
DeepSeek-Coder	深度求索	⭐⭐⭐⭐	极低	价格优势	预算有限的场景

2.4 启动 Claude Code

基本启动:

claude

危险模式(跳过权限确认):

claude --dangerously-skip-permissions

Headless 模式(非交互式):

git diff | claude -p "解释这些更改"

三、核心概念详解

了解了 Claude Code 的安装配置后，深入了解一下它的一些核心概念。这些概念是充分发挥 Claude Code 能力的基础。

3.1 Skills(技能包)

什么是 Skills?

Skills 是预封装的工作流,就像游戏中的”技能包”,用完即走,不占用上下文。它是别人已经编写好的、可直接使用的功能模块。

官方 Skills 库: https://github.com/anthropics/skills (32k+ Stars)

Skills 的类型

类型	说明	示例
User Skills	用户自定义技能,存储在本地	个人工作流自动化
Plugin Skills	插件提供的技能,随插件安装	frontend-design
Built-in Skills	Claude Code 内置技能	commit, review-pr

常用官方 Skills

# 前端设计技能
npx skills-installer install @anthropics/claude-code/frontend-design --client claude-code

# 文档协同技能
npx skills-installer install @anthropics/claude-code/doc-coauthoring --client claude-code

# Canvas 设计技能
npx skills-installer install @anthropics/claude-code/canvas-design --client claude-code

# PDF 处理技能
npx skills-installer install @anthropics/claude-code/pdf --client claude-code

# 算法艺术生成
npx skills-installer install @anthropics/claude-code/algorithmic-art --client claude-code

如何使用 Skills

查看可用 Skills:

claude /skills

调用 Skill:

# 在 Claude Code 对话中
使用 frontend-design skill 优化 https://example.com

使用 pdf skill 提取 report.pdf 中的表格数据

如何编写自己的 Skills

Skill 目录结构:

my-skill/
├── skill.json          # Skill 元数据
├── skill.md            # Skill 文档
├── api/                # API 定义(可选)
└── tools/              # 自定义工具(可选)

skill.json 示例:

{
  "name": "my-custom-skill",
  "description": "我的自定义技能",
  "version": "1.0.0",
  "author": "Your Name",
  "categories": ["automation"],
  "license": "MIT",
  "skill": {
    "file": "skill.md",
    "description": "这个技能用于..."
  }
}

skill.md 示例:

# My Custom Skill

这个技能帮助用户快速完成[特定任务]。

## 使用场景

- 场景1:描述...
- 场景2:描述...

## 使用方式

用户只需要告诉你要完成什么,这个技能就会自动:

1. 分析需求
2. 执行步骤
3. 返回结果

## 注意事项

- 注意事项1
- 注意事项2

安装本地 Skill:

# 将技能复制到 Claude Code 配置目录
cp -r my-skill ~/.claude/skills/

# 或使用安装命令
npx skills-installer install ./my-skill --client claude-code

3.2 Hooks(钩子)

什么是 Hooks?

Hooks 是在特定事件触发时自动执行的脚本,用于自定义工作流、拦截危险操作、自动格式化代码等。

核心价值:

事件触发

Hook 拦截

执行自定义脚本

返回结果

继续/阻止操作

Hook 事件类型

事件类型	触发时机	典型用途
user-prompt-submit	用户提交提示词前	验证、修改提示词
tool-use	工具使用前	权限检查、参数验证
after-tool-use	工具使用后	日志记录、结果处理
permission-request	权限请求时	拦截危险操作
notification	通知时	发送告警、更新状态

Hook 配置方式

方式一:通过 /hooks 命令

# 在 Claude Code 中
/hooks

方式二:通过配置文件

在 ~/.claude/settings.json 或项目 .claude/settings.json 中配置:

{
  "hooks": {
    "user-prompt-submit-hook": {
      "command": "npm run validate-prompt",
      "enabled": true
    },
    "tool-use-hook": {
      "command": "~/.claude/hooks/check-permission.sh",
      "enabled": true,
      "blocking": true
    },
    "after-tool-use-hook": {
      "command": "echo 'Tool used: {{toolName}}' >> ~/.claude/hooks.log",
      "enabled": true
    }
  }
}

Hook 实战示例

拦截危险命令:

#!/bin/bash
# ~/.claude/hooks/check-dangerous.sh

# 读取工具调用信息
TOOL_NAME=$(jq -r '.toolName' <<< "$CLAUDE_HOOK_INPUT")

# 危险操作列表
DANGEROUS_TOOLS=("rm" "delete" "format" "shutdown")

if [[ " ${DANGEROUS_TOOLS[@]} " =~ " ${TOOL_NAME} " ]]; then
  echo "⚠️  警告:即将执行危险操作 - $TOOL_NAME"
  echo "请确认是否继续? (yes/no)"
  read -r confirmation
  if [[ "$confirmation" != "yes" ]]; then
    exit 1  # 阻止操作
  fi
fi

自动格式化代码:

{
  "hooks": {
    "after-write-hook": {
      "command": "if [[ {{filePath}} == *.js ]]; then prettier --write {{filePath}}; fi",
      "enabled": true,
      "blocking": false
    }
  }
}

发送通知:

{
  "hooks": {
    "task-complete-hook": {
      "command": "notify-send 'Claude Code' '任务已完成'",
      "enabled": true
    }
  }
}

自动格式化代码(PostToolUse Hook):

来自创始人的实战经验 – 彻底消灭 CI 里的格式报错:

{
  "hooks": {
    "after-tool-use-hook": {
      "command": "bun run format || true",
      "enabled": true,
      "blocking": false
    }
  }
}

工作原理:

每次 Claude 使用 Write 或 Edit 工具后自动触发
运行格式化命令(这里是 bun run format)
|| true 确保即使格式化失败也不阻塞流程
虽然 Claude 已经写得很规范,但这最后 10% 的自动化处理能彻底解决格式问题

效果:

✅ CI 中不再有格式报错
✅ 代码风格始终一致
✅ 无需手动运行格式化
✅ Git diff 更清晰

3.3 Plugins(插件)

什么是 Plugins?

Plugins 是打包在一起的扩展集合,可以包含:

5 个 Skills
10 个斜杠命令
3 个 MCP 服务器配置
2 个 SubAgent 定义
若干 Hooks

Plugins vs Skills:

特性	Skills	Plugins
复杂度	简单工作流	完整功能套件
内容	单一技能	多种资源的集合
安装	独立安装	一次性安装多个资源
适用场景	单一任务	完整解决方案

Plugin 安装与使用

哪里获取已有 Plugins?

官方插件市场:

来源	地址	说明
Anthropic Skills	https://github.com/anthropics/skills	官方Skills库,包含多个插件
Claude Code Marketplace	https://claudecodemarketplaces.com	插件市场目录
Awesome Claude Code	https://awesomeclaude.ai/plugins	社区插件精选

添加插件市场:

# 添加官方Anthropic插件市场
claude /plugin marketplace add anthropics/skills

# 添加本地插件市场
claude /plugin marketplace add ~/my-marketplace

# 浏览可用插件
claude /plugin
# 选择 "Browse Plugins" 查看完整列表

常用官方插件:

# 文档处理插件套件
claude /plugin marketplace add anthropics/skills
claude /plugin install document-skills

# 前端开发插件
claude /plugin install frontend-design

# Git工作流插件
claude /plugin install git-workflow

安装 Plugin

从市场安装:

claude plugin install <plugin-name>

从本地安装:

# 安装本地插件
claude plugin install ./my-plugin

# 或使用完整路径
claude plugin install /path/to/my-plugin

从GitHub安装:

# 直接从GitHub仓库安装
claude plugin install github:user/repo

查看 Plugins

查看已安装 Plugins:

claude /plugin

浏览可用插件:

# 在Claude Code中输入
/plugin
# 选择 "Browse Plugins"

卸载 Plugin:

claude plugin uninstall <plugin-name>

创建自定义 Plugin:

my-plugin/
├── plugin.json           # Plugin 配置
├── skills/              # Skills 目录
│   ├── skill1/
│   └── skill2/
├── commands/            # 自定义斜杠命令
│   └── my-command.md
├── mcp/                 # MCP 配置
│   └── mcp-config.json
├── agents/              # SubAgent 定义
│   └── agent1.json
└── hooks/               # Hook 脚本
    └── hook1.sh

plugin.json 示例:

{
  "name": "my-plugin",
  "version": "1.0.0",
  "description": "我的自定义插件",
  "author": "Your Name",
  "skills": [
    "skills/skill1",
    "skills/skill2"
  ],
  "commands": [
    {
      "name": "/my-command",
      "description": "我的自定义命令",
      "file": "commands/my-command.md"
    }
  ],
  "mcpServers": [
    {
      "name": "my-mcp",
      "config": "mcp/mcp-config.json"
    }
  ],
  "agents": [
    {
      "name": "my-agent",
      "config": "agents/agent1.json"
    }
  ]
}

3.4 MCP Servers(模型上下文协议服务器)

什么是 MCP?

MCP (Model Context Protocol) 是 AI 的扩展接口标准,通过添加 MCP 服务器可以扩展 Claude Code 获取外部工具、资源、服务的能力。

核心概念:

Claude Code

MCP Client

MCP Server 1

MCP Server 2

MCP Server N

GitHub API

Database

Browser

常用 MCP 服务器

MCP Server	功能	Star 数
chrome-devtools-mcp	浏览器自动化,26个工具	18.5k
github-mcp	GitHub API 集成	10k+
postgres-mcp	PostgreSQL 数据库操作	5k+
filesystem-mcp	增强文件系统操作	3k+
web-search-mcp	网络搜索功能	2k+

MCP 安装方式

方式一:命令行安装

claude mcp add chrome-devtools npx chrome-devtools-mcp@latest

方式二:配置文件安装

编辑 ~/.claude/mcp.json:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["chrome-devtools-mcp@latest"],
      "disabled": false
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your_github_token_here"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/db"
      }
    }
  }
}

验证安装:

# 在 Claude Code 中
/mcp

# 或通过命令行
claude mcp list
claude mcp test chrome-devtools

Chrome DevTools MCP 实战

安装:

claude mcp add chrome-devtools npx chrome-devtools-mcp@latest

使用示例:

# 在 Claude Code 中
用Chrome浏览器打开 https://example.com,然后通过 chrome devtools mcp 完成以下任务:
1. 截取页面截图
2. 提取所有链接
3. 分析页面结构
4. 获取页面性能数据

26个内置工具包括:

chrome_navigate: 导航到指定 URL
chrome_screenshot: 截取页面截图
chrome_click: 点击元素
chrome_fill: 填写表单
chrome_select: 选择元素
chrome_evaluate: 执行 JavaScript
等等…

3.5 Subagents(子代理)

什么是 Subagents?

Subagents 是可以并行处理任务的独立 AI 代理,每个子代理拥有独立的 200K 上下文窗口,可以分配不同任务以提高效率。

核心理念： 把常用工作流看作自动化运行的”子智能体”,就像圣诞老人分派任务给精灵一样,每个子智能体专注于特定领域。

核心优势:

主代理 Claude Code

子代理1: 代码审查

子代理2: 测试编写

子代理3: 文档生成

子代理4: 性能优化

并行处理

结果汇总

Subagent 配置

方式一:通过 /agents 命令

claude /agents

方式二:配置文件

在 ~/.claude/agents.json 或项目 .claude/agents.json 中配置:

{
  "agents": {
    "code-reviewer": {
      "description": "专门负责代码审查的子代理",
      "model": "claude-opus-4-5",
      "instructions": "你是一个专业的代码审查专家,专注于检查代码质量、安全漏洞和性能问题。",
      "tools": ["read", "search", "git"],
      "permissions": {
        "allowWrite": false
      }
    },
    "test-writer": {
      "description": "专门负责编写测试的子代理",
      "model": "claude-sonnet-4-5",
      "instructions": "你是一个测试工程师,专注于编写全面的单元测试和集成测试。",
      "tools": ["read", "write", "bash"]
    },
    "doc-generator": {
      "description": "专门负责生成文档的子代理",
      "model": "claude-sonnet-4-5",
      "instructions": "你是一个技术文档专家,专注于生成清晰、准确的技术文档。",
      "tools": ["read", "write"]
    }
  }
}

Subagent 使用示例

场景:完成一个功能开发

# 主任务
我需要完成用户认证功能,请帮我:

1. 使用 code-reviewer agent 审查现有认证代码
2. 使用 test-writer agent 编写测试用例
3. 使用 doc-generator agent 更新 API 文档

这三个任务并行执行

Claude Code 会自动:

创建三个独立的子代理
分配各自的上下文(200K × 3)
并行执行任务
汇总结果返回

实战子代理案例

来自 Claude Code 创始人 Boris Cherny 的实际使用案例:

code-simplifier:

# .claude/agents/code-simplifier.md

你是一个代码精简专家。在 Claude 完成工作后,你的任务是:
1. 分析代码的复杂度和可读性
2. 识别可以简化的逻辑
3. 提供优化建议但保持功能不变
4. 优先考虑性能和可维护性

verify-app:

# .claude/agents/verify-app.md

你是一个端到端测试专家。你的任务是验证应用功能:
1. 运行完整的测试套件
2. 检查所有关键路径
3. 验证边界情况
4. 确保用户体验"感觉对劲"
5. 如果发现问题,提供详细的修复步骤

使用方式:

# 在 Claude Code 中
使用 code-simplifier agent 优化刚才写的代码

使用 verify-app agent 验证应用是否正常工作

3.6 CLAUDE.md(项目记忆文件)

什么是 CLAUDE.md?

CLAUDE.md 是 Claude Code 的”项目记忆文件”,记录项目结构、构建命令、代码规范、架构决策等信息,让 Claude Code 快速理解项目上下文。

CLAUDE.md 的作用

作用	说明
📚 项目知识库	记录项目架构、技术栈、依赖关系
🚀 快速启动	自动读取,无需重复解释项目背景
🤝 团队协作	共享项目规范,确保团队理解一致
🔄 持续迭代	随项目演进自动更新

CLAUDE.md 最佳位置

项目根目录_CLAUDE.md

src_.claude_CLAUDE.md

.claude_rules_auth.md

home_.claude_CLAUDE.md

全局项目配置

模块级配置

特定规则

用户级配置

优先级: 特定规则 > 模块配置 > 项目配置 > 用户配置

CLAUDE.md 示例

完整示例:

# 项目名称: E-Commerce Platform

## 项目概述
这是一个基于 Node.js + React 的电商平台,支持商品管理、订单处理、支付集成等功能。

## 技术栈
- **前端:** React 18, TypeScript, Tailwind CSS, Redux Toolkit
- **后端:** Node.js 20, Express, TypeScript
- **数据库:** PostgreSQL 15, Redis 7
- **认证:** JWT, OAuth 2.0
- **测试:** Jest, Playwright
- **部署:** Docker, Kubernetes

## 项目结构
\`\`\`
src/
├── frontend/          # React 前端
│   ├── components/    # 可复用组件
│   ├── pages/         # 页面组件
│   ├── store/         # Redux store
│   └── utils/         # 工具函数
├── backend/           # Node.js 后端
│   ├── controllers/   # 控制器
│   ├── services/      # 业务逻辑
│   ├── models/        # 数据模型
│   └── routes/        # API 路由
└── shared/            # 共享代码
    └── types/         # TypeScript 类型定义
\`\`\`

## 常用命令

### 开发环境
\`\`\`bash
# 安装依赖
npm install

# 启动前端开发服务器
npm run dev:frontend

# 启动后端开发服务器
npm run dev:backend

# 同时启动前后端
npm run dev
\`\`\`

### 构建与部署
\`\`\`bash
# 构建前端
npm run build:frontend

# 构建后端
npm run build:backend

# 构建所有
npm run build

# Docker 构建
docker-compose build
docker-compose up
\`\`\`

### 测试
\`\`\`bash
# 运行所有测试
npm test

# 前端单元测试
npm run test:frontend

# 后端单元测试
npm run test:backend

# E2E 测试
npm run test:e2e

# 测试覆盖率
npm run test:coverage
\`\`\`

### 代码质量
\`\`\`bash
# 代码格式化
npm run format

# 代码检查
npm run lint

# 类型检查
npm run type-check
\`\`\`

## 代码规范

### 命名规范
- **文件名:** kebab-case (user-profile.ts)
- **组件名:** PascalCase (UserProfile)
- **函数/变量:** camelCase (getUserProfile)
- **常量:** UPPER_SNAKE_CASE (API_BASE_URL)
- **类型/接口:** PascalCase (UserProfile)

### Git 提交规范
遵循 Conventional Commits:
- \`feat: 新功能\`
- \`fix: 修复 bug\`
- \`docs: 文档更新\`
- \`style: 代码格式调整\`
- \`refactor: 代码重构\`
- \`test: 测试相关\`
- \`chore: 构建/工具链更新\`

### 代码审查清单
- [ ] 代码符合项目命名规范
- [ ] 添加了必要的注释
- [ ] 更新了相关文档
- [ ] 编写了/更新了测试
- [ ] 通过了所有测试
- [ ] 通过了 lint 检查
- [ ] 没有引入安全漏洞

## 架构决策

### ADR-001: 选择 TypeScript 而非 JavaScript
**日期:** 2024-01-15
**状态:** 已接受
**理由:**
- 类型安全减少运行时错误
- 更好的 IDE 支持
- 代码可维护性更高

### ADR-002: 采用微服务架构
**日期:** 2024-02-20
**状态:** 已接受
**理由:**
- 便于团队并行开发
- 独立部署和扩展
- 技术栈灵活性

## 环境变量

### 必需变量
\`\`\`bash
DATABASE_URL=postgresql://...
REDIS_URL=redis://...
JWT_SECRET=your-secret-key
API_BASE_URL=https://api.example.com
\`\`\`

### 可选变量
\`\`\`bash
LOG_LEVEL=info
NODE_ENV=development
PORT=3000
\`\`\`

## 常见问题

### Q: 如何添加新的 API 端点?
A:
1. 在 \`backend/routes/\` 创建路由文件
2. 在 \`backend/controllers/\` 创建控制器
3. 在 \`backend/services/\` 实现业务逻辑
4. 添加测试用例
5. 更新 API 文档

### Q: 如何调试前端状态管理问题?
A:
1. 使用 Redux DevTools 浏览器扩展
2. 在 \`src/frontend/store/\` 添加日志
3. 检查 action 和 reducer 逻辑

## 重要注意事项

1. **安全:** 永远不要在代码中硬编码密钥或敏感信息
2. **性能:** 大数据查询必须使用分页
3. **测试:** 所有新功能必须包含测试
4. **文档:** API 变更必须更新文档
5. **兼容性:** 确保向后兼容,使用版本控制

## 相关资源
- [项目 Wiki](https://wiki.example.com)
- [API 文档](https://docs.example.com)
- [设计规范](https://design.example.com)

生成 CLAUDE.md 的方式

方式一:使用 /init 命令

# 在项目根目录
claude /init

Claude Code 会自动扫描项目并生成初始 CLAUDE.md,包含:

构建和测试命令
目录结构说明
代码规范和架构决策
技术栈信息

方式二:手动创建

# 创建基础文件
touch CLAUDE.md

# 让 Claude Code 帮助生成
claude "请根据当前项目结构生成 CLAUDE.md 文件"

方式三:模块化规则

# 在 .claude/rules/ 目录创建多个规则文件
.claude/rules/
├── auth.md          # 认证相关规则
├── database.md      # 数据库相关规则
├── api.md           # API 设计规范
└── testing.md       # 测试规范

方式四:Memory Updates – 动态更新记忆

# 直接告诉 Claude 更新知识
Update CLAUDE.md: always use bun instead of npm
Update CLAUDE.md: 不要使用 enum,改用 string union

# Claude 会自动把新知识写入记忆文件,无需手动编辑

CLAUDE.md 的 AI 进化机制

来自 Claude Code 创始人团队的实战经验:

核心理念: 让 Claude 在 Code Review 中自我迭代,越用越聪明

实战流程:

在 PR 中发现问题

# 在 GitHub PR 评论中
@claude 这里的代码使用了 enum,但我们项目规范要求使用 string union,请修复

让 Claude 记住教训

# 在 PR 中直接告诉 Claude
@claude 请把这次的教训写入 CLAUDE.md:不要使用 enum,改用 string union

Claude 自动更新

# Claude 会在 CLAUDE.md 中添加
## 代码规范更新 (2026-01-03)

### Enum vs String Union
- ❌ 不要使用 enum
- ✅ 改用 string union
- 理由:更好的类型推断和 Tree-shaking

团队共同维护

# 将 CLAUDE.md 签入 Git
git add CLAUDE.md
git commit -m "docs: 更新 CLAUDE.md 规范"

# 整个团队共享这份"行为准则"

价值体现:

🧠 集体智慧: 每个团队成员的反馈都让 AI 更聪明
🔄 持续进化: Claude 不会重复犯同样的错误
📚 知识沉淀: 项目规范自动文档化
🤝 团队协作: 统一的 AI 助手理解团队偏好

实际案例:

# CLAUDE.md - 实际演进示例

## 初始版本 (第1周)
- 使用 TypeScript
- 测试覆盖率 > 80%

## 第1次更新 (第2周 - PR反馈)
+ 永远使用 bun 而不是 npm
+ 理由:启动速度快 10 倍

## 第2次更新 (第3周 - PR反馈)
+ 不要使用 enum,改用 string union
+ 理由:更好的类型推断

## 第3次更新 (第4周 - PR反馈)
+ 所有 API 必须添加错误处理
+ 使用 try-catch 包装所有 async 函数

四、高级功能

实际上CC还有一些高级功能，这些功能将帮助更高效地完成复杂任务。

4.1 Plan 模式(规划模式)

什么是 Plan 模式?

Plan 模式是一种”先规划、后执行”的工作模式,Claude 会先分析项目架构、依赖关系并起草实现方案,确认后才开始编写代码。

Anthropic 开发者关系负责人 Ado Kukic 有 90% 的时间都在使用这个模式。

核心价值: 在这个模式下,Claude 会阅读代码、分析架构、起草计划,但绝不修改代码。直到你批准计划,它才会动手。你是架构师,它是执行者。

核心价值:

是

否

接收任务

分析项目

探索代码库

设计方案

用户确认?

执行实现

调整方案

完成任务

进入 Plan 模式

快捷键:

# 按两次 Shift+Tab
Shift+Tab, Shift+Tab

命令方式:

/plan

Plan 模式工作流程

1. 探索阶段

读取相关文件
分析代码结构
理解依赖关系

2. 规划阶段

设计实现方案
列出具体步骤
识别潜在风险

3. 确认阶段

展示完整计划
等待用户反馈
根据反馈调整

4. 执行阶段

按计划实施
实时反馈进度
处理异常情况

Plan 模式最佳实践

适合场景:

✅ 复杂功能开发(多文件、多步骤)
✅ 架构重构
✅ 性能优化
✅ 代码迁移
✅ 不熟悉的项目

不适合场景:

❌ 简单 bug 修复
❌ 单行代码修改
❌ 文档查询
❌ 快速原型验证

使用技巧:

# 启用 Plan 模式
Shift+Tab × 2

# 明确任务需求
请帮我实现用户认证功能,包括:
1. 用户注册
2. 用户登录
3. JWT token 验证
4. 密码加密存储

# Claude 会先探索并规划:
# Plan: 实现用户认证功能
#
# 1. 分析现有代码结构
# 2. 设计认证流程
# 3. 创建数据模型
# 4. 实现 API 端点
# 5. 添加中间件
# 6. 编写测试
#
# 确认后开始执行? (yes/no)

# 确认后开始实施
yes

4.2 Sandbox 模式(沙箱模式)

什么是 Sandbox 模式?

Sandbox 模式通过定义允许的操作范围,拦截危险操作,提高安全性。

核心机制:

允许

拒绝

需要确认

允许

拒绝

操作请求

Sandbox 规则检查

执行操作

拦截并警告

询问用户

配置 Sandbox 模式

方式一:通过 /permissions 命令

claude /permissions

方式二:配置文件

编辑 ~/.claude/settings.json:

{
  "permissions": {
    "allow": {
      "bash": [
        "npm install",
        "npm test",
        "npm run build",
        "git *",
        "node -v",
        "npm -v"
      ],
      "write": [
        "src/**/*",
        "tests/**/*",
        "*.md"
      ],
      "read": [
        "**/*"
      ]
    },
    "deny": {
      "bash": [
        "rm -rf *",
        "format *",
        "shutdown",
        "reboot"
      ],
      "write": [
        "node_modules/**/*",
        ".git/**/*",
        "/etc/*",
        "/usr/*"
      ]
    }
  }
}

Sandbox 最佳实践

最小权限原则:

{
  "permissions": {
    "allow": {
      "bash": ["npm test", "npm run build"],
      "write": ["src/**/*", "tests/**/*"]
    }
  }
}

特定项目配置:

// .claude/settings.json (项目级)
{
  "permissions": {
    "allow": {
      "bash": [
        "npm run dev:*",
        "npm run test:*",
        "npm run build:*"
      ],
      "write": ["src/**/*", "tests/**/*", "docs/**/*"]
    },
    "deny": {
      "write": ["dist/**/*", "build/**/*"]
    }
  }
}

4.3 Headless 模式(无头模式)

什么是 Headless 模式?

Headless 模式是非交互式运行方式,输出结果直接流向标准输出,可集成到 Shell 脚本或 CI/CD 流程中。

使用场景:

场景	示例
🔄 CI/CD 集成	自动化代码审查
📜 脚本自动化	批量处理任务
🔍 快速分析	不需要交互的代码分析
📊 报告生成	自动生成文档

Headless 模式使用

基本用法:

# 从管道输入
git diff | claude -p "解释这些更改"

# 从文件输入
cat file.txt | claude -p "总结这个文件"

# 直接指定
claude -p "检查代码质量" < src/main.js

CI/CD 集成示例:

# .github/workflows/claude-review.yml
name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Run Code Review
        run: |
          git diff origin/main...HEAD | claude -p "审查这个 PR 的代码变更" > review.txt

      - name: Comment PR
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.txt', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: review
            });

脚本自动化示例:

#!/bin/bash
# batch-process.sh

for file in src/**/*.js; do
  echo "Processing $file..."

  # 使用 Claude Code 分析代码
  claude -p "检查文件 $file 的代码质量,包括:
  1. 潜在的 bug
  2. 性能问题
  3. 安全漏洞
  4. 代码规范违规" < "$file" > "reports/$(basename $file).md"

  echo "✓ Completed $file"
done

echo "All files processed!"

4.4 Vim 模式

启用 Vim 模式

/vim

Vim 常用快捷键

快捷键	功能
`h`	左移光标
`j`	下移光标
`k`	上移光标
`l`	右移光标
`ciw`	修改单词
`dd`	删除行
`yy`	复制行
`p`	粘贴
`u`	撤销
`Ctrl+r`	重做

4.5 Slash Commands(自定义命令)

什么是 Slash Commands?

Slash Commands 是将高频工作流封装成可复用的斜杠命令,将复杂的”人机对话”变成简单的”命令行指令”。

来自 Claude Code 创始人的实战经验:为了避免重复输入相同的 Prompt,他将高频工作流封装成了 Slash Commands。

创建自定义命令

方式一:通过 /commands 命令

claude /commands
# 选择 "Create new command"

方式二:手动创建

在 .claude/commands/ 目录创建 Markdown 文件:

# .claude/commands/
├── commit-push-pr.md
├── daily-standup.md
└── deploy-staging.md

示例1:自动提交并创建 PR

# .claude/commands/commit-push-pr.md

你是一个发布助手。请执行以下步骤:

1. 检查 Git 状态
   !git status

2. 运行测试套件
   !npm test

3. 如果测试通过:
   - 添加所有更改
   - 生成符合 Conventional Commits 的提交消息
   - 推送到远程
   - 创建 Pull Request

4. 如果测试失败:
   - 分析失败原因
   - 提供修复建议

使用:

# 直接输入命令
/commit-push-pr

# Claude 会自动执行整个流程

示例2:生成每日站会日报

# .claude/commands/daily-standup.md

请生成今日站会报告,包括:

1. 昨天完成了什么
   !git log --since="yesterday" --oneline

2. 今天计划做什么
   (读取 CLAUDE.md 中的当前任务)

3. 遇到的阻碍
   (读取最近的 TODO 注释)

请以清晰的 Markdown 格式输出。

使用:

/daily-standup

实战案例

完整的部署工作流:

# .claude/commands/deploy-production.md

你是一个部署专家。请按以下步骤执行生产环境部署:

## 前置检查
1. 确认当前分支
   !git branch --show-current

2. 检查是否有未提交的更改
   !git status

3. 运行完整测试套件
   !npm run test:all

## 构建阶段
4. 构建生产版本
   !npm run build

5. 运行构建产物测试
   !npm run test:build

## 部署阶段
6. 打包部署
   !npm run deploy:staging

7. 验证部署
   !curl https://staging.example.com/health

8. 运行冒烟测试
   !npm run test:smoke

## 生产部署
9. 合并到主分支
   !git checkout main
   !git merge production

10. 推送到远程
    !git push origin main

11. 监控部署
    (等待 CI/CD 完成)

12. 验证生产环境
    !curl https://api.example.com/health

## 回滚准备
如果部署失败,立即执行:
!git revert HEAD
!git push origin main

## 部署后检查
13. 检查错误日志
    (使用 Sentry MCP 查询最新错误)

14. 发送团队通知
    (使用 Slack MCP 发送部署成功通知)

请每完成一步都报告进度,遇到问题立即暂停并询问。

价值:

✅ 一键执行复杂流程
✅ 减少人为错误
✅ 团队共享最佳实践
✅ 可以签入 Git 版本控制

4.6 Extended Thinking(扩展思考模式)

ultrathink 深度思考模式

当你需要设计复杂的缓存层或重构架构时,在提示词中加上 ultrathink。

# 标准模式
设计一个 Redis 缓存层

# ultrathink 模式
ultrathink: 设计一个高可用的 Redis 缓存层,考虑:
- 缓存穿透、缓存击穿、缓存雪崩
- 分布式锁
- 缓存更新策略
- 降级方案

效果:

Claude 会分配高达 32k 的 Token 进行内部推理
虽然反应慢一点,但逻辑准确率大幅提升
适合架构设计、复杂重构等关键任务

Extended Thinking API

通过 API 调用时,开启 Extended Thinking 可以看到 Claude 的逐步推理过程(Thinking Blocks)。

价值:

透明化思考过程
便于调试复杂逻辑
理解 Claude 的决策路径
教学和学习工具

五、实用技巧与快捷操作

了解了 Claude Code 的高级功能后，分享一些实用的技巧和快捷操作，可以更高效地使用这个工具。

5.1 基础操作技巧

项目初始化(/init)

# 自动生成 CLAUDE.md
/init

# 或手动指定
claude /init "这是一个 Node.js + React 项目"

快速引用上下文(@提及)

# 引用单个文件
@src/auth.ts

# 引用整个目录
@src/components/

# 引用多个文件
@src/auth.ts @src/user.ts @src/database.ts

# 引用 MCP 服务器
@mcp:github

# 模糊匹配
@auth  # 自动匹配 auth.ts, auth.controller.ts 等

即时执行 Bash 命令(!前缀)

# 查看状态
!git status

# 运行测试
!npm test

# 查看进程
!ps aux | grep node

# 组合使用
!git diff && echo "=== Changes Summary ==="

回退操作(双击 ESC)

ESC ESC

选项:

仅回退对话
仅回退代码
同时回退对话和代码

注意: 已执行的 Bash 命令无法回退

5.2 效率提升技巧

反向搜索历史提示词(Ctrl+R)

Ctrl+R    # 开始搜索
Ctrl+R    # 循环匹配项
Enter     # 运行
Tab       # 编辑后运行

提示词暂存(Ctrl+S)

Ctrl+S    # 暂存当前提示词
# ... 处理其他事务 ...
# 恢复暂存内容继续工作

类似 Git stash,但用于提示词

智能提示补全(Prompt Suggestions)

Claude 甚至能预测你接下来想问什么:

# 当你看到灰色的建议文字时
Tab       # 接受建议并编辑
Enter     # 直接运行建议

价值:

减少打字量
发现隐藏功能
学习最佳实践

会话管理高级技巧

Continue & Resume – 无缝续关

# 终端意外关闭?电脑没电了?
claude --continue              # 瞬间恢复上一次对话
claude --resume                # 显示历史会话列表供选择

# 上下文完美保留,工作流永不丢失

Named Sessions – 会话命名

# 像管理 Git 分支一样管理会话
/rename api-migration          # 给当前会话命名
/resume api-migration          # 按名称恢复会话

# 用途:为不同任务创建独立会话
/rename feature-auth
/rename bugfix-login
/resume feature-auth

Claude Code Remote – 跨设备传送

# 在网页版 claude.ai/code 上开始任务
# 回家后用终端继续开发

claude --teleport session_id   # 把云端会话"拉"到本地

# 利用"传送(Teleport)"功能
# 在终端和网页间同步上下文
# 甚至早上起床和白天休息时,用手机版 Claude App 查看进度

自定义状态栏(/statusline)

/statusline

可显示信息:

Git 分支
当前模型
Token 用量
上下文占比
任务进度

配置示例:

{
  "statusline": {
    "segments": [
      "git.branch",
      "model.name",
      "context.usage",
      "token.cost"
    ],
    "refreshInterval": 1000
  }
}

可视化上下文(/context)

/context

显示:

当前 token 使用情况
上下文占用百分比
各文件占用大小
建议优化方向

使用统计与监控

查看使用习惯:

/stats     # 查看你的使用习惯、最爱用的模型、连续使用天数等
/usage     # 查看当前的费率限制和使用进度

价值:

了解自己的使用模式
监控费用消耗
晒 Claude Code 统计(现在比晒 GitHub 提交记录更流行)

5.3 文件夹管理技巧

工作空间隔离

最佳实践:

# 为每个任务创建独立文件夹
project-1/
project-2/
task-a/
task-b/

快速启动:

# Windows: 在地址栏输入 cmd
# macOS: 在右键菜单选择"服务 > 新建终端位于文件夹"

# 然后启动 Claude Code
claude

拖拽文件

支持操作:

拖拽单个文件
拖拽整个文件夹
拖拽多个文件

使用场景:

# 拖拽文件后直接描述任务
[拖入 auth.ts]
这个认证模块有安全问题,请帮我审查并修复

5.4 粘贴技巧

文本粘贴

操作	方式
在 CC 中粘贴文本	鼠标右键 → 粘贴
在普通命令行粘贴	Ctrl+V
在 CC 中粘贴图片	复制图片 → Alt+V (Windows) / Ctrl+V (macOS)

注意:

CC 中不能用 Ctrl+V 粘贴文本
CC 中不能用 Ctrl+A 全选
图片必须在打开状态复制,预览状态无法粘贴

5.5 常用斜杠命令速查

命令	功能	使用频率
`/clear`	清空对话历史	⭐⭐⭐⭐⭐
`/compact`	清空对话但保留摘要	⭐⭐⭐⭐⭐
`/context`	可视化上下文使用	⭐⭐⭐⭐⭐
`/model`	切换模型	⭐⭐⭐⭐
`/cost`	显示费用统计	⭐⭐⭐⭐
`/export`	导出对话	⭐⭐⭐⭐
`/add-dir`	添加工作目录	⭐⭐⭐⭐
`/status`	查看系统状态	⭐⭐⭐
`/mcp`	管理 MCP 服务器	⭐⭐⭐
`/skills`	列出可用技能	⭐⭐⭐
`/hooks`	管理钩子	⭐⭐
`/agents`	管理子代理	⭐⭐
`/vim`	切换 Vim 模式	⭐⭐
`/theme`	更换主题	⭐
`/doctor`	诊断环境	⭐⭐⭐⭐

六、最佳实践

继续。提供并建立一些最佳实践以提升团队协作和开发效率。

6.1 项目组织最佳实践

目录结构规范

project/
├── .claude/                    # Claude Code 配置
│   ├── settings.json           # 项目级设置
│   ├── agents.json             # 子代理配置
│   ├── rules/                  # 模块化规则
│   │   ├── auth.md
│   │   ├── database.md
│   │   └── api.md
│   └── mcp.json                # MCP 配置
├── src/                        # 源代码
├── tests/                      # 测试代码
├── docs/                       # 文档
├── CLAUDE.md                   # 项目主配置
└── README.md                   # 项目说明

CLAUDE.md 层级配置

用户级_home_claude_CLAUDE_md

项目级_CLAUDE_md

模块级_src_claude_CLAUDE_md

特定规则_claude_rules

合并规则

最终配置

6.2 工作流最佳实践

探索-规划-编码-提交工作流

这是一个完整的开发工作流程,需要配合特定的Skills和MCP使用。

前置准备 – 安装必要工具:

# 1. 安装代码分析MCP(可选,用于深度分析)
claude mcp add github npx -y @modelcontextprotocol/server-github

# 2. 安装commit skill(用于生成规范的commit消息)
npx skills-installer install @anthropics/claude-code/commit --client claude-code

# 3. 安装Chrome DevTools MCP(用于浏览器测试,可选)
claude mcp add chrome-devtools npx chrome-devtools-mcp@latest

详细工作流程:

第1步:探索阶段 – 理解项目

# 启动Claude Code
claude

# 探索项目架构
请帮我分析这个项目的架构,重点关注:
1. 整体项目结构
2. 认证模块的实现
3. 依赖关系
4. 技术栈

# 使用@引用特定目录
@src/

# 如果有GitHub仓库,使用GitHub MCP
请使用github MCP查看最近的commit历史和issue

第2步:规划阶段 – 使用Plan模式

# 进入Plan模式(按两次Shift+Tab)
Shift+Tab, Shift+Tab

# 或使用命令
/plan

# 明确任务需求
我需要添加 OAuth2.0 认证支持,请规划实现方案,包括:
1. 需要创建哪些新文件
2. 需要修改哪些现有文件
3. 需要安装哪些依赖
4. 实现步骤顺序
5. 潜在的风险点

# Claude会生成详细计划,等待你的确认
# Plan: 添加OAuth2.0认证支持
#
# 1. 分析现有认证代码
# 2. 设计OAuth2.0流程
# 3. 创建OAuth控制器
# 4. 实现token生成和验证
# 5. 添加测试用例
# 6. 更新文档
#
# 预计需要修改的文件:
# - src/auth/oauth.controller.ts (新建)
# - src/auth/auth.service.ts (修改)
# - src/config/oauth.config.ts (新建)
#
# 确认后开始执行? (yes/no)

# 确认后开始实施
yes

第3步:编码阶段 – 实施计划

# 让Claude按照计划实施
按照上面的计划开始实施

# 如果遇到问题,可以要求暂停
暂停,让我先检查一下这一步

# 继续实施
继续下一步

# 运行测试
!npm test

# 修复失败的测试
测试失败了,请帮我修复

第4步:提交阶段 – 使用commit skill

# 使用commit skill生成规范的commit消息
使用commit skill为这些更改创建一个规范的commit消息

# Claude会分析变更并生成commit
# commit skill会:
# 1. 分析git diff
# 2. 生成符合Conventional Commits的消息
# 3. 自动创建commit

# 或手动指导commit
请帮我创建git commit,包含这些更改
commit消息格式: feat(auth): 添加OAuth2.0认证支持

测试驱动开发(TDD)工作流

前置准备 – 安装测试相关工具:

# 1. 安装测试编写skill(可选)
npx skills-installer install @anthropics/claude-code/test-writer --client claude-code

# 2. 或者配置test-writer子代理(后面详细说明)

TDD工作流程:

# 第1步:先写测试
# 使用test-writer skill或agent
使用test-writer skill为用户登录功能编写测试,包括:
1. 正常登录场景
2. 错误密码场景
3. 用户不存在场景
4. Token验证场景

@src/auth/login.controller.ts

# 第2步:运行测试(预期失败)
!npm test

# 第3步:实现最小可行代码
测试失败了,请实现登录功能使测试通过,只写能通过的代码

# 第4步:重构代码
代码通过了但不够优雅,请重构以提高可读性,但保持测试通过

# 第5步:重复循环
继续添加新功能的测试...

代码审查工作流

前置准备 – 创建和配置代码审查子代理:

方式1:使用 /agents 命令创建

# 在Claude Code中
claude
/agents

# 选择 "Create new agent"
# 按提示配置:
- Name: code-reviewer
- Description: 专门负责代码审查的子代理
- Instructions: 你是一个代码审查专家,专注于检查代码质量、安全漏洞和性能问题
- Tools: read, search, git
- Permissions: 禁止写入(allowWrite: false)

方式2:手动配置文件

# 创建agents配置文件
mkdir -p ~/.claude
cat > ~/.claude/agents.json << 'EOF'
{
  "agents": {
    "code-reviewer": {
      "description": "专门负责代码审查的子代理",
      "model": "claude-sonnet-4-5",
      "instructions": "你是一个专业的代码审查专家。专注于:\n1. 代码质量(Clean Code原则)\n2. 安全漏洞(OWASP Top 10)\n3. 性能问题(算法复杂度、资源使用)\n4. 最佳实践\n\n请以结构化方式输出审查结果。",
      "tools": ["read", "search", "git"],
      "permissions": {
        "allowWrite": false
      }
    },
    "security-reviewer": {
      "description": "专注于安全问题的子代理",
      "model": "claude-sonnet-4-5",
      "instructions": "你是一个安全专家,专注于识别:\n1. SQL注入、XSS、CSRF等漏洞\n2. 敏感信息泄露\n3. 权限控制问题\n4. 依赖安全问题",
      "tools": ["read", "search"],
      "permissions": {
        "allowWrite": false
      }
    },
    "performance-reviewer": {
      "description": "专注于性能问题的子代理",
      "model": "claude-sonnet-4-5",
      "instructions": "你是一个性能优化专家,专注于:\n1. 算法效率\n2. 内存使用\n3. 数据库查询优化\n4. 缓存策略",
      "tools": ["read", "search"],
      "permissions": {
        "allowWrite": false
      }
    }
  }
}
EOF

# 验证配置
claude
/agents
# 应该看到刚创建的三个agent

使用代码审查工作流:

# 第1步:使用子代理并行审查
# 代码质量审查
使用code-reviewer agent审查以下文件的代码质量:
- 是否符合Clean Code原则
- 是否有代码异味
- 是否易于维护

@src/auth.ts @src/user.ts @src/database.ts

# 安全审查(并行)
使用security-reviewer agent审查这些文件的安全问题:
- SQL注入风险
- XSS漏洞
- 敏感信息泄露

@src/auth.ts @src/user.ts @src/database.ts

# 性能审查(并行)
使用performance-reviewer agent审查这些文件的性能问题:
- 算法复杂度
- 数据库查询效率
- 内存使用

@src/auth.ts @src/user.ts @src/database.ts

# 第2步:生成综合审查报告
请综合以上三个agent的审查结果,生成一份详细报告,包括:
- 发现的问题列表
- 每个问题的严重程度(Critical/High/Medium/Low)
- 具体的修复建议
- 修复优先级排序

# 第3步:逐个修复问题
根据审查报告,请帮我修复Critical和High级别的问题:
1. 先修复安全问题
2. 再修复性能问题
3. 最后修复代码质量问题

# 第4步:重新审查
修复完成后,使用code-reviewer agent重新审查修复后的代码

6.3 团队协作最佳实践

共享 CLAUDE.md

场景:团队项目

实施步骤:

在项目根目录创建 CLAUDE.md
团队共同维护
定期更新
版本控制

示例:

# 团队项目规范

## 团队约定
- 代码审查至少 1 人 approve
- 所有 PR 必须通过 CI
- 文档与代码同步更新

## 分工信息
- @alice: 前端负责人
- @bob: 后端负责人
- @charlie: DevOps

## 沟通渠道
- Slack: #team-channel
- JIRA: 项目看板

GitHub 集成

安装 GitHub App:

/install-github-app

使用 PR 评论:

# 在 PR 中
@.claude 请审查这个 PR 的代码变更

# 自动添加问题到 CLAUDE.md
/pr-comments

6.4 性能优化最佳实践

极致的并行处理(Parallelism)

来自 Claude Code 创始人 Boris Cherny 的核心理念:不要让 AI 等你,也不要让你等 AI

1. 终端里的”多线程”操作

# 同时运行 5 个 Claude 实例
# 将终端标签页标记为 1-5

# 配置系统通知(System Notifications)
# 当某个 Claude 完成任务需要输入时,直接弹窗提醒

# 在 ~/.claude/settings.json 中配置
{
  "notifications": {
    "enabled": true,
    "sound": true,
    "position": "top-right"
  }
}

就好比你雇了 5 个初级程序员同时干活,你只需要负责 Review 和分配任务,效率直接翻倍。

2. 本地与云端的”混合双打”

# 在本地终端运行 5 个实例
# 同时在 claude.ai/code 网页端运行 5-10 个会话

# 利用 & 命令将本地会话"甩"给网页端后台运行
& 将这个任务转到网页端继续

# 在网页版开始新任务
# 然后在终端用 claude --teleport session_id 拉回本地

3. 跨设备同步工作流

# 早上在办公室:终端 + 网页版
# 中午休息:手机版 Claude App 查看进度
# 晚上回家:claude --teleport 继续开发

# 工作流永不中断

效果对比:

方式	并发度	效率提升	适用场景
单实例	1x	基准	简单任务
5个终端	5x	400%	本地开发
5终端 + 10网页	15x	1400%	大型项目
全设备协作	20x+	1900%+	复杂重构

上下文管理

策略:

# 长对话定期 compact
/compact "保留以下要点: ..."

# 新任务先 clear
/clear

# 监控上下文使用
/context

# 定期 export 备份
/export conversation-2026-01-06.json

Token 优化

技巧	说明	节省效果
使用 @提及	只加载需要的文件	30-50%
定期 /compact	清理历史保留摘要	40-60%
避免重复加载	检查 /context 输出	20-30%
使用 Subagents	并行处理减少串行上下文	50-70%

模型选择策略

Claude Code 创始人的独家见解: 只用最强的模型:Opus 4.5 + Thinking

很多人为了省钱或追求速度会用 Haiku 或 Sonnet,但 Boris Cherny 只用 Opus 4.5,并全程开启 Thinking(思考)模式。

理由:

虽然 Opus 4.5 更贵、更慢,但它不需要你频繁纠正(Steer less)
工具使用能力更强,一次就能做对
从”任务完成总耗时”来看,聪明的大模型反而比”快但笨”的小模型更快
一次做对,永远比反复修改更省时间

土豪专属了属于是。

国外模型选择策略:

简单任务

Haiku 4.5

中等复杂度

Sonnet 4.5

高复杂度

Opus 4.5 + Thinking

成本优化

平衡性能

质量优先

国外模型使用建议:

快速查询/格式化: Haiku 4.5 – 最快最便宜
日常开发/代码编写: Sonnet 4.5 – 性价比平衡
架构设计/复杂重构: Opus 4.5 + Thinking – 最高质量(创始人首选)

国内模型选择策略:

简单任务

DeepSeek-Coder

中文项目

GLM-4.7

大型项目

Kimi K2

Python/JS

Qwen-Coder-Plus

极低成本

中文优化

超长上下文

开源优秀

国内模型使用建议:

任务类型	推荐模型	理由	价格(相对)
简单查询	DeepSeek-Coder	极低成本,够用	⭐
中文项目	GLM-4.7	中文理解最强,有Coding套餐	⭐⭐⭐
大型重构	Kimi K2	超长上下文(2M+),MoE架构	⭐⭐
Python/JS	Qwen-Coder-Plus	开源,Python/JS性能优秀	⭐⭐
预算有限	DeepSeek-Coder	价格优势明显	⭐
团队协作	GLM-4.7	有团队套餐,管理方便	⭐⭐⭐

模型切换策略:

# 方式1:使用 /model 命令快速切换
claude
/model
# 选择对应模型

# 方式2:临时切换(当前会话)
export ANTHROPIC_MODEL=kimi-k2
claude

# 方式3:针对不同任务使用不同配置
# 创建alias
alias cc-glm='ANTHROPIC_MODEL=GLM-4.7 claude'
alias cc-kimi='ANTHROPIC_MODEL=kimi-k2 claude'
alias cc-qwen='ANTHROPIC_MODEL=qwen-coder-plus claude'

# 使用
cc-glm   # 使用智谱GLM
cc-kimi  # 使用Kimi
cc-qwen  # 使用通义千问

成本优化建议:

简单查询

中文开发

大型重构

Python项目

高质量要求

任务开始

任务类型?

DeepSeek-Coder

GLM-4.7

Kimi K2

Qwen-Coder-Plus

Sonnet 4.5

成本: $

成本: $$

成本:

混合使用策略:

# 日常开发用国产模型(便宜)
export ANTHROPIC_MODEL=GLM-4.7

# 遇到复杂任务时临时切换到高质量模型
/model
# 选择 Opus 4.5

# 完成后切换回国产模型
/model
# 选择 GLM-4.7

6.5 安全最佳实践

Sandbox 配置

{
  "permissions": {
    "allow": {
      "bash": ["npm run *", "git *"],
      "write": ["src/**/*", "tests/**/*"],
      "read": ["**/*.ts", "**/*.js", "**/*.json"]
    },
    "deny": {
      "bash": ["rm -rf *", "format *", "shutdown"],
      "write": ["node_modules/**/*", ".git/**/*", "/etc/*", "/usr/*"]
    }
  }
}

Hooks 安全检查

#!/bin/bash
# ~/.claude/hooks/security-check.sh

# 检查敏感操作
if [[ "$TOOL_NAME" == "Bash" ]]; then
  COMMAND=$(jq -r '.command' <<< "$CLAUDE_HOOK_INPUT")

  # 危险命令黑名单
  DANGEROUS_CMDS=("rm -rf" "format" "shutdown" "reboot" "chmod 000")

  for cmd in "${DANGEROUS_CMDS[@]}"; do
    if [[ "$COMMAND" == *"$cmd"* ]]; then
      echo "🚫 拦截危险命令: $COMMAND"
      exit 1
    fi
  done
fi

敏感信息保护

# CLAUDE.md 安全规范

## 禁止事项
- ❌ 在代码中硬编码密钥
- ❌ 在 CLAUDE.md 中记录密码
- ❌ 在 Git 提交中包含凭证

## 推荐做法
- ✅ 使用环境变量
- ✅ 使用 .env 文件(不提交)
- ✅ 使用密钥管理服务(AWS Secrets Manager 等)
- ✅ .gitignore 排除敏感文件

6.6 验证闭环(Feedback Loop)

来自 Claude Code 创始人的最重要的一条技巧：永远给 Claude 一种验证自己工作的方法

核心原理

如果 Claude 能看到自己代码的运行结果(报错信息、测试通过与否),它的代码质量会提升 2-3 倍。

实践方法

1. 简单的任务:运行 Bash 命令验证

# 编写代码后立即验证
请实现一个用户登录功能,然后:
1. 运行测试
!npm test

# 根据测试结果修复问题

# 重新验证
!npm test

# 直到所有测试通过

2. 复杂的 UI:使用浏览器自动化

# 使用 Claude Chrome 扩展
请修复这个 Bug 并验证:
1. 用 Chrome 打开 http://localhost:3000/login
2. 输入测试账号和密码
3. 点击登录按钮
4. 检查是否正确跳转到首页
5. 查看控制台是否有报错
6. 直到体验"感觉对劲"为止

3. 端到端验证流程

# 创建完整的验证循环
使用 verify-app agent 验证以下功能:
1. 用户注册流程
2. 登录和登出
3. 权限验证
4. 数据持久化

运行完整测试套件:
!npm run test:e2e

如果发现问题,请:
1. 分析根因
2. 修复代码
3. 重新验证
4. 确认问题已解决

效果对比

验证方式	代码质量	所需时间	返工率
无验证	⭐⭐	基准	40%
人工验证	⭐⭐⭐	+50%	20%
Claude 自动验证	⭐⭐⭐⭐⭐	+20%	5%

为什么验证循环如此重要?

人类开发流程:

写代码
手动测试
发现 bug
修复 bug
重复测试

Claude + 验证循环流程:

Claude 写代码
Claude 自己测试
Claude 看到错误
Claude 立即修复
Claude 再次验证
循环直到完美

关键差异:

Claude 能立即看到错误信息
Claude 不需要等待人工反馈
Claude 可以在几秒内完成多个修复循环
最终代码质量远超人工编写

最佳实践建议

✅ 推荐做法:

# 总是让 Claude 验证自己的工作
请实现功能 X,然后:
1. 运行测试验证
2. 检查代码格式
3. 验证边界情况
4. 确认无回归问题

❌ 避免做法:

# 不要让 Claude"盲写"
请实现功能 X
# (没有验证步骤,Claude 不知道代码是否正确)

七、实战案例

简单几个案例看看如何运用到实际工作中。

7.1 案例1:批量文件重命名

需求:将文件夹中所有文件名改为规范的英文名称

实现:

# 拖拽文件夹到 Claude Code

请将文件夹中的所有文件名改成规范的英文名称,只改名字,不改序号

# Claude Code 自动:
# 1. 读取文件夹内容
# 2. 分析文件名
# 3. 批量重命名
# 4. 报告结果

7.2 案例2:自动化数据抓取

需求:抓取公众号多页文章数据并导出 Excel

实现:

# 使用 Chrome DevTools MCP

用Chrome浏览器打开这个链接:[公众号链接]

然后通过 chrome devtools mcp 完成:
1. 获取第1、2、3页每篇文章的详细数据
2. 包括标题、阅读量、点赞量、发布时间等
3. 保存到 Excel 表格中

# Claude Code 自动:
# 1. 启动 Chrome
# 2. 导航到页面
# 3. 翻页抓取数据
# 4. 生成 Excel 报告

效果对比:

方式	耗时	准确率
人工	30分钟	90%
Claude Code + MCP	5分钟	99%

7.3 案例3:代码质量审查

需求:审查 PR 的代码变更

实现:

# 使用 code-reviewer subagent

使用 code-reviewer agent 审查这个 PR:
- 代码质量
- 安全漏洞
- 性能问题
- 最佳实践

@src/ @tests/

# Claude Code 自动:
# 1. 读取所有相关文件
# 2. 应用审查标准
# 3. 生成详细报告
# 4. 提供修复建议

7.4 案例4:自动化测试生成

需求:为新功能编写测试

实现:

# 使用 test-writer subagent

使用 test-writer agent 为用户认证功能编写测试:
- 单元测试
- 集成测试
- E2E 测试
- 边界情况测试

@src/auth.ts @src/auth.controller.ts

# Claude Code 自动:
# 1. 分析代码逻辑
# 2. 识别测试场景
# 3. 编写测试用例
# 4. 运行测试验证

7.5 案例5:CI/CD 集成

需求:在 PR 创建时自动审查代码

实现:

# .github/workflows/claude-review.yml

name: Claude Auto Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Install Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Configure Claude
        run: |
          echo "配置模型..."
          export ANTHROPIC_MODEL="claude-sonnet-4-5"

      - name: Run Review
        run: |
          git diff origin/main...HEAD > diff.txt
          claude -p "审查这个 PR 的代码变更,重点关注:
          1. 安全漏洞
          2. 性能问题
          3. 代码规范
          请提供详细审查意见" < diff.txt > review.txt

      - name: Comment on PR
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const review = fs.readFileSync('review.txt', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: `## 🤖 Claude Code 自动审查\n\n${review}`
            });

八、常见问题与解决方案

在使用 Claude Code 的过程中,你可能会遇到一些常见问题。本章节收集了最常见的问题及其解决方案,帮助你快速排除故障。

8.1 安装问题

Q1: npm install 失败

问题:

npm ERR! code EACCES
npm ERR! syscall access

解决方案:

# 方式1: 使用 sudo (macOS/Linux)
sudo npm install -g @anthropic-ai/claude-code

# 方式2: 修改 npm 全局目录
mkdir ~/.npm-global
npm config set prefix '~/.npm-global'
export PATH=~/.npm-global/bin:$PATH
npm install -g @anthropic-ai/claude-code

# 方式3: 使用 nvm (推荐)
nvm install --lts
npm install -g @anthropic-ai/claude-code

Q2: claude 命令未找到

问题:

bash: claude: command not found

解决方案:

# 检查 npm 全局路径
npm config get prefix

# 添加到 PATH
export PATH=$(npm config get prefix)/bin:$PATH

# 永久配置
echo 'export PATH=$(npm config get prefix)/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

8.2 配置问题

Q3: 模型配置不生效

问题:配置后仍显示默认模型

解决方案:

# 1. 验证环境变量
echo $ANTHROPIC_BASE_URL
echo $ANTHROPIC_AUTH_TOKEN
echo $ANTHROPIC_MODEL

# 2. 重新启动终端
# 配置环境变量后必须重启终端才能生效

# 3. 使用 claude /status 检查
claude
/status

# 4. 手动设置(临时)
claude
/model
# 选择第4个(自定义模型)

Q4: MCP 服务器无法连接

问题:

Error: MCP server 'chrome-devtools' failed to start

解决方案:

# 1. 检查 MCP 状态
claude
/mcp

# 2. 测试连接
claude mcp test chrome-devtools

# 3. 重新安装
claude mcp remove chrome-devtools
claude mcp add chrome-devtools npx chrome-devtools-mcp@latest

# 4. 检查网络
npx chrome-devtools-mcp@latest --version

# 5. 查看日志
claude /doctor

8.3 使用问题

Q5: 上下文超出限制

问题:

Context exceeded: Request too large

解决方案:

# 1. 查看上下文使用
/context

# 2. 使用 compact 保留摘要
/compact "保留项目背景和当前任务"

# 3. 使用 clear 清空历史
/clear

# 4. 减少文件引用
# 不要用 @src/ 引用整个目录
# 改用 @src/file1.ts @src/file2.ts 精确引用

# 5. 使用 Subagents 分担上下文
# 将大任务拆分给多个子代理

Q6: 代码生成质量差

问题:生成的代码不符合项目规范

解决方案:

# 1. 完善 CLAUDE.md
# 在 CLAUDE.md 中明确代码规范

# 2. 使用 Plan 模式
Shift+Tab × 2
# 让 Claude 先理解项目再编写代码

# 3. 提供示例
# 这是符合规范的代码示例:
@src/good-example.ts
# 请参照这个风格编写新功能

# 4. 明确要求
请编写符合以下规范的代码:
- 使用 TypeScript 严格模式
- 遵循项目命名规范
- 包含完整的错误处理
- 添加必要的注释

8.4 性能问题

Q7: 响应速度慢

问题:Claude Code 响应延迟高

解决方案:

# 1. 检查网络
ping api.anthropic.com

# 2. 切换更快的模型
/model
# 选择 Haiku 4.5(最快) 或国产模型

# 3. 优化提示词
# 避免冗长的提示词,直接说明需求

# 4. 减少上下文
/context
# 如果接近 100%,使用 /compact 清理

# 5. 使用本地模型(如果有)
export ANTHROPIC_BASE_URL=http://localhost:8000

Q8: Token 消耗过快

问题:费用增长过快

解决方案:

# 1. 监控费用
/cost

# 2. 定期 compact
/compact "保留关键信息"

# 3. 新任务先 clear
/clear

# 4. 使用更便宜的模型
# Haiku < Sonnet < Opus
# 国产模型(更便宜)

# 5. 优化工作流
# 避免反复修改,一次性明确需求

8.5 调试技巧

启用调试模式

# 设置环境变量
export CLAUDE_DEBUG=true
export CLAUDE_LOG_LEVEL=debug

# 启动 Claude Code
claude

# 查看日志
tail -f ~/.claude/logs/claude.log

使用 /doctor 诊断

claude
/doctor

检查项:

✅ 安装版本
✅ 配置文件
✅ API 连接
✅ MCP 服务器
✅ 权限设置
✅ 环境变量

九、高级集成与扩展

Claude Code 的真正强大之处在于它的可扩展性。通过 LSP 集成和 Agent SDK，甚至可以构建自己的智能开发环境。

9.1 LSP 集成

什么是 LSP?

LSP (Language Server Protocol) 是语言服务器协议，通过集成 LSP，Claude Code 现在的代码理解能力达到了 IDE 级别。

LSP 的强大能力

# Claude Code 现在可以:
- 看到实时报错和警告
- 跳转到定义
- 查看类型信息
- 理解符号引用
- 分析代码结构

效果对比:

能力	无 LSP	有 LSP
错误检测	⭐⭐⭐	⭐⭐⭐⭐⭐
类型推断	⭐⭐⭐	⭐⭐⭐⭐⭐
代码导航	⭐⭐	⭐⭐⭐⭐⭐
重构建议	⭐⭐⭐	⭐⭐⭐⭐⭐

实战案例:

# Claude Code 可以像 IDE 一样理解代码

@src/auth.ts
这个函数的返回类型是什么?
# (Claude 会使用 LSP 查看准确的类型定义)

这个函数在哪里被调用了?
# (Claude 会使用 LSP 查找所有引用)

这里有个类型错误,怎么修复?
# (Claude 会看到实时报错并提供建议)

配置 LSP

Claude Code 会自动检测项目中的 LSP 服务器:

# TypeScript 项目
# 自动使用 tsserver

# Python 项目
# 自动使用 pylsp

# Go 项目
# 自动使用 gopls

手动配置 LSP:

// ~/.claude/settings.json
{
  "lsp": {
    "typescript": {
      "command": "typescript-language-server",
      "args": ["--stdio"]
    },
    "python": {
      "command": "pylsp",
      "args": ["--stdio"]
    }
  }
}

9.2 Claude Agent SDK

什么是 Agent SDK?

Claude Agent SDK 将 Claude Code 的核心能力(Agent Loop、工具管理、上下文管理)作为一个 SDK 开放了。可以用几十行代码构建一个像 Claude Code 一样强大的自定义智能体。

核心能力

import { Agent, Tool, Context } from '@anthropic-ai/agent-sdk';

// 创建自定义 Agent
const myAgent = new Agent({
  model: 'claude-sonnet-4-5',
  tools: [
    new Tool({
      name: 'readFile',
      execute: async (path: string) => {
        return fs.readFileSync(path, 'utf-8');
      }
    }),
    new Tool({
      name: 'writeFile',
      execute: async (path: string, content: string) => {
        fs.writeFileSync(path, content);
      }
    })
  ],
  context: new Context({
    maxSize: 200_000, // 200K tokens
    compression: 'auto'
  })
});

// 运行 Agent
const result = await myAgent.run('创建一个用户认证系统');

实战案例

案例1:自动化测试生成器

import { Agent, Tool } from '@anthropic-ai/agent-sdk';

class TestGenerator extends Agent {
  constructor() {
    super({
      model: 'claude-sonnet-4-5',
      instructions: '你是一个测试专家,专门为代码编写全面的测试用例',
      tools: [
        new Tool({
          name: 'readSource',
          description: '读取源代码文件',
          execute: async (path: string) => {
            return fs.readFileSync(path, 'utf-8');
          }
        }),
        new Tool({
          name: 'writeTest',
          description: '编写测试文件',
          execute: async (path: string, content: string) => {
            fs.writeFileSync(path, content);
          }
        }),
        new Tool({
          name: 'runTests',
          description: '运行测试',
          execute: async () => {
            return execSync('npm test').toString();
          }
        })
      ]
    });
  }
}

// 使用
const testGen = new TestGenerator();
await testGen.run(`
  为 src/auth.ts 编写测试,包括:
  1. 正常登录场景
  2. 错误密码场景
  3. 用户不存在场景
  4. Token 验证场景

  然后运行测试确保所有测试通过
`);

案例2:代码审查机器人

import { Agent, Tool } from '@anthropic-ai/agent-sdk';

class CodeReviewer extends Agent {
  constructor() {
    super({
      model: 'claude-opus-4-5',
      instructions: `
        你是一个代码审查专家。审查代码时关注:
        1. 安全漏洞(OWASP Top 10)
        2. 性能问题
        3. 代码规范
        4. 最佳实践

        输出格式:
        - 严重程度(Critical/High/Medium/Low)
        - 问题描述
        - 修复建议
        - 代码示例
      `,
      tools: [
        new Tool({
          name: 'readFile',
          execute: async (path: string) => {
            return fs.readFileSync(path, 'utf-8');
          }
        }),
        new Tool({
          name: 'gitDiff',
          execute: async () => {
            return execSync('git diff').toString();
          }
        })
      ]
    });
  }
}

// 使用
const reviewer = new CodeReviewer();
const review = await reviewer.run('审查当前的代码变更');

console.log(review);
/*
输出:
## 🔴 Critical: SQL 注入风险

位置: src/auth.ts:45
问题: 直接拼接 SQL 查询,存在注入风险
建议: 使用参数化查询

代码示例:
\`\`\`typescript
// ❌ 不安全
const query = `SELECT * FROM users WHERE id = ${userId}`;

// ✅ 安全
const query = 'SELECT * FROM users WHERE id = ?';
await db.query(query, [userId]);
\`\`\`
*/

案例3:自动化部署助手

import { Agent, Tool } from '@anthropic-ai/agent-sdk';

class DeploymentBot extends Agent {
  constructor() {
    super({
      model: 'claude-sonnet-4-5',
      instructions: `
        你是一个部署专家。部署流程:
        1. 运行测试
        2. 构建项目
        3. 部署到 staging
        4. 验证部署
        5. 部署到生产
        6. 监控错误
        如果任何步骤失败,立即回滚
      `,
      tools: [
        new Tool({
          name: 'runTests',
          execute: async () => {
            return execSync('npm test').toString();
          }
        }),
        new Tool({
          name: 'build',
          execute: async () => {
            return execSync('npm run build').toString();
          }
        }),
        new Tool({
          name: 'deploy',
          execute: async (env: 'staging' | 'production') => {
            return execSync(`npm run deploy:${env}`).toString();
          }
        }),
        new Tool({
          name: 'verify',
          execute: async (url: string) => {
            return fetch(`${url}/health`).then(r => r.json());
          }
        }),
        new Tool({
          name: 'rollback',
          execute: async () => {
            return execSync('npm run rollback').toString();
          }
        }),
        new Tool({
          name: 'notify',
          execute: async (message: string) => {
            // 发送 Slack 通知
            await slackClient.chat.postMessage({
              channel: '#deployments',
              text: message
            });
          }
        })
      ]
    });
  }
}

// 使用
const deployBot = new DeploymentBot();
await deployBot.run('部署最新版本到生产环境');

Agent SDK 的核心优势

1. 完整的 Agent Loop

// 自动处理:
- 思考(Thinking)
- 工具调用(Tool Use)
- 结果观察(Observation)
- 迭代优化(Iteration)

2. 强大的上下文管理

const context = new Context({
  maxSize: 200_000,
  compression: 'auto', // 自动压缩历史对话
  priority: 'recent'   // 优先保留最近的内容
});

3. 灵活的工具系统

// 支持各种类型的工具
- 文件操作
- API 调用
- 数据库查询
- 网络请求
- 自定义脚本

4. 可观测性

const agent = new Agent({
  onThink: (thought) => console.log('思考:', thought),
  onToolUse: (tool, args) => console.log('调用工具:', tool),
  onError: (error) => console.error('错误:', error),
  onComplete: (result) => console.log('完成:', result)
});

使用场景

场景	价值
CI/CD 集成	自动化代码审查和测试
自动化运维	智能部署和监控
文档生成	自动生成 API 文档
代码迁移	批量重构和升级
教学工具	编程辅导和练习

附录

A. 快速参考卡

核心命令速查

# 基础操作
claude                    # 启动 Claude Code
claude -p "prompt"        # Headless 模式
claude --version          # 查看版本

# 斜杠命令
/clear                    # 清空对话
/compact                  # 压缩对话
/context                  # 查看上下文
/cost                     # 查看费用
/model                    # 切换模型
/mcp                      # 管理 MCP
/skills                   # 查看 Skills
/hooks                    # 管理 Hooks
/agents                   # 管理子代理
/status                   # 系统状态
/doctor                   # 诊断环境

# 快捷键
Ctrl+R                    # 搜索历史
Ctrl+S                    # 暂存提示词
Ctrl+C                    # 中止操作
Shift+Tab × 2             # Plan 模式
ESC ESC                   # 回退操作
Alt+V                     # 粘贴图片

# 文件操作
@file.ts                  # 引用文件
@src/                     # 引用目录
!command                  # 执行 Bash

B. 配置文件清单

配置文件	位置	作用
CLAUDE.md	项目根目录	项目配置
settings.json	~/.claude/ 或项目/.claude/	全局/项目设置
agents.json	~/.claude/ 或项目/.claude/	子代理配置
mcp.json	~/.claude/	MCP 服务器配置
hooks/	~/.claude/hooks/	Hook 脚本
skills/	~/.claude/skills/	自定义 Skills
rules/	项目/.claude/rules/	模块化规则

C. 推荐资源

官方资源

Claude Code 官网: https://code.claude.com
文档: https://code.claude.com/docs
GitHub: https://github.com/anthropics/claude-code
Skills 库: https://github.com/anthropics/skills
MCP 服务器: https://github.com/modelcontextprotocol

总结

Claude Code 真的很强，是一个强大的系统级 AI Agent，用好这个工具能为自己提高很多工作效率。

核心能力清单

✅ Skills: 预封装的工作流,快速复用专业能力
✅ Hooks: 事件驱动的自动化,打造个性化工作流
✅ Plugins: 完整解决方案,一键安装多功能套件
✅ MCP Servers: 外部服务集成,无限扩展能力边界
✅ Subagents: 并行处理复杂任务,提升团队协作效率
✅ CLAUDE.md: 项目记忆系统,让 AI 理解你的项目,并支持自我进化
✅ Plan 模式: 先规划后执行,减少返工提高质量(90% 时间都在用)
✅ Slash Commands: 复杂工作流一键执行,团队共享最佳实践
✅ Extended Thinking: ultrathink 深度思考模式,解决复杂问题
✅ Sandbox 模式: 安全防护机制,保护你的工作环境
✅ Headless 模式: CI/CD 集成,实现自动化工作流
✅ LSP 集成: IDE 级代码理解,实时错误检测
✅ Agent SDK: 构建自定义智能体,几十行代码创造强大工具

顶级开发者的秘诀

来自 Claude Code 创始人和 Anthropic 团队的实战经验:

1. 并行处理是效率倍增的关键

同时运行 5 个终端实例 + 5-10 个网页会话
利用系统通知和多设备协作
效率提升可达 1900%+

2. AI 进化机制让工具越用越聪明

在 PR 评论中直接 @claude 反馈
自动将教训写入 CLAUDE.md
整个团队的 AI 助手持续进化

3. 验证闭环是质量保证的基石

永远给 Claude 验证自己工作的方法
代码质量提升 2-3 倍
返工率降低到 5%

4. 选择合适的工具

简单任务: Haiku 4.5 或国产模型
日常开发: Sonnet 4.5
复杂任务: Opus 4.5 + Thinking(创始人首选)
追求极致效率:聪明的大模型比”快但笨”的小模型更快

5. 先规划后执行

90% 的时间使用 Plan 模式
你是架构师,Claude 是执行者
一次做对,永远比反复修改更省时间

设计哲学

看完这些技巧会发现 Claude Code 的设计哲学非常有意思:

通过 Plan Mode,它尊重人的决策权
通过 Hooks 和 Sandbox,它给人提供了控制权
通过 Subagents 和 Automation,它帮人分担了繁琐的执行工作
通过 LSP 和 Agent SDK,它提供了无限的扩展可能

正如 Ado Kukic 所说:”用得最好的开发者,不是那些把所有事情都丢给 AI 的人,而是那些懂得何时使用计划模式、何时开启深度思考、如何设置安全边界的人。”

Claude Code 不仅仅是一个工具,它是一个可编程、可扩展、可进化的智能开发环境。你的创造力决定了它的上限。

__EOF__

本文作者： knqiufan
本文链接： https://www.cnblogs.com/knqiufan/p/19449849
关于博主： 这世界没有女孩子真的不会转！ —— 来自一名代号65的技术宅
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主： 如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。

1
2
3
4
...
下一页
共 883 页

开发笔记

1 什么是混剪视频

2 治愈老奶奶智能体

2.1 搭建工作流

2.2 设置智能体

3 搭建工作流

3.1 配置开始节点

3.2 配置“输出语录文案”大模型节点

3.3 配置“文本处理”节点

3.4 配置“移除空字符串”代码节点

3.5 配置“配图文案”大模型节点

3.6 配置“批处理”节点

3.7 配置批处理体的“图像生成”节点

3.8 配置“处理图片与音频”代码节点

3.9 配置“create_draft”节点

3.10 配置“add_images”节点

3.11 配置“add_images”节点

3.12 配置“add_audios”节点

3.13 配置“save_draft”节点

3.14 配置“gen_video”节点

3.15 配置结束节点

4 设置智能体

4.1 新建智能体

4.1 设置人设与逻辑

4.1 绑定工作流

5.3 测试并发布

一、从技术本质定义OpenClaw

二、核心架构全解析（从发消息到收回复）

1. 渠道适配器：消息的“预处理中转站”

2. 网关服务：系统的“核心枢纽”

3. 智能体运行器：AI能力的“承载者”

4. 大模型API调用：结果的“生成环节”

5. 智能体循环：工具调用的“核心循环”

6. 回复通路：结果的“反馈与留存”

三、OpenClaw的记忆管理机制（不做“金鱼式”AI）

两套记忆存储系统

混合检索方案（向量+关键词）

技术实现细节（可直接借鉴）

简洁却高效的记忆同步与生成

四、核心竞争力：电脑操作能力（OpenClaw的“护城河”）

五、安全机制设计（或说“是否真的安全？”）

1. 命令白名单机制

2. 预授权安全命令

3. 危险命令默认拦截

六、浏览器工具亮点：语义快照技术

最后总结

前言：为什么选择 Clawdbot (Moltbot)？

第一阶段：基建工程（环境准备）

1.1 解决 Node.js 安装与版本问题

1.1.1全新安装Node.js（电脑未安装过Node.js时）

1.1.2卸载旧版Node.js 安装新版（电脑安装过Node.js但是版本不够新时）

1.2 解锁脚本执行权限

第二阶段：正式安装与初始化

2.1 执行一键安装

2.2 运行向导 (Onboarding)

2.3 成功界面

第三阶段：破解“命令找不到”与“网关未授权”

3.1 解决 moltbot 命令失效

3.2 提取身份令牌 (Token) 登录网页

第四阶段：配置各种API

总结：你的 AI 现在能干什么？

项目概述

分层架构

核心设计模式

1. 领域驱动设计（DDD）

2. CQRS模式（命令查询职责分离）

3. 事件驱动架构

4. FastEndpoints轻量级API框架

几个核心特性

1. 强类型ID

2. 仓储模式

3. 验证机制

4. 异常处理

测试策略

前端架构

开发规范

云原生支持

代码分析可视化

总结

参考资料

五模型架构设计