企业官网建设流程全解析

最近在AI圈子里，Skill和Agent这两个词出现的频率越来越高。很多开发者，尤其是刚接触AI应用开发的朋友，常常会感到困惑：它们听起来都像是“智能体”或“能力”，到底有什么区别？是同一个东西的不同叫法，还是完全不同的两个层级？

这种困惑非常普遍。你可能看过一些文章，有的说Skill是Agent的“技能”，有的说Agent是Skill的“大脑”，但看完之后，对如何在自己的项目里应用，依然一头雾水。更麻烦的是，当你尝试使用一些AI开发框架时，会发现有的文档里混着用这两个词，配置项也让人摸不着头脑。

这篇文章，我们不打算从晦涩的学术定义开始。我将用一个你我都熟悉的场景——开一家奶茶店——来彻底讲清楚Skill和Agent的核心区别、各自的职责边界，以及它们是如何协同工作的。更重要的是，我们会把这个比喻映射回真实的技术实现，让你不仅“听懂”，更能“会用”。

读完本文，你将能清晰地回答：

1. Skill和Agent的本质区别是什么？（是“员工”和“技能”的关系）
2. 在技术架构中，它们分别对应什么组件？
3. 如何设计一个兼具灵活Skill和智能决策Agent的系统？
4. 市面上常见的框架（如LangChain、Semantic Kernel）是如何实现这两者的？

1. 从开奶茶店的故事，理解核心困境

想象一下，你要开一家奶茶店。你的目标是：顾客点单后，能自动制作出对应的奶茶。

最初的方案（只有Skill）：你买了一台超级全能的“奶茶机器人”。这台机器预设了100种技能（Skill）：

• Skill_泡红茶
• Skill_加珍珠
• Skill_加奶盖
• Skill_摇匀
• Skill_封口

看起来很棒，对吧？但问题来了。当顾客说“我要一杯珍珠奶茶，少冰，三分糖”时，这台机器懵了。它拥有所有底层技能，但它不知道应该按什么顺序、用什么参数来调用这些技能。“少冰”对应多少克冰？“三分糖”是加多少毫升糖浆？先加珍珠还是先加茶？这些决策，单个Skill无法做出。

这就是“只有Skill，没有Agent”的典型困境：能力碎片化，缺乏统一的协调与决策中枢。系统像一堆散落的工具，虽然每个工具都很锋利，但没人知道该在什么时候、用什么工具、以及如何组合它们来完成一个复杂目标。

进化后的方案（引入Agent）：你决定雇佣一位“店长”（Agent）。这位店长本身不会泡茶、不会封口，但他懂三件事：

1. 理解意图：他能听懂顾客的“珍珠奶茶，少冰，三分糖”是什么意思。
2. 规划与决策：他能拆解任务：“哦，这需要先执行泡红茶，然后执行加珍珠，糖度参数设为30%，冰量参数设为70%。”
3. 调度与执行：他指挥那台“奶茶机器人”：“先调用Skill_泡红茶，然后调用Skill_加珍珠，接着调用Skill_调糖度(30%)……”

在这个过程中，店长（Agent）是大脑，负责思考和指挥；机器人身上的各种功能（Skill）是手脚，负责具体执行。店长根据复杂的目标，灵活地编排和调用一个或多个Skill。

映射到AI开发中：

• Skill（技能）：一个单一的、可复用的、完成特定任务的能力单元。它通常是确定性的，有明确的输入和输出。例如：一个“查询天气API”的Skill，一个“计算两个日期之间天数”的Skill，一个“调用数据库查询用户信息”的Skill。
• Agent（智能体）：一个具备自主感知、规划、决策和执行能力的系统。它拥有一个或多个Skill，并能根据目标、上下文和环境状态，决定调用哪个Skill、以什么参数调用、以及如何处理Skill返回的结果。Agent的核心是“决策逻辑”或“大脑模型”（通常是大语言模型LLM）。

简单说：Skill是“做什么”，Agent是“何时做、如何做、以及做完之后怎么办”。

2. 技术概念深潜：Skill与Agent的架构定义

理解了比喻，我们来看严格的技术定义和架构位置。

