引言：Agent开发的三次范式转移

2023年，Prompt Engineering被誉为AI时代的“新编程语言”；2024年，RAG（检索增强生成）成为企业落地大模型的标配；2025年，Agent Skill工程化开始重新定义智能体的能力边界。2026年，行业共识已然清晰：AI Agent工程师的核心竞争力，正从单一维度的技术掌握，转向提示工程、检索增强与Skill工程化三位一体的系统能力。

这种演进背后是一条清晰的逻辑线：Prompt解决“如何表达”，RAG解决“能看到什么”，Skill工程化解决“能做什么” 。三者层层递进，共同构成了全栈式AI Agent工程师的能力图谱。

本文将从这三个层次出发，结合LangChain、GraphRAG等主流技术栈，通过可运行的代码示例，系统拆解AI Agent工程化的核心能力栈。

---

第一部分：Prompt Engineering——从“写指令”到“设计认知循环”

1.1 Prompt的权重为何在下降

在AI Agent落地初期，搭建师的核心工作集中在Prompt工程精细化调优——因为当时大模型的上下文推理能力存在明显短板，人工打磨的逻辑是弥补模型能力缺口的关键。

但随着GPT-4o、Claude 4.5等新一代模型推理能力的跃迁，很多原本需要人工设计的复杂多步骤Prompt逻辑，已被模型原生能力覆盖。Prompt在Agent开发中的权重已大幅下降，它现在只是系统中的一个参数，而非核心竞争力。

但这不意味着Prompt不重要——它只是从“全部”变成了“一部分”。真正重要的是：从写Prompt升级为设计Agent的认知循环。

1.2 结构化工作流：超越单次Prompt

生产环境中，直接扔一个提示词等结果的方式根本无法扩展——输出混乱、质量不可控、浪费计算资源。真正有效的做法是设计结构化的Agent工作流。

以下是一个串行链式处理的示例，将复杂任务拆解为多个小步骤，每一步的输出作为下一步的输入：

from typing import List
from helpers import run_llm

def serial_chain_workflow(input_query: str, prompt_chain: List[str]) -> List[str]:
    """运行一系列LLM调用来处理input_query，使用prompt_chain中指定的提示词列表"""
    response_chain = []
    response = input_query
    for i, prompt in enumerate(prompt_chain):
        print(f"Step {i+1}")
        response = run_llm(f"{prompt}\nInput:\n{response}")
        response_chain.append(response)
        print(f"{response}\n")
    return response_chain

# 示例：数学问题拆解
question = "Sally每小时挣12美元。昨天她只做了50分钟的保姆工作，她挣了多少钱？"
prompt_chain = [
    """只提取相关的数字信息及其使用方式。""",
    """基于提取的数字信息，只列出解决问题的步骤。""",
    """基于步骤，给出最终答案。"""
]
responses = serial_chain_workflow(question, prompt_chain)

1.3 智能路由：让模型各司其职

不是每个查询都需要动用最强大、最昂贵的模型。路由机制根据输入类型动态分配最适合的模型或处理流程：

from pydantic import BaseModel, Field
from typing import Literal, Dict
from helpers import run_llm, JSON_llm

def router_workflow(input_query: str, routes: Dict[str, str]) -> str:
    """根据输入查询选择最佳模型并返回响应"""
    ROUTER_PROMPT = """根据用户查询，选择最合适的处理路径。
    查询: {user_query}
    可用路径: {routes}
    只返回路径名称。"""
    # 简化的路由逻辑
    route = JSON_llm(ROUTER_PROMPT.format(
        user_query=input_query, 
        routes=list(routes.keys())
    ))
    return run_llm(routes[route] + "\nInput: " + input_query)

1.4 不到100行代码实现简易Agent

理解了结构化工作流之后，我们可以用不到100行代码实现一个具备工具调用能力的简易Agent。核心机制是Function Call——允许模型在生成文本的同时，以结构化格式发出调用外部工具的指令：

import json
from typing import List, Dict, Any

class SimpleAgent:
    def __init__(self, llm, tools: List[Dict[str, Any]]):
        self.llm = llm
        self.tools = {tool["name"]: tool for tool in tools}
        self.max_iterations = 5
    
    def run(self, user_input: str) -> str:
        messages = [{"role": "user", "content": user_input}]
        
        for _ in range(self.max_iterations):
            # 调用LLM，附带工具描述
            response = self.llm.chat(
                messages=messages,
                tools=self._format_tools()
            )
            
            # 检查是否有工具调用请求
            if not response.get("tool_calls"):
                return response["content"]
            
            # 执行工具调用
            for tool_call in response["tool_calls"]:
                tool_name = tool_call["function"]["name"]
                tool_args = json.loads(tool_call["function"]["arguments"])
                
                if tool_name in self.tools:
                    result = self.tools[tool_name]["function"](**tool_args)
                    messages.append({
                        "role": "tool",
                        "tool_call_id": tool_call["id"],
                        "content": str(result)
                    })
        
        return "达到最大迭代次数"
    
    def _format_tools(self):
        return [{
            "type": "function",
            "function": {
                "name": name,
                "description": tool["description"],
                "parameters": tool.get("parameters", {})
            }
        } for name, tool in self.tools.items()]

