ai 的skill - 光之星

什么是skill

简单来说，AI（人工智能）的“Skill”（技能）指的是它能够执行的任务、具备的能力以及它在特定领域表现出的“专长”。

如果你把 AI 想象成一个数字化的大脑，它的技能可以从基础通用能力和特定垂直领域能力两个维度来看：

1. 基础通用技能 (Core Capabilities)

这是大多数现代 AI（尤其是像我这样的大语言模型）都具备的看家本领：

自然语言处理 (NLP)： 理解、生成、翻译和总结文本。这是 AI 最核心的沟通技能。
逻辑推理与分析： 能够处理复杂逻辑，从混乱的数据中提取关键信息。
多模态处理： 不仅仅是文字，现在的 AI 还可以识别图像、生成视频、合成音乐或编写代码。
学习与适应： 通过大量数据训练（机器学习），AI 能够识别模式并在不断的反馈中优化自己的输出。

2. 专业/垂直领域技能 (Specialized Skills)

当 AI 被应用到具体行业时，它会展现出类似“专家”的技能：

领域	具体技能表现
编程与开发	自动编写代码、Debug（找 Bug）、解释复杂的算法。
创意设计	生成高质量图像、设计 Logo、辅助建筑建模。
医疗健康	分析医学影像（如 X 光片）、预测药物分子的结构。
数据科学	在几秒钟内分析数百万行表格，预测市场趋势。
行政办公	整理会议纪要、撰写周报、自动回复邮件。

3. AI 技能的本质是什么？

AI 的技能与人类的技能有着本质的区别。人类靠的是“经验”和“直觉”，而 AI 的技能本质上是 $$P(\text{output} | \text{input})$$，即基于输入数据，计算出最有可能、最合理的输出结果。

有趣的比喻：
如果说传统的计算机软件像是一个“死板的工具箱”，给它什么指令它就做什么；那么 AI 就像是一个“实习生”，它不仅有工具，还能通过观察和学习，掌握解决问题的方法。

4. 它是如何“获得”这些技能的？

AI 并不是天生就会这些。它的技能来自于以下过程：

预训练 (Pre-training)： 吞掉海量的互联网数据，学习人类说话的逻辑。
微调 (Fine-tuning)： 在特定任务上进行强化训练（比如专门学习如何写代码）。
人类反馈 (RLHF)： 通过人类的评价，学习哪些回答是好的，哪些是有误导性的。

给ai应用开发一个技能

给 AI 应用开发一个“技能”（Skill），本质上是让 AI 能够调用它原本无法触及的外部工具、数据或执行特定的业务逻辑。

根据你开发场景的不同，通常有以下三种主流实现方式：

1. 插件化开发 (如 Claude Skills / GPTs Actions)

这是目前最流行的方式，适合在现有的 AI 平台上快速扩展能力。你通过定义一个描述文件（如 Skill.md 或 OpenAPI JSON），告诉 AI 在什么情况下调用什么工具。

核心逻辑： 编写一份“说明书”，包含技能名称、描述、输入参数定义。

示例 (Claude Skill)：

# Skill.md
name: "Weather_Expert"
description: "当用户询问特定城市的天气时，调用此技能获取实时气象数据。"
parameters:
  city: "城市名称，字符串类型"

实现： AI 识别到需求后，会通过 Function Calling（函数调用） 机制生成符合格式的请求，发送给你的后端 API，获取结果后再包装成自然语言回复用户。

2. 函数调用 (Function Calling)

如果你是在开发自己的 AI 应用（使用 OpenAI/Anthropic 的 API），这是核心开发模式。

流程：
1. 定义工具 (Tools)： 在调用 API 时，传入一个 tools 列表，详细描述你的函数功能和参数结构。
2. 模型决策： AI 判断是否需要使用这些工具。如果需要，它会返回一个 tool_calls（包含函数名和参数）。
3. 本地执行： 你的程序在后台执行真正的代码（比如查询数据库、发邮件）。
4. 结果回传： 将执行结果发回给 AI，AI 总结并回复。