2.1 Skill：原子化的能力封装

一个设计良好的Skill，应该像乐高积木一样，具备以下特征：

1. 功能单一：只做好一件事。例如，“发送邮件”Skill就只负责发邮件，不负责起草邮件内容。
2. 接口明确：有清晰的输入（Input）和输出（Output）定义。这通常通过函数签名（Function Calling）或API规范来描述。
3. 可独立测试：不依赖特定Agent或复杂上下文，可以单独进行单元测试。
4. 可复用：可以被不同的Agent在不同的任务中调用。

技术实现示例（Python函数形式）：

# 这是一个标准的“查询天气”Skill # 文件：skills/weather_skill.py import requests def get_weather(city: str, date: str = None) -> dict: """ 根据城市和日期查询天气信息。 参数: city (str): 城市名称，如 "北京" date (str): 日期，格式 "YYYY-MM-DD"，默认为今天 返回: dict: 包含天气信息的字典，例如： {"city": "北京", "date": "2023-10-27", "condition": "晴", "temp": "22℃"} """ # 这里简化实现，实际应调用如和风天气等API api_key = "YOUR_API_KEY" base_url = "https://api.weather.com/v3/..." params = {"city": city, "key": api_key} if date: params["date"] = date try: response = requests.get(base_url, params=params, timeout=5) response.raise_for_status() data = response.json() # 解析并返回标准化格式 return { "city": data.get("location", {}).get("name", city), "date": data.get("forecast", {}).get("date", date), "condition": data.get("current", {}).get("condition", "未知"), "temp": f"{data.get('current', {}).get('temp', 'N/A')}℃" } except requests.exceptions.RequestException as e: return {"error": f"查询天气失败: {str(e)}"} # 这个Skill可以被任何需要天气信息的Agent调用。

2.2 Agent：具备决策能力的协调者

Agent是更上层的抽象，它包含以下核心组件：

1. 记忆（Memory）：存储对话历史、执行状态、用户偏好等。这是Agent能进行连续对话和基于上下文决策的基础。
2. 规划器（Planner）：将用户的高层目标（如“帮我规划一个周末旅行”）分解成一系列可执行的子任务（查询天气、查找景点、预订酒店……）。这个“大脑”通常由LLM驱动。
3. 技能工具箱（Skill Toolkit）：Agent所掌握的所有Skill的集合。它知道每个Skill能干什么、怎么调用。
4. 执行引擎（Executor）：负责按规划调用具体的Skill，并处理执行结果（成功、失败、需要进一步输入等）。
5. 反思与学习（Reflection）：高级Agent还能根据执行结果反思计划是否合理，并动态调整。

一个简化Agent的决策流程伪代码：

# 文件：agents/travel_agent.py class TravelAgent: def __init__(self, llm_client, skills): self.llm = llm_client # 大语言模型客户端，如OpenAI, Claude self.skills = skills # 技能字典，如 {'get_weather': weather_skill, 'search_hotel': hotel_skill} self.memory = [] # 对话记忆 def run(self, user_query: str): # 1. 更新记忆 self.memory.append({"role": "user", "content": user_query}) # 2. 规划：让LLM根据用户查询和记忆，决定下一步该调用哪个Skill plan_prompt = f""" 你是一个旅行助手。当前对话历史：{self.memory[-5:]}。 用户最新请求：{user_query}。 你拥有的技能：{list(self.skills.keys())}。 请分析是否需要调用技能，以及调用哪个技能，并给出调用参数。 如果不需要调用技能，请直接回复用户。 """ llm_decision = self.llm.generate(plan_prompt) # 3. 解析LLM的决策（例如，它说“调用get_weather技能，参数city=北京”） if "调用 get_weather" in llm_decision: # 4. 执行：从决策中提取参数，并调用对应的Skill import re match = re.search(r"city=(\w+)", llm_decision) city = match.group(1) if match else "北京" # 调用具体的Skill weather_result = self.skills["get_weather"](city=city) # 5. 将结果反馈给LLM，生成对用户的自然语言回复 response_prompt = f""" 技能调用结果：{weather_result}。 请根据这个结果，生成一段友好、自然的回复给用户。 """ final_response = self.llm.generate(response_prompt) # 6. 更新记忆并返回 self.memory.append({"role": "assistant", "content": final_response}) return final_response else: # 无需调用技能，直接使用LLM的回复 self.memory.append({"role": "assistant", "content": llm_decision}) return llm_decision