这个简易框架展示了Agent的核心循环：思考→调用工具→观察结果→继续思考。在LangChain等成熟框架中，这一模式被封装为ReAct等经典算法。

---

第二部分：RAG与GraphRAG——让Agent拥有“开卷考试”的能力

如果说Prompt解决的是“如何表达任务”，那么RAG解决的是“模型在决策时能看到什么”。RAG通过将LLM与外部知识库结合，有效解决了大模型在垂直领域的“幻觉”问题。

2.1 RAG核心架构

典型RAG系统包含三大核心模块：

• 知识存储层：向量数据库（如Chroma、FAISS）
• 检索中间层：查询重写、向量检索、结果排序
• 生成应用层：大语言模型调用、响应格式化

以下是基于LangChain构建RAG系统的完整示例：

from langchain.schema import Document
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI

# 1. 文档预处理
def preprocess_docs(raw_texts: List[str]) -> List[Document]:
    documents = []
    for i, text in enumerate(raw_texts):
        doc = Document(
            page_content=text,
            metadata={"source": f"doc_{i}", "section": "introduction"}
        )
        documents.append(doc)
    return documents

# 2. 文本分块
def chunk_documents(documents: List[Document]) -> List[Document]:
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50,
        separators=["\n\n", "\n", "。", "！", "？", "；", "，", " ", ""]
    )
    return text_splitter.split_documents(documents)

# 3. 构建向量数据库
def build_vector_store(documents: List[Document]) -> Chroma:
    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
    vectorstore = Chroma.from_documents(
        documents,
        embeddings,
        persist_directory="./vector_store"
    )
    return vectorstore

# 4. 创建RAG问答链
def create_rag_chain(vectorstore: Chroma):
    retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 4})
    
    qa_chain = RetrievalQA.from_chain_type(
        llm=ChatOpenAI(model="gpt-4", temperature=0),
        chain_type="stuff",
        retriever=retriever,
        return_source_documents=True
    )
    return qa_chain

# 完整流程
raw_texts = ["你的知识文档内容..."]
docs = preprocess_docs(raw_texts)
chunks = chunk_documents(docs)
vectorstore = build_vector_store(chunks)
qa_chain = create_rag_chain(vectorstore)

# 查询
result = qa_chain({"query": "你的问题"})
print(result["result"])
print("参考来源:", [doc.metadata for doc in result["source_documents"]])

2.2 混合检索策略

单纯的向量检索可能遗漏关键信息。混合检索结合语义检索与关键词检索（BM25），能显著提升召回率：

from langchain.retrievers import EnsembleRetriever

# 语义检索器
semantic_retriever = vectorstore.as_retriever(search_type="similarity")

# 关键词检索器（BM25）
keyword_retriever = vectorstore.as_retriever(search_type="bm25")

# 混合检索器：70%语义 + 30%关键词
hybrid_retriever = EnsembleRetriever(
    retrievers=[semantic_retriever, keyword_retriever],
    weights=[0.7, 0.3]
)

2.3 GraphRAG：当RAG遇上知识图谱

传统RAG在处理需要多跳推理的复杂查询时力不从心——信息碎片化导致全局理解缺失。GraphRAG通过引入知识图谱，将检索增强过程转化为图谱上的社区发现与分层摘要问题。

GraphRAG的核心架构包含三个组件：

• 图谱构建引擎：将非结构化文本转化为结构化知识表示
• 社区检测模块：识别图谱中具有强关联的实体群组
• 分层摘要系统：生成从实体级到社区级的多粒度摘要

以下是一个简化的GraphRAG实现框架：

from typing import List, Dict
from transformers import pipeline

# 1. 文本分块
class TokenChunker:
    def __init__(self, max_tokens: int = 512):
        self.max_tokens = max_tokens
    
    def split(self, text: str) -> List[str]:
        tokens = text.split()
        chunks = []
        current_chunk = []
        for token in tokens:
            if len(' '.join(current_chunk + [token])) > self.max_tokens:
                chunks.append(' '.join(current_chunk))
                current_chunk = [token]
            else:
                current_chunk.append(token)
        if current_chunk:
            chunks.append(' '.join(current_chunk))
        return chunks