代码示意 (Python)：

tools = [{
    "type": "function",
    "function": {
        "name": "get_stock_price",
        "description": "获取股票实时价格",
        "parameters": {"type": "object", "properties": {"symbol": {"type": "string"}}}
    }
}]

3. 使用 Model Context Protocol (MCP)

这是 2025 年后兴起的新标准（由 Anthropic 推出），旨在让 AI 技能标准化和通用化。

优势： 你写好一个“技能服务器”（MCP Server），它可以同时给 Claude、IDE（如 Cursor）、或者你自己开发的 AI Agent 使用，不需要为每个平台重写一遍。
开发步骤：
1. 使用 SDK（Python/TypeScript）构建一个 MCP Server。
2. 暴露 Resources（数据源）或 Tools（可执行操作）。
3. 通过标准协议连接到 AI 终端。

开发技能的 3 个关键要素

无论用哪种技术，开发好技能的关键在于：

清晰的 Description（描述）： 这是 AI 的“触发器”。描述得越精准（例如：“仅在用户要求对比两份 PDF 文档的差异时调用”），AI 就越不会误用。
严格的 Schema（架构）： 明确参数类型（String, Int, Enum），防止 AI 传错参数导致程序崩溃。
错误处理： 如果外部 API 挂了，你的技能需要返回友好的错误信息，让 AI 能向用户解释清楚，而不是直接报错。

从零开发一个包含 AI 技能的独立 App

从零开发一个包含 AI 技能的独立 App，你可以想象成在搭建一个“大脑”（AI 模型）、“躯干”（你的应用代码）和“工具手”（AI 技能）的组合体。

目前的行业标准架构通常被称为 Agentic Workflow（智能体工作流）。以下是分步指南：

第一步：选择你的“大脑”连接方式 (Orchestration)

你不需要从头训练模型，而是通过 API 调用成熟的模型（如 Claude 3.5, GPT-4o, 或国产的 DeepSeek）。

框架推荐： * LangChain / LangGraph: 功能最全，适合复杂逻辑。
- Vercel AI SDK: 如果你用 TypeScript/Next.js 开发 Web App，这是目前体验最好的选择。
- Dify / Coze: 如果你想通过“拖拽”快速搭建后端逻辑，这两个平台可以让你像画流程图一样定义 AI 技能。

第二步：核心技术——函数调用 (Function Calling)

这是独立 App 实现 AI 技能的工业级标准。其过程如下：

定义技能清单： 在代码中声明一个 JSON 结构，描述你的 App 能干什么。
用户输入： 用户说“帮我查一下上周的销售额”。
模型决策： AI 发现自己没数据，但看到你提供了一个 get_sales_data 的技能，它会返回一个调用请求。
本地执行： 你的 App 代码去数据库查数据。
总结回复： 把数据传回 AI，AI 组织语言告诉用户结果。

示例代码逻辑 (TypeScript/Node.js):

const tools = {
  get_weather: {
    description: '获取指定城市的天气',
    parameters: z.object({ city: z.string() }),
    execute: async ({ city }) => {
      // 这里写你真正的业务逻辑：调用天气 API 或查数据库
      return await fetchWeatherApi(city);
    },
  },
};

第三步：App 整体架构图

一个完整的 AI App 通常包含以下层级：

层级	技术栈建议	职责
前端 (UI)	React Native / Flutter / Next.js	聊天界面、按钮触发、结果展示。
后端 (API)	Node.js (Fastify) / Python (FastAPI)	处理 AI 逻辑、验证用户权限、连接数据库。
AI 编排	LangChain / Vercel AI SDK	管理对话上下文（Context）和技能分发。
技能实现	工具 API / 数据库 / 本地脚本	真正干活的代码（如发送邮件、查询订单）。
向量数据库	Pinecone / Milvus (可选)	让 AI 拥有“长久记忆”或读取你的私有文档。

第四步：开发流程建议