3. 主流框架中的Skill与Agent实现

理解了概念，我们看看在流行的AI应用开发框架中，这两者是如何被设计和使用的。

3.1 LangChain：以“链”为核心，Agent是特殊的链

在LangChain中，Skill的概念被具象化为“Tool”（工具）。一个Tool就是一个可被Agent调用的函数。

创建Skill（Tool）：

from langchain.agents import Tool from langchain.utilities import SerpAPIWrapper # 创建一个搜索Skill（Tool） search = SerpAPIWrapper() search_tool = Tool( name="Search", func=search.run, description="当需要回答关于当前事件或特定信息的问题时使用此工具。输入应该是一个搜索查询。" ) # 创建一个计算器Skill（Tool） from langchain.tools import BaseTool class CalculatorTool(BaseTool): name = "Calculator" description = "用于执行数学计算。输入应该是一个数学表达式，如 '2 + 2' 或 'sqrt(16)'。" def _run(self, query: str) -> str: try: # 警告：直接eval有安全风险，生产环境应用更安全的计算库（如numexpr） result = eval(query) return str(result) except Exception as e: return f"计算错误: {e}" async def _arun(self, query: str) -> str: return self._run(query) calculator_tool = CalculatorTool()

创建Agent并赋予Skill：LangChain的Agent是一个使用LLM来决定如何以及何时使用这些Tool的链。

from langchain.agents import initialize_agent, AgentType from langchain.llms import OpenAI llm = OpenAI(temperature=0) # 温度设为0，使输出更确定 tools = [search_tool, calculator_tool] # 初始化一个Agent，类型是“ZERO_SHOT_REACT_DESCRIPTION” # 这是一种经典的Agent类型，它使用ReAct（推理+行动）框架 agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True # 打印出Agent的思考过程 ) # 运行Agent result = agent.run("特斯拉最新的股价是多少？如果我现在买10股，大概需要多少人民币？") print(result)

在这个例子中，agent就是协调者。它会先“思考”：“用户的问题需要最新股价和货币换算。我有Search工具可以查股价，有Calculator工具可以计算总价。”然后它可能会先调用Search工具查询“Tesla stock price”，得到股价（如$210.5），再调用Calculator工具计算“210.5 * 10”，最后将美元结果换算成人民币（可能还需要调用一次Search查汇率），并组织成最终答案。

3.2 Semantic Kernel：原生区分Plugin（Skill）和Planner（Agent核心）

微软的Semantic Kernel（SK）框架对Skill和Agent的区分更为清晰。

• Skill：在SK中称为Plugin。一个Plugin包含一系列Functions（函数）。每个Function就是一个具体的Skill。
• Agent的核心：在SK中，Planner是Agent的大脑。它负责理解目标，并生成一个调用Plugin Functions的执行计划。

创建Skill（Plugin和Function）：

// 在C#中，Skill通常以类和方法的形式定义 // 文件：Plugins/WeatherPlugin.cs using Microsoft.SemanticKernel; using System.ComponentModel; public class WeatherPlugin { [KernelFunction, Description("获取指定城市的当前天气")] public string GetCurrentWeather( [Description("城市名称，例如：'Seattle', 'London'")] string city ) { // 模拟调用天气API return $"The weather in {city} is 72 degrees and sunny."; } [KernelFunction, Description("获取指定城市的天气预报")] public string GetWeatherForecast( [Description("城市名称")] string city, [Description("预报天数，例如：1 表示明天，7 表示下周")] int days ) { return $"The forecast for {city} in the next {days} days is mild with a chance of rain."; } }

使用Planner（Agent）来协调Skill：