# 2. 实体关系提取
class EntityRelationExtractor:
    def __init__(self, model_name: str = "bert-large-ner"):
        self.ner_pipeline = pipeline("ner", model=model_name)
    
    def extract(self, text: str) -> List[Dict]:
        entities = self.ner_pipeline(text)
        # 简化：提取实体及其类型
        results = []
        for ent in entities:
            results.append({
                "entity": ent["word"],
                "type": ent["entity_group"],
                "confidence": ent["score"]
            })
        return results

# 3. 知识图谱构建（简化版）
class KnowledgeGraph:
    def __init__(self):
        self.nodes = {}  # 实体节点
        self.edges = []  # 关系边
    
    def add_entity(self, entity: str, entity_type: str):
        if entity not in self.nodes:
            self.nodes[entity] = {"type": entity_type, "relations": []}
    
    def add_relation(self, source: str, target: str, relation_type: str):
        self.edges.append({"source": source, "target": target, "type": relation_type})
        if source in self.nodes:
            self.nodes[source]["relations"].append({"target": target, "type": relation_type})

# GraphRAG查询（简化版）
def graph_rag_query(query: str, kg: KnowledgeGraph, llm) -> str:
    # 1. 从查询中提取实体
    extractor = EntityRelationExtractor()
    entities = extractor.extract(query)
    
    # 2. 在知识图谱中查找相关实体及邻居
    relevant_nodes = []
    for ent in entities:
        entity_name = ent["entity"]
        if entity_name in kg.nodes:
            relevant_nodes.append(entity_name)
            # 添加一跳邻居
            for rel in kg.nodes[entity_name]["relations"]:
                relevant_nodes.append(rel["target"])
    
    # 3. 基于相关节点构建上下文
    context = f"相关知识: {', '.join(set(relevant_nodes))}\n"
    
    # 4. 使用LLM生成回答
    return llm.generate(f"{context}\n问题: {query}")

GraphRAG特别适用于需要跨段落推理的复杂场景，如“A公司收购了哪些与B业务相关的企业”这类需要多跳推理的问题。

---

第三部分：Agent Skill工程化——从“调用工具”到“封装能力”

3.1 什么是Agent Skill

Agent Skill是Anthropic推出的一种开发范式，用于为AI引入可共享的专业技能。它将经验封装到可发现、可复用的能力单元中，每个技能以文件夹形式存在，包含特定任务的指导性说明（SKILL.md文件）、脚本代码和资源等。

Skill的核心设计理念是渐进式披露（Progressive Disclosure） ——技能的信息分为三个层次，按需逐步加载：

层级	内容	加载时机
第一层：元数据	SKILL.md开头的YAML信息（名称、描述）	Agent启动时预加载
第二层：技能主体	完整的SKILL.md内容	判断技能相关时加载
第三层：附加资源	脚本文件、参考文档	需要时按需加载

这种设计避免了将过多内容一次性塞入上下文，使技能可以包含海量信息而不用担心超出上下文窗口限制。

3.2 Skill的目录结构与示例

一个标准的Agent Skill目录结构如下：

skills/
└── pdf-analyzer/
    ├── SKILL.md          # 技能主文件（含元数据 + 指令）
    ├── scripts/
    │   └── extract.py    # Python脚本
    └── references/
        └── formats.md    # 参考文档

以下是一个完整的SKILL.md示例：

---
name: api-expert
description: FastAPI开发最佳实践与规范。在构建、审查或调试FastAPI应用时使用。
metadata:
  pattern: tool-wrapper
  domain: fastapi
---

你是FastAPI开发专家。将以下规范应用到用户的代码或问题中。

## 核心规范

加载 `references/conventions.md` 获取完整的FastAPI最佳实践列表。

## 代码审查流程

1. 加载规范参考文档
2. 逐条检查用户代码是否符合规范
3. 对于每条违规，引用具体规则并提出修复建议

## 代码编写流程

1. 加载规范参考文档
2. 严格遵守每条规范
3. 为所有函数添加类型注解
4. 使用Annotated风格进行依赖注入

3.3 Google提出的5种Skill设计模式

Google通过对生态系统中Skill构建方式的研究，总结出五种反复出现的设计模式：

1. 工具包装器（Tool Wrapper）

让Agent瞬间成为任何库的专家。无需将API约定硬编码到系统提示中，而是打包到一个Skill中，Agent只在实际使用该技术时才加载上下文。

2. 生成器（Generator）

根据可重用模板生成结构化文档。通过协调“填空”过程确保输出一致性，适用于生成API文档、标准化提交消息等场景。

3. 审核员（Reviewer）