MVP 阶段 (最简可行产品):
- 使用 Vercel AI SDK 或 Dify 快速跑通一个聊天窗口。
- 实现一个最简单的技能（例如：点击按钮，AI 调用一个打印 Hello World 的函数）。
技能增强阶段:
- 接入 RAG (检索增强生成): 让 AI 能够通过技能去搜索你 App 里的文档或数据库。
- 流式输出 (Streaming): 确保 AI 的回答是逐字跳出的，否则用户体验会很差。
上线准备:
- 添加“护栏” (Guardrails): 限制 AI 只能在你的技能范围内操作，防止它被诱导去执行危险指令（如删除数据库）。

关键避坑指南

不要在前端直接调 AI API： 这样会暴露你的 API Key，一定要通过后端转发。
明确技能边界： 不要给 AI 太宽泛的权限。比如“修改数据库”技能，应该设计成“生成修改建议”，然后由用户点击按钮确认执行。
处理延迟： AI 调用+技能执行可能需要几秒钟，前端一定要有 Loading 状态或预期的交互设计。

要从零开发一个带技能的独立 App，建议使用 FastAPI（作为后端框架）配合 Pydantic（进行数据校验），并使用 OpenAI SDK（它支持大多数兼容 OpenAI 格式的模型，如 DeepSeek, Claude 等）来实现 Function Calling。

1. 核心架构设计

你的 App 需要通过以下流程来运行“技能”：

用户发送消息。
FastAPI 将消息和工具定义一起发给 AI。
AI 返回一个“调用请求”（例如：call get_user_info(id=123)）。
Python 代码执行真实的数据库查询。
FastAPI 将查询结果传回给 AI。
AI 生成最终的人类语言回复。

2. 起步代码示例

你需要安装：pip install openai fastapi uvicorn pydantic

第一步：定义你的“技能”函数

这就是 AI 真正能干活的代码。

import json

# 这是一个模拟数据库查询的“技能”
def get_order_status(order_id: str):
    """获取订单状态的真实逻辑"""
    # 实际开发中这里会写 SQL 查询
    database = {
        "12345": "已发货，预计明天到达",
        "67890": "待付款"
    }
    status = database.get(order_id, "订单号不存在")
    return json.dumps({"order_id": order_id, "status": status})

第二步：配置 AI 技能说明书

你需要告诉 AI 这个函数叫什么，怎么用。

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "当用户询问订单状态或物流进度时调用",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string", "description": "订单号，例如 12345"}
                },
                "required": ["order_id"]
            }
        }
    }
]

第三步：编写 FastAPI 后端接口

这是 App 的心脏，负责协调 AI 和你的技能。

from fastapi import FastAPI
from openai import OpenAI

app = FastAPI()
client = OpenAI(api_key="你的API_KEY")

@app.post("/chat")
async def chat(user_input: str):
    # 1. 询问 AI 是否需要调用技能
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": user_input}],
        tools=tools
    )
    
    message = response.choices[0].message
    
    # 2. 检查 AI 是否发出了调用请求
    if message.tool_calls:
        for tool_call in message.tool_calls:
            if tool_call.function.name == "get_order_status":
                # 解析 AI 给出的参数
                args = json.loads(tool_call.function.arguments)
                # 执行真实技能
                result = get_order_status(args['order_id'])
                
                # 3. 将结果喂回给 AI，让它组织语言
                final_response = client.chat.completions.create(
                    model="gpt-4o",
                    messages=[
                        {"role": "user", "content": user_input},
                        message,
                        {"role": "tool", "content": result, "tool_call_id": tool_call.id}
                    ]
                )
                return {"reply": final_response.choices[0].message.content}
    
    return {"reply": message.content}

3. 开发进阶建议

使用 LangGraph 实现复杂技能：
如果你的技能不是“一问一答”，而是需要多步操作（比如：先搜搜看 -> 没找到 -> 再去另一个 API 找），建议学习 LangGraph，它能帮你管理复杂的技能状态机。
异步化处理 (Async/Await)：
AI 的响应通常很慢。在 Python 中务必使用 async def，配合前端的流式输出（Streaming），让用户能看到 AI 正在思考。
持久化存储：
独立 App 需要记忆。你可以使用 PostgreSQL 存储聊天记录，并在每次请求时把最近的 5-10 条记录传给 AI，作为它的“短期记忆”。