using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.Planning; // 1. 创建内核（Kernel），这是SK的核心运行时 var kernel = Kernel.CreateBuilder() .AddOpenAIChatCompletion(modelId: "gpt-3.5-turbo", apiKey: openAIApiKey) .Build(); // 2. 导入Skill（Plugin） kernel.ImportPluginFromType<WeatherPlugin>("Weather"); // 3. 创建Planner（这里是SequentialPlanner，它会生成一个顺序执行计划） var planner = new SequentialPlanner(); // 4. 让Planner为复杂任务生成计划 var goal = "先获取北京今天的天气，然后根据天气决定是推荐室内活动还是室外活动，并给出一个具体建议。"; var plan = await planner.CreatePlanAsync(kernel, goal); Console.WriteLine("生成的计划："); Console.WriteLine(plan.ToPlanString()); // 5. 执行计划 var result = await plan.InvokeAsync(kernel); Console.WriteLine($"\n执行结果：\n{result}");

在这个例子中，SequentialPlanner就是Agent的“大脑”。它接收到“获取天气并给出建议”的目标后，会分析内核中已导入的Plugin，自动生成一个计划：先调用WeatherPlugin的GetCurrentWeather函数，然后将结果作为上下文，再调用LLM本身（作为内置的“文本生成”Skill）来生成建议。Planner完成了“思考-规划”的工作，而具体的“执行”则由Kernel来调度各个Plugin完成。

4. 实战：构建一个智能邮件助手Agent

现在，让我们动手构建一个简单的智能邮件助手Agent。它将展示Skill和Agent如何协同工作。

项目目标：用户用自然语言描述需求，Agent自动调用相应Skill处理邮件。核心Skill：

1. draft_email：根据主题和要点起草邮件正文。
2. analyze_sentiment：分析一段文本的情感倾向（积极/消极/中立）。
3. check_grammar：检查邮件正文的语法错误。

步骤1：定义Skill

# 文件：mail_skills.py import openai import language_tool_python # 一个语法检查库 # 配置你的OpenAI API Key（实际项目中应从环境变量读取） openai.api_key = "sk-..." def draft_email(subject: str, key_points: list) -> str: """根据主题和要点起草邮件正文""" prompt = f""" 你是一位专业的商务人士。请起草一封关于【{subject}】的邮件。 需要包含的要点如下： {chr(10).join(f'- {point}' for point in key_points)} 邮件要求：格式规范、语气得体、逻辑清晰。 """ try: response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[{"role": "user", "content": prompt}], temperature=0.7, ) return response.choices[0].message.content except Exception as e: return f"起草邮件时出错：{e}" def analyze_sentiment(text: str) -> dict: """分析文本情感""" prompt = f""" 请分析以下文本的情感倾向。只返回一个词：'积极'、'消极' 或 '中立'。 文本：{text} """ try: response = openai.ChatCompletion.create( model="gpt-3.5-turbo", messages=[{"role": "user", "content": prompt}], temperature=0, ) sentiment = response.choices[0].message.content.strip() return {"sentiment": sentiment, "text_sample": text[:50]} except Exception as e: return {"error": str(e)} def check_grammar(text: str) -> dict: """检查语法错误""" tool = language_tool_python.LanguageTool('en-US') # 检查英文语法 matches = tool.check(text) issues = [] for match in matches[:5]: # 只显示前5个问题 issues.append({ "message": match.message, "replacements": match.replacements[:3], # 建议的修改 "offset": match.offset, "context": match.context }) return { "original_text": text[:100], "issue_count": len(matches), "top_issues": issues }

步骤2：构建核心Agent