根据严重程度，对照检查清单对代码进行评分。适用于代码审查、质量检查等场景。

4. 反转（Inversion）

Agent在采取行动前先“面试”用户，收集必要信息后再执行。适用于需要明确需求后才能完成的任务。

5. 流水线（Pipeline）

通过检查点强制执行严格的多步骤工作流程。适用于合规性检查、多阶段审批等场景。

3.4 Dify平台上的Skill开发

对于不熟悉底层框架的开发者，Dify等低代码平台提供了更友好的Skill开发方式。以下是一个Dify平台上天气查询Skill的开发框架：

# Dify自定义Skill示例 - 天气查询
from typing import Dict, Any
import requests

class WeatherSkill:
    """天气查询技能"""
    
    def __init__(self):
        self.name = "weather_query"
        self.description = "查询指定城市的天气信息"
        self.parameters = {
            "city": {"type": "string", "description": "城市名称"}
        }
    
    def execute(self, city: str) -> Dict[str, Any]:
        # 调用天气API
        api_key = "YOUR_API_KEY"
        url = f"http://api.weather.com/v1/current/{city}?apikey={api_key}"
        response = requests.get(url)
        
        if response.status_code == 200:
            data = response.json()
            return {
                "city": city,
                "temperature": data["main"]["temp"],
                "condition": data["weather"][0]["description"],
                "humidity": data["main"]["humidity"]
            }
        return {"error": "无法获取天气信息"}

3.5 Skill工程化的核心价值

Agent Skill的工程化实践，本质上是将**“临时性的Prompt调优”升级为“结构化的能力封装”** 。其核心价值体现在：

1. 能力原子化：将复杂任务拆解为可复用的技能单元
2. 按需加载：通过渐进式披露机制，高效管理上下文
3. 可审计可演进：技能独立版本管理，便于迭代和回滚
4. 跨平台复用：标准化的Skill格式可在不同Agent框架间迁移

---

第四部分：工程化能力——从Demo到生产

掌握了Prompt、RAG和Skill三个核心技术层之后，还需要一套工程化体系将Agent从“能跑”推进到“可靠”。

4.1 记忆管理

Agent需要记住对话历史、用户偏好和长期知识。以下是一个结合短期记忆与长期记忆的实现：

from langchain.memory import ConversationBufferMemory, VectorStoreRetrieverMemory
from langchain.vectorstores import FAISS

# 短期记忆：对话缓存
short_term_memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

# 长期记忆：向量检索
vector_store = FAISS.from_documents([], embeddings)
retriever = vector_store.as_retriever()
long_term_memory = VectorStoreRetrieverMemory(
    retriever=retriever,
    memory_key="long_term_memory"
)

# 混合记忆
class HybridMemory:
    def __init__(self, short_term, long_term):
        self.short_term = short_term
        self.long_term = long_term
    
    def load_memory_variables(self, inputs):
        return {
            **self.short_term.load_memory_variables(inputs),
            **self.long_term.load_memory_variables(inputs)
        }

4.2 可观测性与评估

生产级Agent需要可观测、可评估、可迭代。核心关注点包括：

• 运行状态监控：实时追踪Agent的执行路径和耗时
• 质量评估：正确性、完整性、稳定性的量化指标
• 成本追踪：Token消耗、API调用次数的细粒度统计

4.3 反馈闭环

缺乏有效评估与反馈机制，是导致Agent效果不可持续优化的核心原因。反馈闭环的关键在于找到问题所在的具体节点，只调整相关模块，而非盲目修改Prompt。

典型的反馈闭环包括：

• 面向知识库的反馈：新知识入库，更新向量库
• 面向任务结构的反馈：哪一步经常出错，调整任务拆分逻辑
• 面向Skill的反馈：Skill执行失败时，更新Skill的指令或脚本

---

结语：从“工具使用者”到“系统架构师”

2026年的AI Agent工程师，不再是单纯的Prompt调优者或RAG配置者。要突破职业瓶颈，需要完成从 “工具使用者”到“系统架构师”的思维与技能栈双重升级。

真正的全栈式AI Agent工程师，应当具备：

1. Prompt层：设计结构化工作流，构建Agent的认知循环
2. RAG层：驾驭向量检索与知识图谱，让Agent拥有高质量的外部知识
3. Skill层：将能力封装为可复用的Skill，实现渐进式披露与按需加载
4. 工程化层：记忆管理、可观测性、反馈闭环，让Agent从Demo走向生产

正如行业观察者所言：“未来的核心竞争力，必然属于’AI技术+系统工程’的复合型人才，而非单纯的工具调优者。”从Prompt到RAG到Skill工程化，每一步都是能力的跃迁，每一步也都是工程化思维的深化。