如果你觉得传统的 Function Calling（一问一答）已经无法满足复杂的业务逻辑，那么 LangGraph 就是你要进阶的方向。

简单来说，LangGraph 是 LangChain 团队推出的一个库，专门用于构建有状态的、循环的 AI 任务流（即 AI Agents）。

1. 为什么要用 LangGraph？

在简单的应用中，AI 只是一个“计算器”；但在复杂的 App 中，你可能需要 AI 具备以下行为：

循环（Loops）： AI 执行了一个技能，发现结果不满意，自动修正参数重新执行。
状态管理（State）： 在长达十几个步骤的任务中，准确记住每一步拿到的数据。
条件分支（Conditional Edges）： 如果技能 A 返回了错误，走人工审批流程；如果返回成功，走自动回复流程。

2. LangGraph 的核心概念

在 Python 中开发时，你需要理解这三个核心词：

State (状态)： 一个 Python 字典（TypedDict），记录了当前对话的所有上下文、技能执行结果等。
Nodes (节点)： 你的 Python 函数。一个节点可以是“调用 AI”，另一个节点可以是“查询数据库”。
Edges (边)： 连接节点的线。它决定了 AI 运行完 Node A 后，下一步是去 Node B 还是结束任务。

3. 代码实战：构建一个“会自我修正”的技能流

假设你要开发一个技能：根据用户要求写代码并自动运行测试。如果测试失败，AI 必须重新写。

import operator
from typing import Annotated, TypedDict, Union
from langgraph.graph import StateGraph, END

# 1. 定义状态（State）
class AgentState(TypedDict):
    task: str
    code: str
    test_result: str
    iterations: int

# 2. 定义节点（Nodes）
def programmer_node(state: AgentState):
    # 这里调用 AI 写代码
    print("---程序员节点：正在写代码---")
    return {"code": "print('hello world')", "iterations": state.get("iterations", 0) + 1}

def tester_node(state: AgentState):
    # 这里模拟运行代码并返回测试结果
    print("---测试员节点：正在运行测试---")
    if state["iterations"] < 2:
        return {"test_result": "fail"}
    return {"test_result": "pass"}

# 3. 定义逻辑边（Conditional Edges）
def decide_next_step(state: AgentState):
    if state["test_result"] == "pass":
        return "end"
    return "re_program"

# 4. 构建图（Graph）
workflow = StateGraph(AgentState)

workflow.add_node("programmer", programmer_node)
workflow.add_node("tester", tester_node)

workflow.set_entry_point("programmer")
workflow.add_edge("programmer", "tester")

# 根据测试结果决定是结束还是回到程序员节点
workflow.add_conditional_edges(
    "tester",
    decide_next_step,
    {
        "end": END,
        "re_program": "programmer"
    }
)

app = workflow.compile()

4. 为什么这对于“独立 App”至关重要？

在独立 App 开发中，LangGraph 解决了 “不可控性” 难题：

断点续传（Persistence）： LangGraph 自带 Checkpointer 功能。如果用户在 AI 执行复杂技能时断网了，你可以通过 thread_id 恢复之前的状态，而不需要重新开始。
人机交互（Human-in-the-loop）： 你可以设置“拦截点”。当 AI 准备执行一个高风险技能（如“清空购物车”）时，程序会暂停，等待你在 App 上点击“允许”，AI 才会继续运行。
多智能体协作： 你可以定义一个“技术支持 AI”和一个“财务 AI”，它们在同一个图中互相转交任务。

5. 推荐学习路径

如果你准备用 Python + LangGraph 开发：

安装： pip install langgraph langchain_openai
可视化： LangGraph 的图可以在开发阶段导出为图片，帮你 debug 逻辑流。
持久化： 学习使用 MemorySaver 来保存用户的对话进度。