# 文件：mail_agent.py from typing import Dict, Any import json class MailAssistantAgent: def __init__(self, skills: Dict[str, callable]): self.skills = skills # 简单的规则引擎作为“大脑”（生产环境可用LLM替代） self.rule_brain = { "draft": ["写邮件", "起草", "草拟", "create email"], "sentiment": ["分析情感", "情绪", "态度", "sentiment"], "grammar": ["检查语法", "纠错", "grammar", "spell"] } def understand_intent(self, user_input: str) -> Dict[str, Any]: """理解用户意图（这里用简单规则，实际应用强烈建议使用LLM）""" user_input_lower = user_input.lower() intent = None params = {} if any(keyword in user_input_lower for keyword in self.rule_brain["draft"]): intent = "draft_email" # 简单解析参数（实际应用需更复杂的NLP或LLM） if "主题" in user_input: params["subject"] = user_input.split("主题")[1].split("，")[0].strip() else: params["subject"] = "商务沟通" # 提取要点（这里非常简化） params["key_points"] = ["请查收附件", "期待您的回复"] elif any(keyword in user_input_lower for keyword in self.rule_brain["sentiment"]): intent = "analyze_sentiment" params["text"] = user_input # 假设整个输入都是待分析文本 elif any(keyword in user_input_lower for keyword in self.rule_brain["grammar"]): intent = "check_grammar" # 在实际应用中，这里需要从上下文中提取待检查的文本 # 本例中我们假设用户紧接着提供了文本 params["text"] = "This is a sample text for grammar check." return {"intent": intent, "params": params} def execute(self, intent: str, params: Dict) -> str: """执行技能""" if intent not in self.skills: return f"错误：未知的意图 '{intent}'。" skill_func = self.skills[intent] try: result = skill_func(**params) return json.dumps(result, ensure_ascii=False, indent=2) except Exception as e: return f"执行技能 '{intent}' 时发生错误：{e}" def run(self, user_input: str) -> str: """运行Agent的主要入口""" print(f"[用户输入] {user_input}") # 1. 理解意图 decision = self.understand_intent(user_input) print(f"[Agent决策] 意图：{decision['intent']}, 参数：{decision['params']}") if not decision['intent']: return "抱歉，我没有理解您的需求。请尝试说‘帮我写一封邮件’或‘分析这段文字的情感’。" # 2. 执行技能 result = self.execute(decision['intent'], decision['params']) # 3. 格式化回复（这里简单返回JSON，实际应用可让LLM加工成自然语言） return f"已完成任务 `{decision['intent']}`，结果如下：\n{result}"

步骤3：运行与测试

# 文件：main.py from mail_skills import draft_email, analyze_sentiment, check_grammar from mail_agent import MailAssistantAgent # 1. 初始化技能集 skills = { "draft_email": draft_email, "analyze_sentiment": analyze_sentiment, "check_grammar": check_grammar } # 2. 创建Agent agent = MailAssistantAgent(skills) # 3. 测试不同场景 test_cases = [ "帮我写一封邮件，主题是项目延期通知", "分析一下这句话的情感：‘我对这次合作的前景感到非常乐观！’", "检查这段英文的语法" ] for query in test_cases: print("\n" + "="*50) response = agent.run(query) print(f"[Agent回复]\n{response}") print("="*50)

步骤4：运行结果示例

================================================== [用户输入] 帮我写一封邮件，主题是项目延期通知 [Agent决策] 意图：draft_email, 参数：{'subject': '项目延期通知', 'key_points': ['请查收附件', '期待您的回复']} [Agent回复] 已完成任务 `draft_email`，结果如下： "尊敬的团队成员，\n\n由于近期遇到一些不可预见的技术挑战，我们需要将原定于本月底交付的XX项目延期至下月中旬。\n\n关键要点如下：\n- 延期原因已详细记录在附件报告中。\n- 新的时间表和里程碑已更新，请查收。\n- 我们将于本周五下午3点召开项目复盘会。\n\n对于此次调整带来的不便，我们深表歉意。感谢大家的理解与持续支持。\n\n此致，\n敬礼\n[你的名字]" ==================================================

这个例子清晰地展示了分工：

• Skill (draft_email,analyze_sentiment,check_grammar)：是具体的“工人”，负责执行确定性的任务。它们被良好地封装和复用。
• Agent (MailAssistantAgent)：是“工头”或“经理”。它通过understand_intent方法（这里用了简单规则，实际是LLM）来理解用户要什么（规划），然后通过execute方法调用对应的Skill工人去执行。Agent管理了整个工作流程。

5. 常见问题与排查思路

在实际开发中，Skill和Agent的协作可能会遇到各种问题。下表列出了一些典型问题及解决方法：

6. 最佳实践与架构建议

设计一个健壮的、由Skill和Agent组成的AI系统，需要遵循一些工程最佳实践。

6.1 Skill设计原则

1. 单一职责：一个Skill只做一件事，并且做好。避免创建“瑞士军刀”式的巨型Skill。
2. 接口稳定：定义清晰的输入输出契约。一旦发布，尽量避免破坏性变更。如需变更，考虑版本化。
3. 无状态性：Skill本身不应维护会话状态。状态应由调用它的Agent通过参数传入或统一管理。
4. 防御性编程：对输入进行验证，处理所有可能的异常，并返回结构化的错误信息，而不是直接抛出异常导致Agent崩溃。
5. 完备的文档：为每个Skill编写详细的文档，说明其功能、输入参数、输出格式、错误码以及使用示例。这对于让Agent（尤其是基于LLM的Planner）理解如何调用它至关重要。

6.2 Agent设计原则

1. 明确的边界：Agent应专注于“决策”和“协调”，而非具体的业务逻辑实现。业务逻辑应下沉到Skill中。
2. 可观察性：Agent的决策过程应该是可记录、可追溯的。这有助于调试和优化。记录完整的“思考链”（Chain-of-Thought）。
3. 优雅降级：当某个Skill失败或不可用时，Agent应有备选方案（Fallback），例如调用备用Skill，或直接使用LLM的能力给出一个近似答案，而不是直接报错给用户。
4. 安全性：Agent在调用Skill（尤其是执行写操作、访问敏感数据或外部API的Skill）前，应进行权限检查和输入过滤，防止恶意或误操作。

6.3 系统架构模式

• 编排模式：一个中心化的“超级Agent”（Orchestrator）负责所有决策和Skill调用。这是最常见和直观的模式，适合中等复杂度的应用。LangChain的Agent和SK的Planner都属于此类。
• 协同模式：多个专门的Agent协同工作，每个Agent负责一个子领域，并通过消息传递进行协作。例如，一个“旅行规划Agent”可以调用“天气查询Agent”、“酒店预订Agent”和“路线规划Agent”。这种模式更模块化，适合非常复杂的系统，但设计难度更高。
• 分层模式：将Skill分层。底层是原子Skill（如“发送HTTP请求”、“查询数据库”），上层是组合Skill（由多个原子Skill组合而成，如“创建用户”），最上层是负责高级目标的Agent。这有助于复用和管理。

7. 总结：Skill是砖瓦，Agent是蓝图与工头

回到开头的奶茶店故事。现在我们可以给出一个精确的技术映射：

• Skill（技能）：就是奶茶机器人的每一个标准化动作程序，如加糖(amount)、搅拌(duration)。它们是可复用、可测试、接口明确的函数。在代码中，它们是一个个被你封装好的类、方法或API。
• Agent（智能体）：就是那位店长。他手里有一份配方（目标），并拥有思考能力（LLM或规则引擎）。他的工作是：1.理解顾客的复杂需求（“珍珠奶茶，少冰”）；2.规划出步骤序列（先泡茶，再加珍珠，糖度70%）；3.指挥机器人（调用Skill）按步骤执行；4.处理异常（如果珍珠没了，换椰果）。

两者的本质区别在于“决策权”。Skill没有决策权，它被动等待调用。Agent拥有决策权，它主动规划、调度和决策。

对于开发者而言，理解这个区别至关重要：

• 当你需要添加一个新功能时，你应该思考：这是一个新的、独立的动作吗？如果是，就创建一个新的Skill。
• 当你需要让系统处理一个新的、复杂的、需要多步骤组合的任务时，你应该去训练或调整你的Agent的决策逻辑（通常是优化提示词或微调模型）。

在AI应用开发中，Skill代表了能力的广度，Agent代表了智能的深度。一个好的AI系统，既需要丰富、可靠的Skill作为基础，也需要一个灵活、强大的Agent作为大脑，才能应对真实世界中复杂多变的任务。

建议你在设计下一个AI功能时，先问自己：“这部分是确定性的执行（Skill），还是非确定性的决策（Agent）？” 从这个角度出发，你的架构会清晰很多。