你现在手头有没有一个具体的“复杂任务场景”？我们可以试着把它拆解成 LangGraph 的节点和边。

在 AI 编排（Orchestration）的语境下，Skill（技能）和 Agent（智能体） 的区别就像是“工具箱里的扳手”与“拿着工具箱的修理工”之间的关系。

理解这两者的边界，是设计高效 AI 流程的关键。

1. 核心定义区别

Skill (技能/工具)

本质：一个特定的、原子化的功能函数。
特性：被动执行。它不具备思考能力，只有在被调用时才会执行预设的代码逻辑。
类比：就像 Excel 里的一个公式 SUM()，或者一个 API 接口（如“查询天气”、“搜索 GitHub 仓库”）。
在 Temporal 中：通常对应一个 Activity。它是一个确定的动作，输入 A，输出 B。

Agent (智能体)

本质：一个具备推理、规划和决策能力的系统实体。
特性：主动决策。它拥有“大脑”（LLM），能根据目标（Goal）自主决定何时使用哪个 Skill，并能根据 Skill 的返回结果修正下一步行动。
类比：就像一个实习生。你告诉他“写一份竞品分析报告”，他会自己去搜索（Skill A）、阅读（Skill B）、总结（Skill C）。
在 LangGraph 中：通常对应一个 StateGraph。它包含循环逻辑、状态记忆和条件判断。

2. 深度对比表

维度	Skill (技能)	Agent (智能体)
角色	执行者（Executor）	决策者（Decider）
逻辑复杂度	低（通常是线性代码）	高（包含推理循环 ReAct）
自主性	无（由外部指令驱动）	有（根据目标拆解任务）
状态感知	瞬时性（通常无状态）	持续性（拥有短期和长期记忆）
容错能力	抛出错误	尝试自我修复或切换路径
示例	`read_file()`, `send_email()`	“技术文档翻译助手”, “自动代码审查员”

3. 它们在架构中是如何协作的？

在 2026 年的主流编排架构中，它们是包含关系：

Agent = LLM (大脑) + Planning (规划) + Memory (记忆) + Skills (工具集)

Skill 是 Agent 的“肢体”：Agent 如果没有 Skill，就只能“纸上谈兵”（只有文字输出，无法干涉现实世界）。
Agent 是 Skill 的“统筹”：Skill 如果没有 Agent，就只能由程序员硬编码逻辑（if-else），无法处理模糊多变的业务需求。

4. 实战场景示例：自动化客服

有哪些 Skills？
1. get_order_status(order_id)：查询订单数据库。
2. send_refund_link(user_email)：发送退款链接邮件。
3. search_kb(query)：在知识库搜索 FAQ。
Agent 做什么？
1. 理解意图：用户说“我没收到货，想退钱”。
2. 决策规划：Agent 判断出需要先用 get_order_status 查物流。
3. 处理异常：如果物流显示已签收，Agent 决定调用 search_kb 查看签收纠纷处理流程，而不是盲目发退款链接。

5. 开发建议

在 Temporal + LangGraph 的开发中：

尽量将 Skill 原子化：把 Skill 写成标准的 Python 函数（Activity），确保它们稳定、可测试、有重试机制。
给 Agent 充分的“描述”：在 LangGraph 中，Skill 的 docstring（文档注释）非常重要。Agent 依靠阅读注释来判断“什么时候该用这个 Skill”。
不要让 Skill 太智能：如果一个 Skill 内部又包含复杂的 AI 推理，会导致架构层级混乱。复杂的逻辑应该提到 Agent 层（Graph 逻辑）去处理。

纠错提示：
有些人把“集成了一个 API 的 Agent”也叫 Agent。其实那只是一个 Wrapped API (封装工具)。真正的 Agent 必须具备反思（Reflection）或路径选择的能力。

你目前设计的系统中，是更倾向于构建一个功能极其丰富的“超级 Skill”，还是构建一个能组合多个简单 Skill 的“聪明 Agent”？

发表于 2026-03-31 17:20 光之星阅读(210) 评论(0) 收藏举报