28天Agent开发学习路线（2026年最新版）

$第1-3天：Agent基本概念$ (#第1-3天agent基本概念)
$第4-7天：工具调用与技能$ (#第4-7天工具调用与技能)
$第8-11天：记忆机制$ (#第8-11天记忆机制)
$第12-15天：上下文工程$ (#第12-15天上文工程)
$第16-20天：检索增强RAG$ (#第16-20天检索增强rag)
$第21-23天：多智能体协作$ (#第21-23天多智能体协作)
$第24-26天：协议与框架$ (#第24-26天协议与框架)
$第27-28天：项目实战$ (#第27-28天项目实战)

第1-3天：Agent基本概念

1.1 什么是AI Agent

**AI Agent定义：**

AI Agent是一个能够感知环境、进行推理、做出决策并执行行动的智能系统。

**核心组成：**

**感知模块**：获取环境信息
**推理模块**：基于LLM进行思考决策
**行动模块**：执行工具调用或输出结果
**记忆模块**：存储和检索历史信息

**简单示例：**

```python

from langchain_openai import ChatOpenAI

from langchain_core.prompts import ChatPromptTemplate

创建基础Agent

class SimpleAgent:

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

self.prompt = ChatPromptTemplate.from_messages([

("system", "你是一个乐于助人的AI助手"),

("user", "{input}")

])

def run(self, input_text):

chain = self.prompt | self.llm

response = chain.invoke({"input": input_text})

return response.content

使用

agent = SimpleAgent()

print(agent.run("你好！"))

```

1.2 Agent vs Workflow

| 特性 | Agent | Workflow |

|------|-------|----------|

| **决策方式** | 动态推理 | 预设流程 |

| **灵活性** | 高 | 低 |

| **适用场景** | 复杂任务、探索性工作 | 重复性任务、固定流程 |

| **学习能力** | 自适应 | 需人工配置 |

1.3 单Agent vs Multi-Agent

**单Agent：**

```python

单Agent架构

class SingleAgent:

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

def solve(self, task):

return self.llm.invoke(task).content

```

**Multi-Agent：**

```python

Multi-Agent架构（简化版）

class MultiAgentSystem:

def init(self):

self.agents = {

"researcher": ResearchAgent(),

"analyst": AnalysisAgent(),

"writer": WritingAgent()

}

def execute(self, task):

研究阶段

research_result = self.agents $"researcher"$ .run(task)

分析阶段

analysis_result = self.agents $"analyst"$ .run(research_result)

写作阶段

final_output = self.agents $"writer"$ .run(analysis_result)

return final_output

```

1.4 Agent运行流程

```

┌─────────────────────────────────────────────────────────────┐

│ Agent运行流程 │

├─────────────────────────────────────────────────────────────┤

│ 用户输入 → 解析任务 → 计划制定 → 工具调用 → 结果汇总 → 输出 │

│ │

│ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ │

│ │ 输入 │ → │ 解析 │ → │ 计划 │ → │ 执行 │ → │ 输出 │ │

│ └──────┘ └──────┘ └──────┘ └──────┘ └──────┘ │

│ ↓ ↓ │

│ ┌──────┐ ┌──────┐ │

│ │ 记忆 │ │ 工具 │ │

│ └──────┘ └──────┘ │

└─────────────────────────────────────────────────────────────┘

```

第4-7天：工具调用与技能

2.1 Tool Calling基础

**定义工具：**

```python

from langchain_core.tools import tool

from langchain_openai import ChatOpenAI

from langchain.agents import create_agent, AgentExecutor

from langchain_core.prompts import ChatPromptTemplate

@tool

def get_weather(city: str) -> str:

"""获取指定城市的天气信息"""

return f"{city} 天气晴朗，温度25°C"

@tool

def search_web(query: str) -> str:

"""搜索网络信息"""

return f"搜索结果：关于'{query}'的最新信息"

创建Agent

llm = ChatOpenAI(model="gpt-4o")

prompt = ChatPromptTemplate.from_messages([

("system", "使用提供的工具回答问题"),

("user", "{input}"),

("agent_info", "{agent_info}")

])

agent = create_agent(llm, $get_weather, search_web$ , prompt=prompt)

agent_executor = AgentExecutor(agent=agent, tools= $get_weather, search_web$ )

执行

result = agent_executor.invoke({"input": "北京的天气怎么样？"})

print(result $"output"$ )

```

2.2 Function Calling

**OpenAI函数调用：**

```python

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

定义函数

functions = [

{

"name": "get_weather",

"description": "获取天气信息",

"parameters": {

"type": "object",

"properties": {

"city": {"type": "string", "description": "城市名称"}

"required": $"city"$

}

]

绑定函数

llm_with_func = llm.bind(functions=functions)

response = llm_with_func.invoke("上海天气")

print(response)

```

2.3 MCP协议（Model Context Protocol）

**MCP标准工具定义：**

```python

from mcpsdk import Tool, ToolParameter

MCP格式定义工具

weather_tool = Tool(

name="get_weather",

description="获取天气信息",

parameters=[

ToolParameter(

name="city",

type="string",

description="城市名称",

required=True

)

]

)

MCP工具调用

async def call_mcp_tool(tool, params):

通过MCP协议调用工具

result = await mcp_client.call_tool(tool.name, params)

return result

```

第8-11天：记忆机制

3.1 Short-Term Memory

**对话历史管理：**

```python

from langchain_openai import ChatOpenAI

from langchain_core.messages import AIMessage, HumanMessage

class ShortTermMemoryAgent:

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

self.history = \[\]

def chat(self, message):

添加用户消息到历史

self.history.append(HumanMessage(content=message))

调用LLM

response = self.llm.invoke(self.history)

添加AI回复到历史

self.history.append(AIMessage(content=response.content))

限制历史长度（避免token超限）

if len(self.history) > 20:

self.history = self.history $-10:$

return response.content

使用

agent = ShortTermMemoryAgent()

print(agent.chat("你好"))

print(agent.chat("还记得我是谁吗？"))

```

3.2 Long-Term Memory

**向量记忆系统：**

```python

from langchain_openai import OpenAIEmbeddings

from langchain_community.vectorstores import Chroma

class LongTermMemory:

def init(self):

self.embeddings = OpenAIEmbeddings()

self.vector_store = Chroma(

collection_name="agent_memory",

embedding_function=self.embeddings,

persist_directory="./memory_db"

)

def add_memory(self, content, metadata=None):

self.vector_store.add_texts( $content$ , metadatas= $metadata$ if metadata else None)

self.vector_store.persist()

def retrieve_memory(self, query, k=3):

results = self.vector_store.similarity_search(query, k=k)

return $doc.page_content for doc in results$

使用

memory = LongTermMemory()

memory.add_memory("用户喜欢科技类话题")

memory.add_memory("用户住在北京")

print(memory.retrieve_memory("用户的兴趣"))

```

3.3 Memory压缩

**记忆压缩技术：**

```python

from langchain_openai import ChatOpenAI

from langchain_core.prompts import ChatPromptTemplate

class MemoryCompressor:

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

self.prompt = ChatPromptTemplate.from_template(

"压缩以下对话历史，保留关键信息：\n{history}\n\n压缩结果："

)

def compress(self, history):

chain = self.prompt | self.llm

compressed = chain.invoke({"history": history})

return compressed.content

使用

compressor = MemoryCompressor()

long_history = "用户：你好...（1000字对话）"

compressed = compressor.compress(long_history)

print(compressed)

```

第12-15天：上下文工程

4.1 Prompt Engineering

**有效提示设计：**

```python

from langchain_core.prompts import ChatPromptTemplate

结构化提示

prompt = ChatPromptTemplate.from_messages([

("system", """你是专业的数据分析师，遵循以下步骤：

分析用户问题
识别关键数据需求
提供清晰的分析框架
使用结构化输出"""),

("user", "{question}")

])

带有示例的提示（Few-shot）

few_shot_prompt = ChatPromptTemplate.from_messages([

("system", "根据例子回答问题"),

("human", "2+2=?"),

("ai", "4"),

("human", "3*5=?"),

("ai", "15"),

("human", "{question}"),

("ai", "")

])

```

4.2 Context Window管理

**上下文窗口管理策略：**

```python

class ContextManager:

def init(self, max_tokens=4096):

self.max_tokens = max_tokens

self.context = \[\]

def add_message(self, role, content):

message = {"role": role, "content": content}

self.context.append(message)

检查token数量

total_tokens = self._count_tokens()

while total_tokens > self.max_tokens and len(self.context) > 1:

移除最早的非系统消息

self.context.pop(1) # 保留系统消息（索引0）

total_tokens = self._count_tokens()

def _count_tokens(self):

简化的token计数

return sum(len(msg $"content"$ ) // 4 for msg in self.context)

def get_context(self):

return self.context

使用

manager = ContextManager()

manager.add_message("system", "你是助手")

manager.add_message("user", "问题1")

manager.add_message("assistant", "回答1")

... 添加更多消息

```

4.3 历史消息裁剪

**智能裁剪策略：**

```python

def smart_truncate_history(history, max_tokens=8192):

"""

智能裁剪历史消息，保留重要信息

"""

total_tokens = 0

preserved = \[\]

从后往前遍历

for msg in reversed(history):

msg_tokens = len(msg.content) // 4

if total_tokens + msg_tokens <= max_tokens:

preserved.insert(0, msg)

total_tokens += msg_tokens

else:

对长消息进行裁剪

if msg_tokens > max_tokens:

只保留消息的开头和结尾

max_chars = max_tokens * 4

truncated = msg.content $:max_chars//2$ + "..." + msg.content $-max_chars//2:$

preserved.insert(0, type(msg)(content=truncated))

break

return preserved

```

第16-20天：检索增强RAG

5.1 Embedding与向量化

**向量化基础：**

```python

from langchain_openai import OpenAIEmbeddings

创建嵌入模型

embeddings = OpenAIEmbeddings(

model="text-embedding-3-small",

dimensions=1536

)

生成向量

text = "AI Agent是一种智能系统"

vector = embeddings.embed_query(text)

print(f"向量维度：{len(vector)}")

print(f"向量前10个值：{vector $:10$ }")

```

5.2 Chunking策略

**文档分割：**

```python

from langchain_text_splitters import RecursiveCharacterTextSplitter

创建分割器

text_splitter = RecursiveCharacterTextSplitter(

chunk_size=500,

chunk_overlap=50,

separators= $"\\n\\n", "\\n", "。", "！", "？", " ", ""$

)

分割文档

document = """人工智能（Artificial Intelligence，AI）...（长文档）"""

chunks = text_splitter.split_text(document)

print(f"分割成 {len(chunks)} 个片段")

```

5.3 Retrieval检索

**完整RAG流程：**

```python

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

from langchain_community.document_loaders import TextLoader

from langchain_text_splitters import RecursiveCharacterTextSplitter

from langchain_community.vectorstores import Chroma

from langchain_core.prompts import ChatPromptTemplate

from langchain_core.runnables import RunnablePassthrough

from langchain_core.output_parsers import StrOutputParser

1. 加载文档

loader = TextLoader("knowledge.txt")

docs = loader.load()

2. 分割

text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)

split_docs = text_splitter.split_documents(docs)

3. 向量化存储

embeddings = OpenAIEmbeddings()

vector_store = Chroma.from_documents(split_docs, embeddings)

4. 创建检索器

retriever = vector_store.as_retriever(k=4)

5. 构建RAG链

prompt = ChatPromptTemplate.from_messages([

("system", "使用以下上下文回答问题：\n{context}"),

("user", "{question}")

])

llm = ChatOpenAI(model="gpt-4o")

rag_chain = (

{"context": retriever, "question": RunnablePassthrough()}

| prompt

| llm

| StrOutputParser()

)

6. 查询

result = rag_chain.invoke("什么是AI Agent？")

print(result)

```

5.4 Rerank重排序

**Cross-Encoder重排序：**

```python

from langchain_community.cross_encoders import CrossEncoderReranker

创建重排序器

reranker = CrossEncoderReranker(

model_name="cross-encoder/ms-marco-MiniLM-L-6-v2"

)

先检索，再重排序

retrieved_docs = retriever.get_relevant_documents(query)

reranked_docs = reranker.rerank(query, retrieved_docs, top_n=3)

```

第21-23天：多智能体协作

6.1 Multi-Agent基础架构

**角色定义：**

```python

from langchain_openai import ChatOpenAI

from langchain_core.prompts import ChatPromptTemplate

class AgentRole:

def init(self, role_name, system_prompt):

self.role_name = role_name

self.llm = ChatOpenAI(model="gpt-4o")

self.prompt = ChatPromptTemplate.from_messages([

("system", system_prompt),

("user", "{input}")

])

def run(self, input_text):

chain = self.prompt | self.llm

response = chain.invoke({"input": input_text})

return response.content

定义不同角色

researcher = AgentRole(

"研究员",

"你是专业研究员，擅长收集和整理信息"

)

analyst = AgentRole(

"分析师",

"你是数据分析专家，擅长分析和总结"

)

writer = AgentRole(

"作家",

"你是专业作家，擅长撰写清晰易懂的报告"

)

```

6.2 Router路由

**任务路由：**

```python

from langchain_core.runnables import RunnableBranch

定义路由条件

router = RunnableBranch(

(lambda x: "研究" in x $"task"$ , researcher.run),

(lambda x: "分析" in x $"task"$ , analyst.run),

(lambda x: "写" in x $"task"$ or "报告" in x $"task"$ , writer.run),

lambda x: f"未知任务类型: {x $'task'$ }"

)

使用

result = router.invoke({"task": "研究AI最新趋势"})

print(result)

```

6.3 Supervisor监督者

**监督者模式：**

```python

class Supervisor:

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

self.agents = {

"researcher": researcher,

"analyst": analyst,

"writer": writer

}

def assign_task(self, task):

判断应该调用哪个agent

assignment_prompt = ChatPromptTemplate.from_template(

"根据任务判断应该调用哪个agent：{task}\n"

"可选agent：researcher（研究）、analyst（分析）、writer（写作）\n"

"只返回agent名称"

)

chain = assignment_prompt | self.llm

agent_name = chain.invoke({"task": task}).content.strip()

调用对应agent

if agent_name in self.agents:

return self.agents $agent_name$ .run(task)

else:

return f"无法处理此任务"

使用

supervisor = Supervisor()

result = supervisor.assign_task("分析AI市场报告")

print(result)

```

6.4 Agent通信

**Agent间消息传递：**

```python

class MessagePassing:

@staticmethod

def format_message(sender, receiver, content):

return f"""来自 {sender} 的消息：

{content}

请 {receiver} 处理此信息。

"""

示例：研究员向分析师传递信息

research_result = researcher.run("研究AI趋势")

message = MessagePassing.format_message("研究员", "分析师", research_result)

analysis_result = analyst.run(message)

print(analysis_result)

```

第24-26天：开发框架详解

7.1 LangChain v1.3.0框架详解

**LangChain核心架构：**

LangChain是一个用于构建LLM应用的全面框架，提供了组件化、模块化的开发方式。

🎯 基本原理（通俗理解）

**LangChain就像一个"智能管家系统"：**

想象你有一个超级智能的管家，他可以：

📝 **理解你的指令**（Prompt模板）
🔧 **使用各种工具**（Tools集成）
💭 **记住之前的对话**（Memory记忆）
🤔 **思考并做决策**（Agents智能体）
🔗 **按流程完成任务**（Chains链式调用）

**核心工作流程：**

```

用户提问 → Prompt模板处理 → LLM理解 →

选择工具执行 → 记忆存储 → 返回结果

```

🔧 实现逻辑（简单描述）

**1. 组件化设计（像搭积木）**

每个组件（Models、Prompts、Tools）都是独立的"积木块"
可以自由组合，搭建不同的应用
例如：`Prompt + LLM + Tool = 智能问答系统`

**2. LCEL链式语法（像流水线）**

```python

传统方式（复杂）

result = llm.invoke(prompt.format(question))

LCEL方式（简单，像流水线）

chain = prompt | llm | parser

result = chain.invoke({"question": "..."})

```

`|` 操作符就像流水线的传送带
数据自动从一个组件流向下一个组件

**3. Agent决策机制（像人类思考）**

```

观察问题 → 分析需要什么工具 →

调用工具 → 观察结果 →

继续思考或完成任务

```

**4. Memory记忆机制（像笔记本）**

短期记忆：记住最近几轮对话（像便利贴）
长期记忆：存储重要信息到向量数据库（像档案柜）

**核心组件详解：**

1. Models（模型层）

**Models是LangChain的基础，负责与LLM交互。**

**支持的模型类型：**

**Chat Models**：对话型模型（GPT-4o、Claude、Gemini）
**LLMs**：文本补全模型（旧版API）
**Embeddings**：嵌入模型（text-embedding-3-small）

**详细参数解析表：**

| 参数 | 类型 | 默认值 | 说明 | 示例 |

|------|------|--------|------|------|

**代码示例：**

```python

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

Chat Model配置

chat_model = ChatOpenAI(

model="gpt-4o",

temperature=0.0, # 确定性输出

max_tokens=4096, # 最大输出长度

timeout=30, # 30秒超时

frequency_penalty=0.5, # 减少重复内容

presence_penalty=0.3 # 鼓励新话题

)

Embedding Model配置

embedding_model = OpenAIEmbeddings(

model="text-embedding-3-small",

dimensions=1536 # 向量维度

)

调用示例

response = chat_model.invoke("你好")

vector = embedding_model.embed_query("AI Agent")

```

2. Prompts（提示模板）

**Prompts负责管理和优化提示词。**

**核心类型：**

**ChatPromptTemplate**：对话型提示模板
**PromptTemplate**：简单字符串模板
**FewShotPromptTemplate**：少样本学习模板
**PipelinePromptTemplate**：管道式组合模板

**详细参数解析表：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

| `template` | str | 模板字符串 | "你好{name}" |

| `partial_variables` | dict | 预填充变量 | {"name": "张三"} |

**代码示例：**

```python

from langchain_core.prompts import ChatPromptTemplate, PromptTemplate

ChatPromptTemplate（推荐）

chat_prompt = ChatPromptTemplate.from_messages([

("system", "你是{role}，擅长{skill}"),

("human", "{question}"),

("ai", "{previous_answer}")

])

PromptTemplate（简单场景）

simple_prompt = PromptTemplate(

template="请用{language}翻译：{text}",

input_variables= $"language", "text"$

)

FewShotPromptTemplate（少样本学习）

from langchain_core.prompts import FewShotChatMessagePromptTemplate

examples = [

{"input": "2+2", "output": "4"},

{"input": "3*5", "output": "15"}

]

few_shot_prompt = FewShotChatMessagePromptTemplate(

example_prompt=ChatPromptTemplate.from_messages([

("human", "{input}"),

("ai", "{output}")

]),

examples=examples

)

使用

formatted = chat_prompt.invoke({

"role": "Python专家",

"skill": "编程教学",

"question": "解释装饰器"

})

```

3. Chains（链式调用）

**Chains将多个组件串联成工作流。**

**核心类型：**

**LCEL Chain**：使用 `|` 操作符构建（推荐）
**Sequential Chain**：顺序执行链
**Router Chain**：路由选择链

**LCEL操作符详解：**

| 操作符 | 说明 | 示例 |

|--------|------|------|

| `|` | 链式连接 | `prompt | llm | parser` |

| `RunnablePassthrough` | 透传数据 | `{"query": RunnablePassthrough()}` |

| `RunnableParallel` | 并行执行 | `{"a": chain1, "b": chain2}` |

| `RunnableBranch` | 条件分支 | `branch(condition, chain1, chain2)` |

| `RunnableLambda` | 自定义函数 | `RunnableLambda(lambda x: x.upper())` |

**代码示例：**

```python

from langchain_core.runnables import RunnablePassthrough, RunnableParallel, RunnableLambda

LCEL基础链

chain = prompt | llm | output_parser

RunnablePassthrough（透传）

chain = (

{"context": retriever, "question": RunnablePassthrough()}

| prompt

| llm

)

RunnableParallel（并行）

parallel_chain = RunnableParallel({

"translation": translation_chain,

"summary": summary_chain,

"keywords": keyword_chain

})

RunnableLambda（自定义函数）

def format_output(x):

return f"结果：{x}"

chain = (

prompt

| llm

| RunnableLambda(format_output)

)

RunnableBranch（条件分支）

from langchain_core.runnables import RunnableBranch

branch_chain = RunnableBranch(

(lambda x: "数学" in x, math_chain),

(lambda x: "翻译" in x, translation_chain),

default_chain # 默认分支

)

```

4. Agents（智能代理）

**Agents是动态决策和执行的核心。**

**Agent类型：**

**OpenAI Tools Agent**：使用OpenAI工具调用
**Structured Chat Agent**：结构化对话Agent
**ReAct Agent**：推理-行动循环
**Plan-and-Execute Agent**：计划执行Agent

**Agent核心参数：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

| `max_iterations` | int | 最大迭代次数 | 10 |

**代码示例：**

```python

from langchain.agents import create_agent, AgentExecutor

from langchain_core.tools import tool

定义工具

@tool

def search(query: str) -> str:

"""搜索网络信息"""

return f"搜索结果：{query}"

@tool

def calculate(expression: str) -> str:

"""执行数学计算"""

return str(eval(expression))

创建Agent

llm = ChatOpenAI(model="gpt-4o")

agent = create_agent(llm, $search, calculate$ )

AgentExecutor配置

executor = AgentExecutor(

agent=agent,

tools= $search, calculate$ ,

max_iterations=10, # 最大迭代次数

handle_parsing_errors=True, # 处理解析错误

verbose=True, # 显示详细日志

max_execution_time=60 # 最大执行时间（秒）

)

执行

result = executor.invoke({"input": "搜索AI趋势并计算2+3"})

```

5. Memory（记忆管理）

**Memory负责存储和检索对话历史。**

**Memory类型：**

**ConversationBufferMemory**：完整对话历史
**ConversationBufferWindowMemory**：窗口式记忆
**ConversationSummaryMemory**：摘要式记忆
**VectorStoreMemory**：向量存储记忆

**详细参数解析表：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

| `max_token_limit` | int | 最大Token限制 | 2000 |

| `k` | int | 窗口大小 | 5 |

| `ai_prefix` | str | AI前缀 | "AI" |

**代码示例：**

```python

from langchain.memory import (

ConversationBufferMemory,

ConversationBufferWindowMemory,

ConversationSummaryMemory

)

ConversationBufferMemory（完整历史）

buffer_memory = ConversationBufferMemory(

memory_key="history",

return_messages=True

)

ConversationBufferWindowMemory（窗口记忆）

window_memory = ConversationBufferWindowMemory(

memory_key="history",

k=5 # 只保留最近5轮对话

)

ConversationSummaryMemory（摘要记忆）

summary_memory = ConversationSummaryMemory(

llm=ChatOpenAI(model="gpt-4o"),

memory_key="history",

max_token_limit=1000

)

使用

memory.save_context({"input": "你好"}, {"output": "你好！"})

history = memory.load_memory_variables({})

print(history $"history"$ )

```

6. Tools（工具集成）

**Tools扩展Agent的能力边界。**

**Tool定义方式：**

**@tool装饰器**：推荐方式
**StructuredTool**：结构化工具
**Tool类**：基础工具类

**Tool参数详解：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

**代码示例：**

```python

from langchain_core.tools import tool, StructuredTool

from pydantic import BaseModel, Field

@tool装饰器（推荐）

@tool

def get_weather(city: str) -> str:

"""获取指定城市的天气

Args:

city: 城市名称（如：北京、上海）

Returns:

天气信息字符串

"""

return f"{city} 天气晴朗，温度25°C"

StructuredTool（复杂参数）

class SearchArgs(BaseModel):

query: str = Field(description="搜索关键词")

num_results: int = Field(default=5, description="返回结果数量")

def search_func(args: SearchArgs) -> str:

return f"搜索'{args.query}'，返回{args.num_results}条结果"

search_tool = StructuredTool(

name="search",

description="搜索网络信息",

func=search_func,

args_schema=SearchArgs

)

Tool类（基础方式）

from langchain_core.tools import Tool

basic_tool = Tool(

name="calculator",

description="执行数学计算",

func=lambda x: str(eval(x))

)

```

**基础示例：**

```python

LangChain v1.3.0 基础示例

from langchain_openai import ChatOpenAI

from langchain_core.prompts import ChatPromptTemplate

from langchain_core.output_parsers import StrOutputParser

1. 创建LLM实例

llm = ChatOpenAI(

model="gpt-4o",

temperature=0.7,

api_key="your-api-key"

)

2. 创建提示模板

prompt = ChatPromptTemplate.from_messages([

("system", "你是一个专业的{subject}助手"),

("user", "{question}")

])

3. 创建输出解析器

output_parser = StrOutputParser()

4. 构建LCEL链

chain = prompt | llm | output_parser

5. 执行

result = chain.invoke({

"subject": "Python编程",

"question": "解释什么是装饰器"

})

print(result)

```

**LCEL（LangChain Expression Language）：**

```python

from langchain_core.runnables import RunnablePassthrough

LCEL链式构建

chain = (

{"context": retriever, "question": RunnablePassthrough()}

| prompt

| llm

| StrOutputParser()

)

```

**工具调用示例：**

```python

from langchain_core.tools import tool

from langchain.agents import create_agent, AgentExecutor

from langchain_core.prompts import ChatPromptTemplate

定义工具

@tool

def calculate(expression: str) -> str:

"""执行数学计算"""

try:

result = eval(expression)

return str(result)

except Exception as e:

return f"计算错误：{e}"

@tool

def search_browser(query: str) -> str:

"""搜索网页信息"""

return f"搜索结果：关于'{query}'的信息"

创建Agent

llm = ChatOpenAI(model="gpt-4o")

prompt = ChatPromptTemplate.from_messages([

("system", "使用工具回答问题"),

("user", "{input}"),

("agent_info", "{agent_info}")

])

agent = create_agent(llm, $calculate, search_browser$ , prompt=prompt)

executor = AgentExecutor(

agent=agent,

tools= $calculate, search_browser$ ,

verbose=True

)

执行

result = executor.invoke({"input": "计算 2+3*5 并搜索相关信息"})

print(result $"output"$ )

```

**Memory记忆管理（v1.3.0最新语法）：**

```python

from langchain_core.messages import HumanMessage, AIMessage

from langchain_core.runnables import RunnablePassthrough

from langchain_openai import ChatOpenAI

方法1：使用消息列表管理对话历史（推荐）

class ConversationMemory:

def init(self, max_messages=20):

self.messages = \[\]

self.max_messages = max_messages

def add_user_message(self, content):

self.messages.append(HumanMessage(content=content))

self._trim_history()

def add_ai_message(self, content):

self.messages.append(AIMessage(content=content))

self._trim_history()

def _trim_history(self):

if len(self.messages) > self.max_messages:

self.messages = self.messages $-self.max_messages:$

def get_messages(self):

return self.messages

使用示例

memory = ConversationMemory(max_messages=20)

memory.add_user_message("你好")

memory.add_ai_message("你好！有什么可以帮你的吗？")

memory.add_user_message("我叫张三")

print(memory.get_messages())

方法2：使用LCEL构建带记忆的链（v1.3.0推荐）

llm = ChatOpenAI(model="gpt-4o")

def get_conversation_history(messages):

return "\n".join( $f"{m.type}: {m.content}" for m in messages$ )

memory_chain = (

RunnablePassthrough.assign(

history=lambda x: get_conversation_history(x.get("history", \[\]))

)

| (lambda x: f"对话历史：\n{x $'history'$ }\n\n当前问题：{x $'input'$ }")

| llm

)

执行

result = memory_chain.invoke({

"input": "我叫张三",

"history": $HumanMessage(content="你好"), AIMessage(content="你好！")$

})

print(result.content)

```

**向量记忆系统（长期记忆）：**

```python

from langchain_openai import OpenAIEmbeddings

from langchain_community.vectorstores import Chroma

from langchain_core.documents import Document

class VectorMemory:

def init(self):

self.embeddings = OpenAIEmbeddings()

self.vector_store = Chroma(

collection_name="agent_memory",

embedding_function=self.embeddings,

persist_directory="./memory_db"

)

def add_memory(self, content, metadata=None):

doc = Document(page_content=content, metadata=metadata or {})

self.vector_store.add_documents( $doc$ )

self.vector_store.persist()

def retrieve_memory(self, query, k=3):

results = self.vector_store.similarity_search(query, k=k)

return $doc.page_content for doc in results$

使用

memory = VectorMemory()

memory.add_memory("用户喜欢科技类话题", {"category": "interest"})

memory.add_memory("用户住在北京", {"category": "location"})

print(memory.retrieve_memory("用户的兴趣爱好"))

```

7.2 LangGraph v1.2.0框架详解

**LangGraph核心概念：**

LangGraph是LangChain的扩展，专门用于构建有状态、多Actor的工作流。

🎯 基本原理（通俗理解）

**LangGraph就像一个"智能工厂流水线"：**

想象一个现代化的工厂，有多个工作站：

📍 **每个工作站是一个节点**（Node）
🔀 **工作站之间有传送带连接**（Edge）
📊 **每个产品都有状态记录**（State）
🛑 **可以暂停检查质量**（Interrupt）
💾 **生产进度可以保存**（Checkpoint）

**核心工作流程：**

```

输入数据 → 进入状态图 →

经过多个节点处理 →

根据条件选择路径 →

输出结果或继续循环

```

🔧 实现逻辑（简单描述）

**1. 状态图设计（像地图导航）**

```python

定义状态（像旅行背包）

class AgentState(TypedDict):

messages: list # 对话记录

current_step: str # 当前位置

result: str # 最终结果

构建图（像绘制地图）

workflow = StateGraph(AgentState)

workflow.add_node("start", start_node) # 起点

workflow.add_node("process", process_node) # 处理站

workflow.add_node("end", end_node) # 终点

```

**2. 条件分支（像路口选择）**

```

到达路口 → 判断条件 →

选择路径A或路径B →

继续前进

```

```python

条件路由（像GPS导航）

workflow.add_conditional_edges(

"router",

check_condition, # 判断函数

{

"path_a": "node_a", # 条件1走A路

"path_b": "node_b" # 条件2走B路

}

)

```

**3. 状态持久化（像游戏存档）**

**Checkpoint**：保存当前进度（像游戏存档点）
**恢复执行**：从存档点继续（像加载游戏）
**断点续传**：中断后可以继续（像下载续传）

**4. 人工介入（像质检环节）**

```python

在关键节点暂停，等待人工确认

app = workflow.compile(

interrupt_before= $"approval"$ # 在审批节点前暂停

)

```

**核心组件详解：**

1. StateGraph（状态图）

**StateGraph是LangGraph的核心，管理整个工作流的状态。**

**StateGraph参数详解：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

**状态定义详解：**

```python

from typing import TypedDict, Annotated

from operator import add

基础状态定义

class BasicState(TypedDict):

query: str

result: str

使用Annotated的Reducer状态

class ReducerState(TypedDict):

Annotated $list, add$ 表示列表会自动合并

messages: Annotated $list\[str$ , add]

每个节点返回的list会自动追加到messages

errors: Annotated $list\[str$ , add]

复杂状态定义

class ComplexState(TypedDict):

普通字段（每次更新会覆盖）

current_step: str

iteration: int

approved: bool

Reducer字段（自动合并）

history: Annotated $list\[dict$ , add]

嵌套状态

metadata: dict $str, str$

```

**StateGraph构建流程：**

```python

from langgraph.graph import StateGraph, END

步骤1：定义状态

class WorkflowState(TypedDict):

input: str

processed: bool

output: str

步骤2：创建StateGraph

workflow = StateGraph(WorkflowState)

步骤3：添加节点

workflow.add_node("process", process_node)

workflow.add_node("validate", validate_node)

步骤4：设置入口点

workflow.set_entry_point("process")

步骤5：添加边

workflow.add_edge("process", "validate")

workflow.add_edge("validate", END)

步骤6：编译

app = workflow.compile()

步骤7：执行

result = app.invoke({"input": "test", "processed": False, "output": ""})

```

2. Nodes（节点）

**Nodes是StateGraph中的处理单元，执行具体任务。**

**Node类型：**

**Function Node**：普通函数节点
**LLM Node**：LLM调用节点
**Tool Node**：工具调用节点
**Human Node**：人工介入节点

**Node参数详解：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

| `retry` | int | 重试次数 | 3 |

**Node定义示例：**

```python

from langgraph.pregel import TimeoutPolicy

Function Node（基础节点）

def process_node(state: WorkflowState) -> dict:

"""处理节点"""

processed_data = f"Processed: {state $'input'$ }"

return {

"processed": True,

"output": processed_data

}

LLM Node（LLM调用节点）

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

def llm_node(state: WorkflowState) -> dict:

"""LLM处理节点"""

response = llm.invoke(state $"input"$ )

return {"output": response.content}

Tool Node（工具调用节点）

def tool_node(state: WorkflowState) -> dict:

"""工具执行节点"""

result = search_tool.invoke(state $"input"$ )

return {"output": result}

添加节点（带超时）

workflow.add_node(

"process",

process_node,

timeout=TimeoutPolicy(

run_timeout=60, # 执行超时60秒

overall_timeout=120 # 总超时120秒

)

添加节点（带重试）

workflow.add_node(

"process",

process_node,

retry=3 # 失败后重试3次

)

```

3. Edges（边）

**Edges连接节点，定义工作流路径。**

**Edge类型：**

**Normal Edge**：固定连接
**Conditional Edge**：条件分支
**Dynamic Edge**：动态路由

**Edge参数详解：**

| 方法 | 参数 | 说明 | 示例 |

|------|------|------|------|

**Edge定义示例：**

```python

Normal Edge（固定边）

workflow.add_edge("process", "validate")

workflow.add_edge("validate", END)

Conditional Edge（条件边）

def should_continue(state: WorkflowState) -> str:

"""判断是否继续"""

if state $"iteration"$ < 5:

return "continue"

else:

return "end"

workflow.add_conditional_edges(

"process",

should_continue,

{

"continue": "process", # 继续循环

"end": END # 结束

}

)

Dynamic Edge（动态路由）

def route_by_type(state: WorkflowState) -> str:

"""根据类型动态路由"""

query_type = classify_query(state $"input"$ )

return query_type

workflow.add_conditional_edges(

"router",

route_by_type,

{

"research": "research_node",

"analysis": "analysis_node",

"write": "write_node"

}

)

```

4. Checkpointer（持久化）

**Checkpointer保存和恢复状态，支持断点续传。**

**Checkpointer类型：**

**MemorySaver**：内存保存（开发测试）
**PostgresSaver**：PostgreSQL持久化（生产环境）
**RedisSaver**：Redis持久化（分布式）

**Checkpointer参数详解：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

| `table_name` | str | 表名 | "checkpoints" |

**Checkpointer使用示例：**

```python

from langgraph.checkpoint.memory import MemorySaver

from langgraph.checkpoint.postgres import PostgresSaver

import psycopg2

MemorySaver（开发测试）

memory_checkpointer = MemorySaver()

app = workflow.compile(checkpointer=memory_checkpointer)

执行并保存状态

result = app.invoke(

{"input": "test"},

config={"configurable": {"thread_id": "session_1"}}

)

恢复状态

restored = app.invoke(

None, # 不传输入，使用保存的状态

config={"configurable": {"thread_id": "session_1"}}

)

PostgresSaver（生产环境）

conn = psycopg2.connect(

host="localhost",

database="langgraph",

user="user",

password="password"

)

postgres_checkpointer = PostgresSaver(conn)

app = workflow.compile(checkpointer=postgres_checkpointer)

执行

result = app.invoke(

{"input": "production"},

config={"configurable": {"thread_id": "user_123"}}

)

```

5. Interrupt（人工介入）

**Interrupt在特定节点暂停，等待人工确认。**

**Interrupt参数详解：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

**Interrupt使用示例：**

```python

在approval节点前暂停

app = workflow.compile(

checkpointer=checkpointer,

interrupt_before= $"approval"$ # 在approval节点前暂停

)

第一次执行（会暂停在approval前）

result = app.invoke(

{"input": "test"},

config={"configurable": {"thread_id": "user_123"}}

)

此时状态：current_step = "approval"（暂停）

人工确认后继续执行

result = app.invoke(

None,

config={"configurable": {"thread_id": "user_123"}}

)

```

6. TimeoutPolicy（超时策略）

**TimeoutPolicy控制节点执行时间。**

**TimeoutPolicy参数详解：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

| `run_timeout` | int | 单次执行超时（秒） | 60 |

| `overall_timeout` | int | 总超时（秒） | 120 |

**TimeoutPolicy使用示例：**

```python

from langgraph.pregel import TimeoutPolicy

定义超时策略

timeout_policy = TimeoutPolicy(

run_timeout=60, # 单次执行最多60秒

overall_timeout=120, # 总执行最多120秒

on_timeout="raise" # 超时抛出异常

)

添加节点（带超时）

workflow.add_node(

"long_process",

long_process_node,

timeout=timeout_policy

)

```

**状态图基础示例：**

```python

from langgraph.graph import StateGraph, END

from typing import TypedDict, Annotated

from operator import add

定义状态

class AgentState(TypedDict):

messages: Annotated $list, add$

current_step: str

result: str

定义节点

def node_1(state):

return {"messages": $"Node 1 processed"$ , "current_step": "step1"}

def node_2(state):

return {"messages": $"Node 2 processed"$ , "current_step": "step2"}

def node_3(state):

return {"messages": $"Node 3 processed"$ , "result": "completed"}

构建图

workflow = StateGraph(AgentState)

workflow.add_node("process1", node_1)

workflow.add_node("process2", node_2)

workflow.add_node("finalize", node_3)

添加边

workflow.add_edge("process1", "process2")

workflow.add_edge("process2", "finalize")

workflow.add_edge("finalize", END)

编译

app = workflow.compile()

执行

result = app.invoke({"messages": \[\], "current_step": "start", "result": ""})

print(result)

```

**条件分支示例（v1.2.0最新语法）：**

```python

from langgraph.graph import StateGraph, END

from typing import TypedDict

class ConditionalState(TypedDict):

query: str

needs_research: bool

needs_analysis: bool

final_result: str

def check_needs(state: ConditionalState) -> str:

"""路由函数，返回下一个节点的名称"""

query = state $"query"$ .lower()

if "分析" in query or "研究" in query:

return "research"

return "direct"

def research_node(state: ConditionalState) -> dict:

return {"needs_research": True, "final_result": "Research completed"}

def direct_node(state: ConditionalState) -> dict:

return {"needs_analysis": False, "final_result": "Direct response"}

def analyze_node(state: ConditionalState) -> dict:

return {"needs_analysis": True, "final_result": "Analysis completed"}

构建工作流

workflow = StateGraph(ConditionalState)

workflow.add_node("router", check_needs)

workflow.add_node("research", research_node)

workflow.add_node("direct", direct_node)

workflow.add_node("analyze", analyze_node)

设置入口点

workflow.set_entry_point("router")

添加条件边（v1.2.0最新语法）

workflow.add_conditional_edges(

"router",

check_needs,

{

"research": "research",

"direct": "direct"

}

)

添加固定边

workflow.add_edge("research", "analyze")

workflow.add_edge("analyze", END)

workflow.add_edge("direct", END)

编译

app = workflow.compile()

执行

result = app.invoke({"query": "分析AI趋势"})

print(result)

```

**持久化和Checkpoint：**

```python

from langgraph.checkpoint.memory import MemorySaver

创建Checkpointer

checkpointer = MemorySaver()

编译时添加Checkpointer

app = workflow.compile(checkpointer=checkpointer)

执行并保存状态

result = app.invoke(

{"query": "分析AI趋势"},

config={"configurable": {"thread_id": "user_123"}}

)

恢复状态

restored = app.invoke(

None, # 不传输入，使用保存的状态

config={"configurable": {"thread_id": "user_123"}}

)

```

7.3 CrewAI框架详解

**CrewAI核心概念：**

CrewAI是一个专注于多Agent协作的框架，通过角色分工实现复杂任务。

🎯 基本原理（通俗理解）

**CrewAI就像一个"虚拟团队协作系统"：**

想象你组建了一个虚拟团队，每个成员都有明确的角色：

👨‍💼 **研究员**：负责收集信息
📊 **分析师**：负责分析数据
✍️ **作家**：负责撰写报告
🤝 **项目经理**：协调团队工作

**核心工作流程：**

```

定义任务 → 分配给合适的Agent →

Agent执行任务 → 输出结果 →

下一个Agent继续处理 → 最终完成

```

🔧 实现逻辑（简单描述）

**1. 角色分工（像公司组织架构）**

```python

每个Agent就像一个员工

researcher = Agent(

role="研究员", # 职位

goal="收集信息", # 工作目标

backstory="专业研究员" # 个人背景

)

```

每个Agent有明确的职责范围
不同Agent擅长不同领域
互相协作完成复杂任务

**2. 任务分配（像项目管理）**

```python

Task就像工作任务

research_task = Task(

description="研究AI趋势", # 任务描述

agent=researcher, # 分配给研究员

context= $previous_task$ # 依赖前置任务

)

```

任务有明确的描述和预期输出
可以设置任务依赖关系
支持顺序执行或并行执行

**3. 团队协作（像团队会议）**

```python

Crew就像团队

crew = Crew(

agents= $researcher, analyst, writer$ ,

tasks= $task1, task2, task3$ ,

process=Process.sequential # 顺序执行

)

```

**4. 执行流程（像工作流程）**

**Sequential**：按顺序执行（像流水线）
**Hierarchical**：Manager分配任务（像公司管理）
**Parallel**：并行执行（像多人同时工作）

**核心组件详解：**

1. Agent（智能体）

**Agent是CrewAI的核心，定义具有特定角色的智能体。**

**Agent参数详解表：**

| 参数 | 类型 | 必填 | 说明 | 示例 |

|------|------|------|------|------|

| `role` | str | ✓ | 角色名称 | "研究员" |

| `max_iter` | int | ✗ | 最大迭代次数 | 15 |

| `max_rpm` | int | ✗ | 每分钟最大请求 | 100 |

**Agent定义示例：**

```python

from crewai import Agent

from langchain_openai import ChatOpenAI

from langchain_core.tools import tool

定义工具

@tool

def search_tool(query: str) -> str:

"""搜索工具"""

return f"搜索结果：{query}"

创建基础Agent

researcher = Agent(

role="研究员",

goal="收集并整理相关信息",

backstory="你是专业的研究员，擅长收集和分析信息",

verbose=True

)

创建带工具的Agent

tool_agent = Agent(

role="搜索专家",

goal="使用工具搜索信息",

backstory="你是搜索专家，擅长使用各种工具",

tools= $search_tool$ ,

verbose=True

)

创建带LLM配置的Agent

custom_llm_agent = Agent(

role="分析师",

goal="深度分析数据",

backstory="你是资深分析师",

llm=ChatOpenAI(

model="gpt-4o",

temperature=0.3

max_iter=20, # 最大迭代次数

max_rpm=100 # 每分钟最多100次请求

)

创建可委托任务的Agent

manager_agent = Agent(

role="项目经理",

goal="协调团队成员完成任务",

backstory="你是项目经理，擅长协调团队",

allow_delegation=True, # 允许委托任务给其他Agent

verbose=True

)

创建带记忆的Agent

memory_agent = Agent(

role="客服",

goal="提供优质客户服务",

backstory="你是客服专家",

memory=True, # 启用记忆功能

verbose=True

)

```

2. Task（任务）

**Task定义具体的工作内容和预期输出。**

**Task参数详解表：**

| 参数 | 类型 | 必填 | 说明 | 示例 |

|------|------|------|------|------|

| `expected_output` | str | ✗ | 预期输出 | "500字报告" |

**Task定义示例：**

```python

from crewai import Task

基础Task

research_task = Task(

description="研究AI Agent的最新发展趋势",

expected_output="一份包含5个关键趋势的简要报告",

agent=researcher

)

带工具的Task

search_task = Task(

description="搜索AI领域的最新论文",

expected_output="列出10篇重要论文",

agent=researcher,

tools= $search_tool$

)

带上下文依赖的Task

analysis_task = Task(

description="分析收集到的信息",

expected_output="识别3个关键趋势",

agent=analyst,

context= $research_task$ # 依赖research_task的输出

)

异步执行的Task

async_task = Task(

description="收集市场数据",

expected_output="市场数据报告",

agent=researcher,

async_execution=True # 异步执行

)

输出到文件的Task

file_task = Task(

description="撰写完整报告",

expected_output="Markdown格式报告",

agent=writer,

output_file="ai_trends_report.md" # 输出到文件

)

带回调的Task

def task_callback(output):

print(f"任务完成：{output}")

callback_task = Task(

description="生成摘要",

expected_output="200字摘要",

agent=writer,

callback=task_callback # 完成后调用回调

)

```

3. Crew（团队）

**Crew管理多个Agent和Task，协调执行流程。**

**Crew参数详解表：**

| 参数 | 类型 | 必填 | 说明 | 示例 |

|------|------|------|------|------|

| `max_rpm` | int | ✗ | 每分钟最大请求 | 100 |

**Process执行流程详解：**

| Process类型 | 说明 | 适用场景 |

|-------------|------|----------|

| `sequential` | 顺序执行（默认） | 有依赖关系的任务 |

| `hierarchical` | 层级管理（需要Manager Agent） | 复杂协作任务 |

| `parallel` | 并行执行（无依赖） | 独立任务 |

**Crew定义示例：**

```python

from crewai import Crew, Process

Sequential Process（顺序执行）

sequential_crew = Crew(

agents= $researcher, analyst, writer$ ,

tasks= $research_task, analysis_task, write_task$ ,

process=Process.sequential, # 顺序执行

verbose=True

)

Hierarchical Process（层级管理）

manager_agent = Agent(

role="项目经理",

goal="协调团队完成任务",

backstory="你是项目经理",

allow_delegation=True

)

hierarchical_crew = Crew(

agents= $researcher, analyst, writer$ ,

tasks= $research_task, analysis_task, write_task$ ,

process=Process.hierarchical, # 层级管理

manager_llm=ChatOpenAI(model="gpt-4o"), # Manager LLM

verbose=True

)

Parallel Process（并行执行）

parallel_tasks = [

Task(description="搜索新闻", agent=researcher),

Task(description="搜索论文", agent=researcher),

Task(description="搜索市场数据", agent=researcher)

]

parallel_crew = Crew(

agents= $researcher$ ,

tasks=parallel_tasks,

process=Process.parallel, # 并行执行

verbose=True

)

带记忆的Crew

memory_crew = Crew(

agents= $researcher, writer$ ,

tasks= $research_task, write_task$ ,

memory=True, # 启用团队记忆

verbose=True

)

执行Crew

result = crew.kickoff()

print(result)

```

4. Process（执行流程）

**Process定义Agent和Task的执行方式。**

**Process详细对比：**

|------|------------|--------------|----------|

| **需要Manager** | 否 | 是 | 否 |

| **输出质量** | 稳定 | 高（有协调） | 快速 |

**Process使用示例（v0.6.0最新语法）：**

```python

from crewai import Crew, Process

from langchain_openai import ChatOpenAI

Sequential示例（推荐用于有依赖的任务）

sequential_crew = Crew(

agents= $agent1, agent2, agent3$ ,

tasks= $task1, task2, task3$ ,

process=Process.sequential # v0.6.0使用字符串或Process.sequential

)

Hierarchical示例（推荐用于复杂协作）

hierarchical_crew = Crew(

agents= $agent1, agent2, agent3$ ,

tasks= $task1, task2, task3$ ,

process=Process.hierarchical, # 层级管理

manager_llm=ChatOpenAI(model="gpt-4o"), # 指定Manager的LLM

verbose=True

)

Parallel示例（推荐用于独立任务）

parallel_crew = Crew(

agents= $agent1, agent2$ ,

tasks= $task1, task2$ , # task1和task2无依赖

process=Process.parallel # 并行执行

)

执行Crew（v0.6.0新语法）

result = crew.kickoff()

print(result)

或者使用异步执行（v0.6.0新语法）

async_result = await crew.kickoff_async()

print(async_result)

```

**CrewAI v0.6.0完整示例：**

```python

from crewai import Agent, Task, Crew

from langchain_openai import ChatOpenAI

from crewai.tools import Tool

定义工具

search_tool = Tool(

name="web_search",

func=lambda x: f"搜索结果：{x}",

description="用于搜索网络信息"

)

创建Agent（v0.6.0语法）

researcher = Agent(

role="高级研究员",

goal="收集{topic}领域的最新信息和趋势",

backstory="""你是一位经验丰富的行业研究员，

擅长收集、整理和分析各类信息。

你的研究以严谨和全面著称。""",

verbose=True,

allow_delegation=True,

tools= $search_tool$

)

创建Task（v0.6.0语法）

research_task = Task(

description="深入研究{topic}的最新发展趋势",

expected_output="一份详细的研究报告，包含关键发现和数据支持",

agent=researcher,

async_execution=False

)

创建Crew（v0.6.0语法）

crew = Crew(

agents= $researcher$ ,

tasks= $research_task$ ,

process=Process.sequential,

memory=True, # 启用团队记忆

embedder={

"provider": "openai",

"model": "text-embedding-3-small"

}

)

启动Crew

result = crew.kickoff(inputs={"topic": "人工智能"})

print(result)

```

**基础示例：**

```python

from crewai import Agent, Task, Crew

创建Agent

researcher = Agent(

role="研究员",

goal="收集并整理相关信息",

backstory="你是专业的研究员，擅长收集和分析信息",

verbose=True

)

analyst = Agent(

role="分析师",

goal="深入分析数据并得出结论",

backstory="你是资深分析师，擅长数据分析和洞察",

verbose=True

)

writer = Agent(

role="作家",

goal="撰写清晰易懂的报告",

backstory="你是专业作家，擅长撰写高质量报告",

verbose=True

)

创建Task

research_task = Task(

description="研究AI Agent的最新发展趋势",

agent=researcher

)

analysis_task = Task(

description="分析收集到的信息，识别关键趋势",

agent=analyst,

context= $research_task$

)

write_task = Task(

description="撰写完整的研究报告",

agent=writer,

context= $analysis_task$

)

创建Crew

crew = Crew(

agents= $researcher, analyst, writer$ ,

tasks= $research_task, analysis_task, write_task$ ,

process="sequential" # 顺序执行

)

启动

result = crew.kickoff()

print(result)

```

**并行执行示例：**

```python

并行Task

parallel_tasks = [

Task(description="搜索AI新闻", agent=researcher),

Task(description="搜索市场数据", agent=researcher),

Task(description="搜索技术文档", agent=researcher)

]

crew_parallel = Crew(

agents= $researcher$ ,

tasks=parallel_tasks,

process="processes" # 并行执行

)

results = crew_parallel.kickoff()

```

7.4 AutoGen框架详解

**AutoGen核心概念：**

AutoGen是微软开发的多Agent协作框架，支持人机交互和复杂对话。

🎯 基本原理（通俗理解）

**AutoGen就像一个"智能聊天室系统"：**

想象一个智能聊天室，多个AI助手在里面对话：

💬 **每个Agent是聊天室成员**
🗣️ **Agent之间可以互相对话**
👥 **可以组建群聊（GroupChat）**
🤖 **有管理员协调对话（Manager）**
👨‍💻 **人类可以随时介入（Human-in-the-loop）**

**核心工作流程：**

```

用户提问 → Agent接收 →

思考并回复 → 其他Agent看到 →

继续对话或完成任务

```

🔧 实现逻辑（简单描述）

**1. Agent对话机制（像聊天室）**

```python

每个Agent就像聊天室的一个用户

assistant = ConversableAgent(

name="assistant", # 用户名

system_message="你是助手", # 个人简介

llm_config={"model": "gpt-4o"} # 大脑配置

)

Agent之间对话（像私聊）

user_proxy.initiate_chat(

assistant,

message="你好"

)

```

**2. 群聊协作（像多人会议）**

```python

创建群聊（像会议室）

group_chat = GroupChat(

agents= $researcher, analyst, writer$ ,

max_round=10 # 最多10轮对话

)

管理员协调（像会议主持人）

manager = GroupChatManager(groupchat=group_chat)

```

**3. 人工介入（像邀请专家）**

```python

Human-in-the-loop（人类可以随时加入）

human_agent = ConversableAgent(

name="human",

human_input_mode="ALWAYS" # 每次都需要人类输入

)

```

**4. 代码执行（像程序员助手）**

```python

Agent可以写代码并执行

coder_agent = ConversableAgent(

name="coder",

code_execution_config={

"work_dir": "coding", # 工作目录

"use_docker": False # 本地执行

}

)

```

**核心组件详解：**

1. ConversableAgent（对话型Agent）

**ConversableAgent是AutoGen的核心Agent类型。**

**ConversableAgent参数详解表：**

| 参数 | 类型 | 必填 | 说明 | 示例 |

|------|------|------|------|------|

| `llm_config` | dict | ✗ | LLM配置 | {"model": "gpt-4o"} |

| `max_consecutive_auto_reply` | int | ✗ | 最大连续回复 | 10 |

| `code_execution_config` | dict | ✗ | 代码执行配置 | {"work_dir": "coding"} |

| `default_auto_reply` | str | ✗ | 默认自动回复 | "继续" |

**ConversableAgent定义示例（v0.2.0最新语法）：**

```python

from autogen import ConversableAgent

基础Agent（v0.2.0语法）

assistant = ConversableAgent(

name="assistant",

system_message="你是一个专业的AI助手",

llm_config={

"model": "gpt-4o",

"api_key": "your-api-key",

"temperature": 0.7,

"max_tokens": 2000

}

)

User Proxy Agent（用户代理）

user_proxy = ConversableAgent(

name="user_proxy",

system_message="你是用户代理，代表用户与助手交互",

human_input_mode="NEVER", # 不需要人工输入

max_consecutive_auto_reply=10, # 最大连续回复10次

is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE")

)

Human-in-the-loop Agent（人工介入）

human_agent = ConversableAgent(

name="human",

system_message="你是人工审核员",

human_input_mode="ALWAYS" # 每次都需要人工输入

)

Code Execution Agent（代码执行）

coder_agent = ConversableAgent(

name="coder",

system_message="你是Python程序员，可以编写和执行代码",

llm_config={"model": "gpt-4o", "api_key": "your-key"},

code_execution_config={

"work_dir": "coding", # 工作目录

"use_docker": False # 不使用Docker

}

)

自定义终止条件的Agent

custom_termination_agent = ConversableAgent(

name="reviewer",

system_message="你是审核员",

is_termination_msg=lambda x: "审核通过" in x.get("content", "")

)

v0.2.0新增：带工具调用的Agent

tool_agent = ConversableAgent(

name="tool_agent",

system_message="你是一个助手，可以调用工具完成任务",

llm_config={"model": "gpt-4o", "api_key": "your-key"},

function_map={

"get_weather": lambda city: f"{city}天气晴朗",

"calculate": lambda expr: str(eval(expr))

}

)

```

2. GroupChat（群聊）

**GroupChat管理多个Agent的群聊协作。**

**GroupChat参数详解表：**

| 参数 | 类型 | 必填 | 说明 | 示例 |

|------|------|------|------|------|

| `max_round` | int | ✗ | 最大轮数 | 10 |

**GroupChat定义示例（v0.2.0最新语法）：**

```python

from autogen import GroupChat

基础群聊（v0.2.0语法）

group_chat = GroupChat(

agents= $researcher, analyst, writer$ ,

messages=\[\], # 初始消息历史为空

max_round=10 # 最多10轮对话

)

带管理员的群聊

admin_group_chat = GroupChat(

agents= $manager, researcher, analyst$ ,

messages=\[\],

max_round=20,

admin_name="Manager" # Manager作为管理员

)

v0.2.0新增：自定义发言人选择

custom_group_chat = GroupChat(

agents= $agent1, agent2, agent3$ ,

messages=\[\],

max_round=15,

speaker_selection_method="auto", # 自动选择

allow_repeat_speaker=False # 不允许连续重复发言

)

```

**GroupChatManager定义示例（v0.2.0最新语法）：**

```python

from autogen import GroupChatManager

基础管理器

manager = GroupChatManager(

groupchat=group_chat,

llm_config={"model": "gpt-4o", "api_key": "your-key"}

)

带终止条件的管理器

termination_manager = GroupChatManager(

groupchat=group_chat,

is_termination_msg=lambda x: "完成" in x.get("content", "")

)

带LLM配置的管理器

custom_manager = GroupChatManager(

groupchat=group_chat,

llm_config={

"model": "gpt-4o",

"temperature": 0.5,

"max_tokens": 2000

max_consecutive_auto_reply=15

)

v0.2.0：创建并启动群聊

result = researcher.initiate_chat(

manager,

message="请协作完成一份AI趋势研究报告"

)

```

4. Human Input Mode（人工输入模式）

**Human Input Mode定义人工介入的方式。**

**Human Input Mode详解：**

| 模式 | 说明 | 适用场景 | 示例 |

|------|------|----------|------|

**Human Input Mode使用示例：**

```python

from autogen import ConversableAgent

NEVER模式（完全自动化）

auto_agent = ConversableAgent(

name="auto_agent",

human_input_mode="NEVER"

)

ALWAYS模式（完全人工）

human_agent = ConversableAgent(

name="human_agent",

human_input_mode="ALWAYS"

)

TERMINATE模式（终止时人工介入）

semi_auto_agent = ConversableAgent(

name="semi_auto",

human_input_mode="TERMINATE",

is_termination_msg=lambda x: "需要确认" in x.get("content", "")

)

```

5. Code Execution（代码执行）

**Code Execution允许Agent生成和执行代码。**

**Code Execution参数详解：**

| 参数 | 类型 | 说明 | 示例 |

|------|------|------|------|

| `timeout` | int | 执行超时（秒） | 60 |

| `last_n_messages` | int | 检查最近N条消息 | 3 |

**Code Execution使用示例：**

```python

from autogen import ConversableAgent

代码执行Agent

coder = ConversableAgent(

name="coder",

system_message="你是Python程序员，编写和执行代码",

llm_config={"model": "gpt-4o"},

code_execution_config={

"work_dir": "coding", # 代码保存目录

"use_docker": False, # 不使用Docker（本地执行）

"timeout": 60 # 执行超时60秒

}

)

User Proxy（执行代码）

user_proxy = ConversableAgent(

name="user_proxy",

human_input_mode="NEVER",

max_consecutive_auto_reply=10,

code_execution_config={

"work_dir": "coding",

"use_docker": False,

"last_n_messages": 3 # 检查最近3条消息中的代码

}

)

对话并执行代码

user_proxy.initiate_chat(

coder,

message="写一个Python脚本计算斐波那契数列"

)

```

**基础示例：**

```python

from autogen import ConversableAgent, GroupChat, GroupChatManager

创建Agent

assistant = ConversableAgent(

name="assistant",

system_message="你是一个专业的AI助手",

llm_config={"model": "gpt-4o", "api_key": "your-key"}

)

user_proxy = ConversableAgent(

name="user_proxy",

system_message="你是用户代理，代表用户与助手交互",

is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"),

human_input_mode="NEVER"

)

直接对话

response = user_proxy.initiate_chat(

assistant,

message="解释什么是机器学习"

)

print(response)

```

**群聊协作示例：**

```python

from autogen import GroupChat, GroupChatManager

创建多个Agent

researcher = ConversableAgent(name="researcher", system_message="研究员")

analyst = ConversableAgent(name="analyst", system_message="分析师")

writer = ConversableAgent(name="writer", system_message="作家")

创建群聊

group_chat = GroupChat(

agents= $researcher, analyst, writer$ ,

messages=\[\],

max_round=10

)

创建管理器

manager = GroupChatManager(groupchat=group_chat)

启动群聊

result = researcher.initiate_chat(

manager,

message="请协作完成一份AI趋势研究报告"

)

```

7.5 框架对比与选型

| 框架 | 优点 | 缺点 | 适用场景 | 最新版本 |

|------|------|------|----------|----------|

**选型建议：**

```

场景选型指南：

├── 通用应用开发

│ └── LangChain v1.3.0

├── 复杂工作流/状态机

│ └── LangGraph v1.2.0

├── 多角色协作任务

│ └── CrewAI v0.6.0

├── 人机对话/交互系统

│ └── AutoGen v0.2.0

└── 文档检索/RAG应用

└── LlamaIndex v0.10.0

```

7.6 项目案例：智能客服系统

**使用LangChain + CrewAI构建完整客服系统：**

```python

from crewai import Agent, Task, Crew

from langchain_openai import ChatOpenAI

初始化LLM

llm = ChatOpenAI(model="gpt-4o")

创建客服Agent

greeting_agent = Agent(

role="接待员",

goal="友好地问候用户并了解需求",

backstory="你是热情的客服接待员",

llm=llm

)

qa_agent = Agent(

role="问答专家",

goal="准确回答用户问题",

backstory="你是产品专家，熟悉所有产品细节",

llm=llm

)

escalation_agent = Agent(

role="升级处理",

goal="处理复杂问题或投诉",

backstory="你是高级客服，擅长处理棘手问题",

llm=llm

)

创建Task

greeting_task = Task(

description="问候用户并了解咨询内容",

agent=greeting_agent

)

qa_task = Task(

description="回答用户的具体问题",

agent=qa_agent,

context= $greeting_task$

)

escalation_task = Task(

description="处理无法解决的问题",

agent=escalation_agent,

context= $qa_task$

)

创建Crew

customer_service_crew = Crew(

agents= $greeting_agent, qa_agent, escalation_agent$ ,

tasks= $greeting_task, qa_task, escalation_task$ ,

process="sequential"

)

启动客服系统

result = customer_service_crew.kickoff()

print(result)

```

7.7 项目案例：代码审查Agent

**使用LangGraph构建代码审查工作流：**

```python

from langgraph.graph import StateGraph, END

from typing import TypedDict, Annotated

from operator import add

from langchain_openai import ChatOpenAI

class CodeReviewState(TypedDict):

code: str

issues: Annotated $list, add$

suggestions: list

approved: bool

llm = ChatOpenAI(model="gpt-4o")

def lint_node(state):

issues = $"缺少类型注解", "函数过长"$

return {"issues": issues}

def review_node(state):

prompt = f"审查以下代码问题：{state $'issues'$ }"

response = llm.invoke(prompt)

return {"suggestions": $response.content$ }

def approve_node(state):

approved = len(state $"issues"$ ) < 3

return {"approved": approved}

workflow = StateGraph(CodeReviewState)

workflow.add_node("lint", lint_node)

workflow.add_node("review", review_node)

workflow.add_node("approve", approve_node)

workflow.add_edge("lint", "review")

workflow.add_edge("review", "approve")

workflow.add_edge("approve", END)

app = workflow.compile()

result = app.invoke({

"code": "def add(a,b):return a+b",

"issues": \[\],

"suggestions": \[\],

"approved": False

})

print(f"审查通过：{result $'approved'$ }")

```

7.8 项目案例：多Agent协作研究助手

**使用多种框架构建研究助手：**

```python

from crewai import Agent, Task, Crew

from langgraph.graph import StateGraph, END

from langchain_openai import ChatOpenAI

CrewAI处理协作

researcher = Agent(

role="研究员",

goal="收集AI领域最新资讯",

backstory="你是AI领域的研究员"

)

writer = Agent(

role="作家",

goal="撰写研究报告",

backstory="你是专业科技作家"

)

LangGraph处理工作流

class ResearchState:

def init(self):

self.topic = ""

self.findings = \[\]

self.report = ""

research_flow = StateGraph(ResearchState)

research_flow.add_node("research", researcher)

research_flow.add_node("write", writer)

research_flow.add_edge("research", "write")

research_flow.add_edge("write", END)

app = research_flow.compile()

执行完整研究流程

result = app.invoke({"topic": "2026年AI发展趋势"})

print(result $"report"$ )

```

第24-26天：协议与框架

8.1 MCP协议

**MCP工具注册：**

```python

from mcpsdk import MCPConfig, ToolRegistry

配置MCP

config = MCPConfig(

host="localhost",

port=8080,

api_key="your-api-key"

)

注册工具

registry = ToolRegistry(config)

@registry.register_tool

def get_stock_price(symbol: str) -> str:

"""获取股票价格"""

return f"{symbol} 当前价格：$100"

启动MCP服务

registry.start()

```

8.2 A2A协议（Agent-to-Agent）

**Agent通信协议：**

```python

from a2a_protocol import AgentMessage, MessageType

创建消息

message = AgentMessage(

sender_id="agent-1",

receiver_id="agent-2",

message_type=MessageType.TASK_REQUEST,

content="请分析这份数据",

metadata={"priority": "high"}

)

发送消息

await message.send()

接收消息

received = await AgentMessage.receive("agent-2")

print(received.content)

```

8.3 主流框架对比

| 框架 | 特点 | 适用场景 | 最新版本 |

|------|------|----------|----------|

第27-28天：项目实战

8.1 Coding Agent

**代码生成Agent：**

```python

from langchain_openai import ChatOpenAI

from langchain_core.prompts import ChatPromptTemplate

class CodingAgent:

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

self.prompt = ChatPromptTemplate.from_messages([

("system", """你是专业Python程序员，遵循以下规则：

编写清晰、可维护的代码
添加必要的注释
处理异常情况
返回完整的可运行代码"""),

("user", "{request}")

])

def generate_code(self, request):

chain = self.prompt | self.llm

response = chain.invoke({"request": request})

return response.content

使用

coder = CodingAgent()

code = coder.generate_code("写一个Python函数，计算斐波那契数列")

print(code)

```

8.2 Browser Agent

**浏览器自动化Agent：**

```python

from langchain_community.tools import PlaywrightBrowserTool

from langchain_openai import ChatOpenAI

from langchain.agents import create_agent, AgentExecutor

from langchain_core.prompts import ChatPromptTemplate

初始化浏览器工具

browser_tool = PlaywrightBrowserTool()

创建Agent

llm = ChatOpenAI(model="gpt-4o")

prompt = ChatPromptTemplate.from_messages([

("system", "你可以使用浏览器工具访问网页"),

("user", "{input}"),

("agent_info", "{agent_info}")

])

agent = create_agent(llm, $browser_tool$ , prompt=prompt)

agent_executor = AgentExecutor(agent=agent, tools= $browser_tool$ )

执行

result = agent_executor.invoke({"input": "打开百度首页"})

print(result $"output"$ )

```

8.3 Deep Research Agent

**深度研究Agent：**

```python

class DeepResearchAgent:

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

self.search_tool = search_web

self.analysis_tool = analyze_text

def research(self, topic, depth=3):

results = \[\]

for i in range(depth):

搜索相关信息

search_query = f"{topic} 第{i+1}轮搜索"

search_result = self.search_tool.invoke(search_query)

results.append(search_result)

分析结果

analysis = self.analysis_tool.invoke(search_result)

results.append(analysis)

汇总报告

summary_prompt = ChatPromptTemplate.from_template(

"汇总以下研究结果，生成详细报告：\n{results}"

)

chain = summary_prompt | self.llm

report = chain.invoke({"results": "\n".join(results)})

return report.content

使用

researcher = DeepResearchAgent()

report = researcher.research("AI Agent最新进展", depth=3)

print(report)

```

8.4 Workflow Agent

**工作流Agent：**

```python

from langgraph.graph import StateGraph, END

from typing import TypedDict

定义状态

class WorkflowState(TypedDict):

task: str

research_done: bool

analysis_done: bool

report_done: bool

result: str

定义节点

def research_node(state):

研究阶段

result = researcher.run(state $"task"$ )

return {"research_done": True, "result": result}

def analysis_node(state):

分析阶段

result = analyst.run(state $"result"$ )

return {"analysis_done": True, "result": result}

def write_node(state):

写作阶段

result = writer.run(state $"result"$ )

return {"report_done": True, "result": result}

构建工作流

workflow = StateGraph(WorkflowState)

workflow.add_node("research", research_node)

workflow.add_node("analysis", analysis_node)

workflow.add_node("write", write_node)

workflow.add_edge("research", "analysis")

workflow.add_edge("analysis", "write")

workflow.add_edge("write", END)

编译并运行

app = workflow.compile()

result = app.invoke({"task": "AI趋势报告", "research_done": False})

print(result $"result"$ )

```

企业级项目实战（新增）

8.5 企业级OA审批Agent系统

📋 项目介绍

**项目背景：**

企业OA（Office Automation）审批流程是企业日常运营的核心环节，涉及请假、报销、采购等多种审批场景。传统审批流程存在效率低、流程复杂、人工干预多等问题。

**解决方案：**

使用LangGraph构建智能审批Agent系统，实现：

🤖 **自动审批决策**：基于规则和AI判断
📊 **流程状态管理**：实时跟踪审批进度
👨‍💼 **人工介入机制**：关键节点人工确认
📝 **审批记录存储**：完整审批历史
🔔 **通知提醒系统**：自动发送审批通知

🏗️ 技术架构

**架构设计：**

```

用户提交申请 → 审批Agent接收 →

规则引擎判断 → AI辅助决策 →

（需要人工？）→ 自动审批或人工审批 →

通知相关人员 → 记录审批结果

```

**核心技术栈：**

**LangGraph v1.2.0**：状态图管理审批流程
**LangChain v1.3.0**：LLM决策和工具调用
**PostgreSQL**：审批记录持久化
**Redis**：实时状态缓存

💻 完整代码实现

**1. 状态定义：**

```python

from typing import TypedDict, Annotated

from operator import add

from langgraph.graph import StateGraph, END

from langgraph.checkpoint.postgres import PostgresSaver

from langgraph.pregel import TimeoutPolicy

from langchain_openai import ChatOpenAI

from langchain_core.tools import tool

from langchain_core.prompts import ChatPromptTemplate

import psycopg2

from datetime import datetime

审批状态定义

class ApprovalState(TypedDict):

"""OA审批系统状态"""

application_id: str # 申请ID

applicant: str # 申请人

application_type: str # 申请类型（请假/报销/采购）

application_data: dict # 申请详情

current_approver: str # 当前审批人

approval_level: int # 审批层级（1-3级）

auto_approved: bool # 是否自动审批

needs_human_review: bool # 是否需要人工审核

approval_result: str # 审批结果（approved/rejected/pending）

approval_history: Annotated $list\[dict$ , add] # 审批历史

notifications: Annotated $list\[str$ , add] # 通知记录

errors: Annotated $list\[str$ , add] # 错误记录

```

**2. 工具定义：**

```python

审批规则工具

@tool

def check_approval_rules(application_type: str, amount: float, days: int) -> dict:

"""检查审批规则

Args:

application_type: 申请类型（请假/报销/采购）

amount: 金额（报销/采购）

days: 天数（请假）

Returns:

审批规则结果（是否自动审批、审批层级）

"""

rules = {

"请假": {

"auto_threshold": 3, # 3天以下自动审批

"levels": {1: 3, 2: 7, 3: 30} # 审批层级对应天数

"报销": {

"auto_threshold": 500, # 500元以下自动审批

"levels": {1: 500, 2: 2000, 3: 10000}

"采购": {

"auto_threshold": 1000, # 1000元以下自动审批

"levels": {1: 1000, 2: 5000, 3: 20000}

}

rule = rules.get(application_type)

if not rule:

return {"error": "未知的申请类型"}

判断是否自动审批

threshold = rule $"auto_threshold"$

value = amount if application_type in $"报销", "采购"$ else days

auto_approved = value <= threshold

确定审批层级

level = 1

for l, threshold in rule $"levels"$ .items():

if value <= threshold:

level = l

break

return {

"auto_approved": auto_approved,

"approval_level": level,

"needs_human_review": not auto_approved

}

通知工具

@tool

def send_notification(recipient: str, message: str, notification_type: str) -> str:

"""发送审批通知

Args:

recipient: 接收人

message: 通知内容

notification_type: 通知类型（email/sms/app）

Returns:

通知发送结果

"""

实际应用中集成邮件/短信/APP推送

timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

notification_record = f" ${timestamp}$ 发送{notification_type}通知给{recipient}: {message}"

return notification_record

记录审批工具

@tool

def record_approval(application_id: str, approver: str, result: str, comment: str) -> str:

"""记录审批结果

Args:

application_id: 申请ID

approver: 审批人

result: 审批结果

comment: 审批意见

Returns:

记录结果

"""

timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

record = {

"timestamp": timestamp,

"approver": approver,

"result": result,

"comment": comment

}

return f"审批记录已保存：{record}"

```

**3. Agent节点定义：**

```python

初始化LLM

llm = ChatOpenAI(model="gpt-4o", temperature=0.3)

规则检查节点

def rule_check_node(state: ApprovalState) -> dict:

"""规则检查节点"""

app_type = state $"application_type"$

app_data = state $"application_data"$

获取申请参数

amount = app_data.get("amount", 0)

days = app_data.get("days", 0)

调用规则工具

rule_result = check_approval_rules.invoke({

"application_type": app_type,

"amount": amount,

"days": days

})

return {

"auto_approved": rule_result.get("auto_approved", False),

"approval_level": rule_result.get("approval_level", 1),

"needs_human_review": rule_result.get("needs_human_review", True)

}

AI辅助决策节点

def ai_decision_node(state: ApprovalState) -> dict:

"""AI辅助决策节点"""

prompt = ChatPromptTemplate.from_messages([

("system", """你是企业审批助手，基于以下信息做出审批建议：

申请类型：{application_type}

申请人：{applicant}

申请详情：{application_data}

审批层级：{approval_level}

请分析申请的合理性，给出审批建议（approved/rejected）和理由。"""),

("user", "请给出审批建议")

])

chain = prompt | llm

response = chain.invoke({

"application_type": state $"application_type"$ ,

"applicant": state $"applicant"$ ,

"application_data": str(state $"application_data"$ ),

"approval_level": state $"approval_level"$

})

解析AI建议

ai_suggestion = response.content

简单解析（实际应用中需要更复杂的解析逻辑）

if "批准" in ai_suggestion or "approved" in ai_suggestion.lower():

result = "approved"

elif "拒绝" in ai_suggestion or "rejected" in ai_suggestion.lower():

result = "rejected"

else:

result = "pending"

return {

"approval_result": result,

"approval_history": [{

"approver": "AI系统",

"result": result,

"comment": ai_suggestion,

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}]

}

自动审批节点

def auto_approval_node(state: ApprovalState) -> dict:

"""自动审批节点"""

自动批准

result = "approved"

comment = "系统自动审批通过"

记录审批

record = record_approval.invoke({

"application_id": state $"application_id"$ ,

"approver": "系统自动审批",

"result": result,

"comment": comment

})

发送通知

notification = send_notification.invoke({

"recipient": state $"applicant"$ ,

"message": f"您的{state $'application_type'$ }申请已自动审批通过",

"notification_type": "app"

})

return {

"approval_result": result,

"approval_history": [{

"approver": "系统自动审批",

"result": result,

"comment": comment,

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}],

"notifications": $notification$

}

人工审批节点（暂停等待人工）

def human_approval_node(state: ApprovalState) -> dict:

"""人工审批节点"""

发送通知给审批人

notification = send_notification.invoke({

"recipient": state $"current_approver"$ ,

"message": f"您有新的{state $'application_type'$ }申请需要审批，申请ID：{state $'application_id'$ }",

"notification_type": "email"

})

return {

"notifications": $notification$ ,

"approval_result": "pending" # 等待人工审批

}

```

**4. 构建审批工作流：**

```python

构建状态图

workflow = StateGraph(ApprovalState)

添加节点

workflow.add_node("rule_check", rule_check_node)

workflow.add_node("ai_decision", ai_decision_node)

workflow.add_node("auto_approval", auto_approval_node)

workflow.add_node("human_approval", human_approval_node)

设置入口点

workflow.set_entry_point("rule_check")

添加条件边（根据审批类型路由）

def route_by_approval_type(state: ApprovalState) -> str:

"""根据审批结果路由"""

if state $"auto_approved"$ :

return "auto"

else:

return "human"

workflow.add_conditional_edges(

"rule_check",

route_by_approval_type,

{

"auto": "ai_decision", # 自动审批路径

"human": "human_approval" # 人工审批路径

}

)

AI决策后可以自动审批或继续人工审批

workflow.add_conditional_edges(

"ai_decision",

lambda state: "auto" if state $"approval_result"$ == "approved" else "human",

{

"auto": "auto_approval",

"human": "human_approval"

}

)

所有审批完成后结束

workflow.add_edge("auto_approval", END)

workflow.add_edge("human_approval", END)

创建PostgreSQL Checkpointer

conn = psycopg2.connect(

host="localhost",

database="oa_approval",

user="admin",

password="password"

)

checkpointer = PostgresSaver(conn)

编译工作流（带人工介入）

app = workflow.compile(

checkpointer=checkpointer,

interrupt_before= $"human_approval"$ # 在人工审批节点前暂停

)

```

**5. 使用示例：**

```python

提交请假申请（自动审批）

leave_application = {

"application_id": "APP-2026-001",

"applicant": "张三",

"application_type": "请假",

"application_data": {"days": 2, "reason": "个人事务"},

"current_approver": "",

"approval_level": 0,

"auto_approved": False,

"needs_human_review": False,

"approval_result": "",

"approval_history": \[\],

"notifications": \[\],

"errors": \[\]

}

result = app.invoke(leave_application)

print(f"审批结果：{result $'approval_result'$ }")

print(f"审批历史：{result $'approval_history'$ }")

提交报销申请（需要人工审批）

expense_application = {

"application_id": "APP-2026-002",

"applicant": "李四",

"application_type": "报销",

"application_data": {"amount": 5000, "reason": "差旅费用"},

"current_approver": "财务主管",

"approval_level": 0,

"auto_approved": False,

"needs_human_review": False,

"approval_result": "",

"approval_history": \[\],

"notifications": \[\],

"errors": \[\]

}

第一次执行（会暂停在human_approval节点）

result1 = app.invoke(

expense_application,

config={"configurable": {"thread_id": "APP-2026-002"}}

)

人工审批后继续执行（模拟人工审批）

实际应用中，人工审批后更新状态

expense_application $"approval_result"$ = "approved"

expense_application $"current_approver"$ = "财务主管"

result2 = app.invoke(

None, # 不传输入，使用保存的状态

config={"configurable": {"thread_id": "APP-2026-002"}}

)

print(f"人工审批结果：{result2 $'approval_result'$ }")

```

🧪 测试用例

**测试用例1：请假自动审批测试**

```python

import unittest

class TestLeaveApproval(unittest.TestCase):

"""请假审批测试"""

def setUp(self):

"""测试初始化"""

self.app = workflow.compile(checkpointer=MemorySaver())

def test_auto_approval_short_leave(self):

"""测试短期请假自动审批"""

2天请假（应自动审批）

application = {

"application_id": "TEST-001",

"applicant": "测试用户",

"application_type": "请假",

"application_data": {"days": 2, "reason": "测试"},

"current_approver": "",

"approval_level": 0,

"auto_approved": False,

"needs_human_review": False,

"approval_result": "",

"approval_history": \[\],

"notifications": \[\],

"errors": \[\]

}

result = self.app.invoke(application)

验证结果

self.assertEqual(result $"approval_result"$ , "approved")

self.assertTrue(result $"auto_approved"$ )

self.assertEqual(result $"approval_level"$ , 1)

self.assertTrue(len(result $"approval_history"$ ) > 0)

self.assertTrue(len(result $"notifications"$ ) > 0)

def test_human_approval_long_leave(self):

"""测试长期请假人工审批"""

10天请假（需要人工审批）

application = {

"application_id": "TEST-002",

"applicant": "测试用户",

"application_type": "请假",

"application_data": {"days": 10, "reason": "长假"},

"current_approver": "部门经理",

"approval_level": 0,

"auto_approved": False,

"needs_human_review": False,

"approval_result": "",

"approval_history": \[\],

"notifications": \[\],

"errors": \[\]

}

result = self.app.invoke(

application,

config={"configurable": {"thread_id": "TEST-002"}}

)

验证结果

self.assertEqual(result $"approval_result"$ , "pending")

self.assertFalse(result $"auto_approved"$ )

self.assertEqual(result $"approval_level"$ , 2)

self.assertTrue(result $"needs_human_review"$ )

def test_rule_check_function(self):

"""测试规则检查函数"""

测试请假规则

result = check_approval_rules.invoke({

"application_type": "请假",

"amount": 0,

"days": 2

})

self.assertTrue(result $"auto_approved"$ )

self.assertEqual(result $"approval_level"$ , 1)

if name == "main":

unittest.main()

```

**测试用例2：报销审批测试**

```python

class TestExpenseApproval(unittest.TestCase):

"""报销审批测试"""

def test_auto_approval_small_expense(self):

"""测试小额报销自动审批"""

application = {

"application_id": "TEST-003",

"applicant": "测试用户",

"application_type": "报销",

"application_data": {"amount": 300, "reason": "办公用品"},

"current_approver": "",

"approval_level": 0,

"auto_approved": False,

"needs_human_review": False,

"approval_result": "",

"approval_history": \[\],

"notifications": \[\],

"errors": \[\]

}

result = self.app.invoke(application)

self.assertEqual(result $"approval_result"$ , "approved")

self.assertTrue(result $"auto_approved"$ )

def test_human_approval_large_expense(self):

"""测试大额报销人工审批"""

application = {

"application_id": "TEST-004",

"applicant": "测试用户",

"application_type": "报销",

"application_data": {"amount": 5000, "reason": "差旅费用"},

"current_approver": "财务主管",

"approval_level": 0,

"auto_approved": False,

"needs_human_review": False,

"approval_result": "",

"approval_history": \[\],

"notifications": \[\],

"errors": \[\]

}

result = self.app.invoke(application)

self.assertEqual(result $"approval_result"$ , "pending")

self.assertFalse(result $"auto_approved"$ )

self.assertEqual(result $"approval_level"$ , 3)

if name == "main":

unittest.main()

```

**测试用例3：采购审批测试**

```python

class TestPurchaseApproval(unittest.TestCase):

"""采购审批测试"""

def test_multi_level_purchase(self):

"""测试多层级采购审批"""

测试不同金额的采购审批层级

test_cases = [

{"amount": 800, "expected_level": 1, "expected_auto": True},

{"amount": 3000, "expected_level": 2, "expected_auto": False},

{"amount": 15000, "expected_level": 3, "expected_auto": False}

]

for case in test_cases:

result = check_approval_rules.invoke({

"application_type": "采购",

"amount": case $"amount"$ ,

"days": 0

})

self.assertEqual(result $"approval_level"$ , case $"expected_level"$ )

self.assertEqual(result $"auto_approved"$ , case $"expected_auto"$ )

if name == "main":

unittest.main()

```

8.6 企业级知识库Agent系统

📋 项目介绍

**项目背景：**

企业知识库是企业信息管理的核心，包含文档、手册、政策、流程等各类知识。传统知识库存在检索效率低、知识更新慢、无法智能问答等问题。

**解决方案：**

使用LangChain + RAG构建智能知识库Agent系统，实现：

📚 **智能文档检索**：基于语义相似度搜索
💬 **智能问答系统**：自然语言问答
🔄 **知识自动更新**：实时同步最新文档
📊 **知识图谱构建**：自动关联相关知识
🎯 **个性化推荐**：根据用户需求推荐知识

🏗️ 技术架构

**架构设计：**

```

用户提问 → 知识库Agent接收 →

向量检索相关文档 → LLM生成答案 →

引用来源文档 → 返回答案

```

**核心技术栈：**

**LangChain v1.3.0**：RAG链构建
**LangGraph v1.2.0**：问答流程管理
**Chroma/FAISS**：向量数据库
**OpenAI Embeddings**：文档向量化

💻 完整代码实现

**1. 知识库系统核心代码：**

```python

from langchain_openai import ChatOpenAI, OpenAIEmbeddings

from langchain_community.vectorstores import Chroma

from langchain_core.documents import Document

from langchain_core.prompts import ChatPromptTemplate

from langchain_core.runnables import RunnablePassthrough, RunnableParallel

from langchain_core.output_parsers import StrOutputParser

from langchain_text_splitters import RecursiveCharacterTextSplitter

from typing import TypedDict, Annotated

from operator import add

from langgraph.graph import StateGraph, END

import os

知识库状态定义

class KnowledgeBaseState(TypedDict):

"""知识库问答状态"""

query: str # 用户问题

retrieved_docs: list # 检索到的文档

answer: str # 生成的答案

sources: Annotated $list\[str$ , add] # 来源文档列表

confidence: float # 答案置信度

related_questions: list # 相关问题推荐

feedback: str # 用户反馈

```

**2. 文档处理和向量化：**

```python

class EnterpriseKnowledgeBase:

"""企业知识库系统"""

def init(self, persist_directory: str = "./knowledge_db"):

self.llm = ChatOpenAI(model="gpt-4o")

self.embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

self.vector_store = Chroma(

collection_name="enterprise_kb",

embedding_function=self.embeddings,

persist_directory=persist_directory

)

self.text_splitter = RecursiveCharacterTextSplitter(

chunk_size=1000,

chunk_overlap=200

)

def add_document(self, file_path: str, metadata: dict = None):

"""添加文档到知识库

Args:

file_path: 文档路径

metadata: 文档元数据（作者、部门、类型等）

"""

读取文档

with open(file_path, 'r', encoding='utf-8') as f:

content = f.read()

分割文档

chunks = self.text_splitter.split_text(content)

创建Document对象

documents = [

Document(

page_content=chunk,

metadata=metadata or {

"source": file_path,

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}

)

for chunk in chunks

]

添加到向量数据库

self.vector_store.add_documents(documents)

self.vector_store.persist()

return f"已添加{len(documents)}个文档片段到知识库"

def add_batch_documents(self, documents: list $dict$ ):

"""批量添加文档

Args:

documents: 文档列表 ${"path": "...", "metadata": {...}}, ...$

"""

results = \[\]

for doc in documents:

result = self.add_document(doc $"path"$ , doc.get("metadata"))

results.append(result)

return results

def search(self, query: str, k: int = 5):

"""搜索相关文档

Args:

query: 搜索查询

k: 返回文档数量

Returns:

创建RAG链

self.rag_chain = self._build_rag_chain()

def _build_rag_chain(self):

"""构建RAG链"""

定义提示模板

prompt = ChatPromptTemplate.from_messages([

("system", """你是企业知识库助手，基于以下文档回答用户问题。

文档内容：

{context}

回答要求：

基于文档内容回答，不要编造信息
如果文档中没有相关信息，明确说明
引用文档来源
回答简洁准确"""),

("user", "{question}")

])

构建RAG链（v1.3.0最新语法）

retriever = self.kb.vector_store.as_retriever(

search_type="similarity",

search_kwargs={"k": 5}

)

chain = (

RunnableParallel(

{

"context": retriever | (lambda docs: self._format_docs(docs)),

"question": RunnablePassthrough()

}

)

| prompt

| self.llm

| StrOutputParser()

)

return chain

def _format_docs(self, docs: list $Document$ ) -> str:

"""格式化文档内容"""

formatted = \[\]

for i, doc in enumerate(docs):

source = doc.metadata.get("source", "未知来源")

content = doc.page_content

formatted.append(f" $文档{i+1}$ 来源：{source}\n内容：{content}\n")

return "\n".join(formatted)

def ask(self, question: str):

"""问答

Args:

question: 用户问题

Returns:

答案和来源文档

"""

检索相关文档

retrieved_docs = self.kb.search(question, k=5)

生成答案

answer = self.rag_chain.invoke(question)

获取来源

sources = $doc.metadata.get("source", "未知") for doc in retrieved_docs$

return {

"answer": answer,

"sources": sources,

"retrieved_docs": retrieved_docs

}

def ask_with_confidence(self, question: str):

"""带置信度的问答

Args:

question: 用户问题

Returns:

答案、来源、置信度

"""

检索相关文档（带分数）

results = self.kb.search_with_scores(question, k=5)

计算置信度（基于相似度分数）

scores = $score for _, score in results$

avg_score = sum(scores) / len(scores) if scores else 0

confidence = min(avg_score / 10, 1.0) # 归一化到0-1

生成答案

docs = $doc for doc, _ in results$

answer = self.rag_chain.invoke(question)

获取来源

sources = $doc.metadata.get("source", "未知") for doc in docs$

return {

"answer": answer,

"sources": sources,

"confidence": confidence,

"retrieved_docs": docs

}

```

**4. 知识库Agent工作流：**

```python

定义Agent节点

def retrieve_node(state: KnowledgeBaseState) -> dict:

"""文档检索节点"""

query = state $"query"$

检索文档

results = kb.search_with_scores(query, k=5)

docs = $doc for doc, _ in results$

scores = $score for _, score in results$

计算置信度

avg_score = sum(scores) / len(scores) if scores else 0

confidence = min(avg_score / 10, 1.0)

获取来源

sources = $doc.metadata.get("source", "未知") for doc in docs$

return {

"retrieved_docs": docs,

"confidence": confidence,

"sources": sources

}

def generate_answer_node(state: KnowledgeBaseState) -> dict:

"""生成答案节点"""

query = state $"query"$

docs = state $"retrieved_docs"$

格式化文档

context = "\n".join( $doc.page_content for doc in docs$ )

生成答案

prompt = ChatPromptTemplate.from_messages([

("system", "基于以下文档回答问题：\n{context}"),

("user", "{question}")

])

chain = prompt | llm | StrOutputParser()

answer = chain.invoke({

"context": context,

"question": query

})

return {"answer": answer}

def recommend_related_node(state: KnowledgeBaseState) -> dict:

"""推荐相关问题节点"""

query = state $"query"$

使用LLM生成相关问题

prompt = ChatPromptTemplate.from_messages([

("system", "基于用户的问题，生成3个相关的延伸问题"),

("user", "{question}")

])

chain = prompt | llm | StrOutputParser()

related = chain.invoke({"question": query})

解析相关问题（简化处理）

questions = $q.strip() for q in related.split("\\n") if q.strip()$

return {"related_questions": questions $:3$ }

构建知识库工作流

kb_workflow = StateGraph(KnowledgeBaseState)

kb_workflow.add_node("retrieve", retrieve_node)

kb_workflow.add_node("generate", generate_answer_node)

kb_workflow.add_node("recommend", recommend_related_node)

kb_workflow.set_entry_point("retrieve")

kb_workflow.add_edge("retrieve", "generate")

kb_workflow.add_edge("generate", "recommend")

kb_workflow.add_edge("recommend", END)

kb_app = kb_workflow.compile()

```

**5. 使用示例：**

```python

初始化知识库

kb = EnterpriseKnowledgeBase(persist_directory="./enterprise_kb")

添加企业文档

documents = [

{

"path": "./docs/company_policy.txt",

"metadata": {"type": "政策", "department": "人事部", "author": "HR"}

{

"path": "./docs/technical_manual.txt",

"metadata": {"type": "手册", "department": "技术部", "author": "Tech"}

{

"path": "./docs/process_guide.txt",

"metadata": {"type": "流程", "department": "运营部", "author": "Ops"}

}

]

kb.add_batch_documents(documents)

创建RAG问答系统

rag = KnowledgeBaseRAG(kb)

问答

result = rag.ask_with_confidence("公司的请假政策是什么？")

print(f"答案：{result $'answer'$ }")

print(f"置信度：{result $'confidence'$ }")

print(f"来源：{result $'sources'$ }")

使用Agent工作流

kb_result = kb_app.invoke({

"query": "技术部门的工作流程是什么？",

"retrieved_docs": \[\],

"answer": "",

"sources": \[\],

"confidence": 0.0,

"related_questions": \[\],

"feedback": ""

})

print(f"答案：{kb_result $'answer'$ }")

print(f"相关问题：{kb_result $'related_questions'$ }")

```

🧪 测试用例

**测试用例1：文档添加和检索测试**

```python

import unittest

class TestKnowledgeBase(unittest.TestCase):

"""知识库测试"""

def setUp(self):

"""测试初始化"""

self.kb = EnterpriseKnowledgeBase(persist_directory="./test_kb")

添加测试文档

test_doc = "./test_docs/sample.txt"

with open(test_doc, 'w', encoding='utf-8') as f:

f.write("这是测试文档内容。公司政策规定员工每年有15天年假。")

self.kb.add_document(test_doc, {"type": "测试", "department": "测试部"})

def test_document_addition(self):

"""测试文档添加"""

验证文档已添加

results = self.kb.search("年假", k=1)

self.assertTrue(len(results) > 0)

self.assertIn("年假", results $0$ .page_content)

def test_similarity_search(self):

"""测试相似度搜索"""

results = self.kb.search("假期政策", k=3)

验证搜索结果

self.assertTrue(len(results) > 0)

for doc in results:

self.assertTrue(hasattr(doc, 'page_content'))

self.assertTrue(hasattr(doc, 'metadata'))

def test_search_with_scores(self):

"""测试带分数的搜索"""

results = self.kb.search_with_scores("年假", k=5)

验证分数

self.assertTrue(len(results) > 0)

for doc, score in results:

self.assertTrue(hasattr(doc, 'page_content'))

self.assertTrue(isinstance(score, (int, float)))

def test_batch_addition(self):

"""测试批量添加文档"""

创建多个测试文档

test_docs = [

{"path": "./test_docs/doc1.txt", "metadata": {"type": "政策"}},

{"path": "./test_docs/doc2.txt", "metadata": {"type": "手册"}}

]

for doc in test_docs:

with open(doc $"path"$ , 'w', encoding='utf-8') as f:

f.write(f"测试文档{doc $'metadata'$ $'type'$ }")

results = self.kb.add_batch_documents(test_docs)

self.assertEqual(len(results), 2)

if name == "main":

unittest.main()

```

**测试用例2：RAG问答测试**

```python

class TestRAGQA(unittest.TestCase):

"""RAG问答测试"""

def setUp(self):

"""测试初始化"""

self.kb = EnterpriseKnowledgeBase(persist_directory="./test_kb")

self.rag = KnowledgeBaseRAG(self.kb)

添加测试文档

test_content = """

公司请假政策：

年假：每年15天
病假：每年10天
事假：需提前申请

审批流程：

3天以下：部门主管审批
3-7天：部门经理审批
7天以上：总经理审批

"""

with open("./test_docs/policy.txt", 'w', encoding='utf-8') as f:

f.write(test_content)

self.kb.add_document("./test_docs/policy.txt", {"type": "政策"})

def test_basic_question(self):

"""测试基础问答"""

result = self.rag.ask("公司年假有多少天？")

验证答案

self.assertTrue(len(result $'answer'$ ) > 0)

self.assertTrue(len(result $'sources'$ ) > 0)

self.assertIn("15天", result $'answer'$ )

def test_confidence_question(self):

"""测试带置信度的问答"""

result = self.rag.ask_with_confidence("请假审批流程是什么？")

验证结果

self.assertTrue(len(result $'answer'$ ) > 0)

self.assertTrue(0 <= result $'confidence'$ <= 1)

self.assertTrue(len(result $'sources'$ ) > 0)

def test_no_answer_question(self):

"""测试无答案问题"""

result = self.rag.ask("公司的股票代码是什么？")

验证答案（应该说明文档中没有相关信息）

self.assertTrue(len(result $'answer'$ ) > 0)

可能包含"没有"或"未知"等关键词

def test_multi_hop_question(self):

"""测试多跳问答"""

result = self.rag.ask("请假7天需要谁审批？")

验证答案

self.assertTrue(len(result $'answer'$ ) > 0)

self.assertIn("总经理", result $'answer'$ )

if name == "main":

unittest.main()

```

**测试用例3：知识库Agent工作流测试**

```python

class TestKnowledgeBaseWorkflow(unittest.TestCase):

"""知识库Agent工作流测试"""

def test_workflow_execution(self):

"""测试工作流执行"""

initial_state = {

"query": "年假政策",

"retrieved_docs": \[\],

"answer": "",

"sources": \[\],

"confidence": 0.0,

"related_questions": \[\],

"feedback": ""

}

result = kb_app.invoke(initial_state)

验证结果

self.assertTrue(len(result $'retrieved_docs'$ ) > 0)

self.assertTrue(len(result $'answer'$ ) > 0)

self.assertTrue(len(result $'sources'$ ) > 0)

self.assertTrue(0 <= result $'confidence'$ <= 1)

self.assertTrue(len(result $'related_questions'$ ) > 0)

def test_related_questions_generation(self):

"""测试相关问题生成"""

state = {

"query": "请假流程",

"retrieved_docs": \[\],

"answer": "",

"sources": \[\],

"confidence": 0.0,

"related_questions": \[\],

"feedback": ""

}

result = kb_app.invoke(state)

验证相关问题

self.assertTrue(len(result $'related_questions'$ ) <= 3)

for question in result $'related_questions'$ :

self.assertTrue(isinstance(question, str))

self.assertTrue(len(question) > 0)

if name == "main":

unittest.main()

```

8.7 企业级流水线Agent系统

📋 项目介绍

**项目背景：**

企业流水线系统涵盖CI/CD（持续集成/持续部署）、数据处理流水线、业务流程自动化等多种场景。传统流水线系统配置复杂、缺乏智能决策、故障处理能力弱。

**解决方案：**

使用LangGraph构建智能流水线Agent系统，实现：

🔄 **自动化流程编排**：动态构建流水线
🤖 **智能决策执行**：AI判断下一步操作
🛠️ **故障自动修复**：自动处理常见错误
📊 **实时监控告警**：流水线状态实时监控
📝 **执行日志记录**：完整执行历史

🏗️ 技术架构

**架构设计：**

```

触发流水线 → Agent接收任务 →

执行阶段1 → 检查结果 →

（成功？）→ 继续下一阶段 →

（失败？）→ 自动修复或人工介入 →

完成流水线

```

**核心技术栈：**

**LangGraph v1.2.0**：流水线状态管理
**LangChain v1.3.0**：工具调用和决策
**Docker/Kubernetes**：容器化部署
**Prometheus/Grafana**：监控告警

💻 完整代码实现

**1. 流水线状态定义：**

```python

from typing import TypedDict, Annotated

from operator import add

from langgraph.graph import StateGraph, END

from langgraph.checkpoint.memory import MemorySaver

from langgraph.pregel import TimeoutPolicy

from langchain_openai import ChatOpenAI

from langchain_core.tools import tool

from langchain_core.prompts import ChatPromptTemplate

from datetime import datetime

import subprocess

import json

流水线状态定义

class PipelineState(TypedDict):

"""企业流水线状态"""

pipeline_id: str # 流水线ID

pipeline_name: str # 流水线名称

pipeline_type: str # 流水线类型（ci_cd/data_processing/business）

current_stage: str # 当前阶段

stages: list # 流水线阶段列表

stage_results: Annotated $list\[dict$ , add] # 阶段执行结果

status: str # 流水线状态（running/success/failed/paused）

errors: Annotated $list\[str$ , add] # 错误记录

retry_count: int # 重试次数

max_retries: int # 最大重试次数

notifications: Annotated $list\[str$ , add] # 通知记录

metrics: dict # 性能指标

```

**2. 流水线工具定义：**

```python

执行命令工具

@tool

def execute_command(command: str, timeout: int = 60) -> dict:

"""执行Shell命令

Args:

command: Shell命令

timeout: 执行超时时间（秒）

Returns:

执行结果（stdout, stderr, return_code）

"""

try:

result = subprocess.run(

command,

shell=True,

capture_output=True,

text=True,

timeout=timeout

)

return {

"success": result.returncode == 0,

"stdout": result.stdout,

"stderr": result.stderr,

"return_code": result.returncode,

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}

except subprocess.TimeoutExpired:

return {

"success": False,

"error": f"命令执行超时（{timeout}秒）",

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}

except Exception as e:

return {

"success": False,

"error": str(e),

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}

发送通知工具

@tool

def send_pipeline_notification(recipient: str, message: str, level: str) -> str:

"""发送流水线通知

Args:

recipient: 接收人

message: 通知内容

level: 通知级别（info/warning/error）

Returns:

通知发送结果

"""

timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

notification = f" ${timestamp}$ ${level.upper}$ 发送给{recipient}: {message}"

return notification

记录指标工具

@tool

def record_metrics(pipeline_id: str, stage: str, metrics: dict) -> str:

"""记录流水线指标

Args:

pipeline_id: 流水线ID

stage: 当前阶段

metrics: 性能指标

Returns:

记录结果

"""

timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

record = {

"pipeline_id": pipeline_id,

"stage": stage,

"metrics": metrics,

"timestamp": timestamp

}

return f"指标已记录：{json.dumps(record)}"

```

**3. CI/CD流水线示例：**

```python

CI/CD流水线阶段定义

class CICDPipeline:

"""CI/CD流水线"""

def init(self):

self.llm = ChatOpenAI(model="gpt-4o", temperature=0.3)

self.workflow = self._build_workflow()

def _build_workflow(self):

"""构建CI/CD流水线工作流"""

定义阶段节点

def checkout_node(state: PipelineState) -> dict:

"""代码检出阶段"""

result = execute_command.invoke({

"command": "git clone https://github.com/example/repo.git",

"timeout": 30

})

return {

"current_stage": "checkout",

"stage_results": [{

"stage": "checkout",

"success": result $"success"$ ,

"output": result.get("stdout", ""),

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}],

"status": "checkout_success" if result $"success"$ else "checkout_failed"

}

def build_node(state: PipelineState) -> dict:

"""构建阶段"""

result = execute_command.invoke({

"command": "cd repo && python setup.py build",

"timeout": 120

})

return {

"current_stage": "build",

"stage_results": [{

"stage": "build",

"success": result $"success"$ ,

"output": result.get("stdout", ""),

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}],

"status": "build_success" if result $"success"$ else "build_failed"

}

def test_node(state: PipelineState) -> dict:

"""测试阶段"""

result = execute_command.invoke({

"command": "cd repo && python -m pytest tests/",

"timeout": 180

})

return {

"current_stage": "test",

"stage_results": [{

"stage": "test",

"success": result $"success"$ ,

"output": result.get("stdout", ""),

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}],

"status": "test_success" if result $"success"$ else "test_failed"

}

def deploy_node(state: PipelineState) -> dict:

"""部署阶段"""

result = execute_command.invoke({

"command": "cd repo && docker build -t app:latest .",

"timeout": 300

})

发送部署通知

notification = send_pipeline_notification.invoke({

"recipient": "运维团队",

"message": f"流水线{state $'pipeline_id'$ }部署完成",

"level": "info"

})

return {

"current_stage": "deploy",

"stage_results": [{

"stage": "deploy",

"success": result $"success"$ ,

"output": result.get("stdout", ""),

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}],

"status": "success" if result $"success"$ else "deploy_failed",

"notifications": $notification$

}

def error_handler_node(state: PipelineState) -> dict:

"""错误处理节点"""

发送错误通知

notification = send_pipeline_notification.invoke({

"recipient": "开发团队",

"message": f"流水线{state $'pipeline_id'$ }在{state $'current_stage'$ }阶段失败",

"level": "error"

})

AI分析错误

prompt = ChatPromptTemplate.from_messages([

("system", "分析流水线错误并给出修复建议"),

("user", "错误信息：{errors}")

])

chain = prompt | self.llm

analysis = chain.invoke({"errors": str(state $"errors"$ )})

return {

"status": "failed",

"notifications": $notification, analysis.content$

}

构建状态图

workflow = StateGraph(PipelineState)

添加节点

workflow.add_node("checkout", checkout_node, timeout=TimeoutPolicy(run_timeout=30))

workflow.add_node("build", build_node, timeout=TimeoutPolicy(run_timeout=120))

workflow.add_node("test", test_node, timeout=TimeoutPolicy(run_timeout=180))

workflow.add_node("deploy", deploy_node, timeout=TimeoutPolicy(run_timeout=300))

workflow.add_node("error_handler", error_handler_node)

设置入口点

workflow.set_entry_point("checkout")

添加条件边（根据执行结果路由）

def route_by_status(state: PipelineState) -> str:

"""根据状态路由"""

if state $"status"$ .endswith("_success"):

return "next"

elif state $"status"$ .endswith("_failed"):

return "error"

else:

return "end"

Checkout -> Build or Error

workflow.add_conditional_edges(

"checkout",

route_by_status,

{

"next": "build",

"error": "error_handler",

"end": END

}

)

Build -> Test or Error

workflow.add_conditional_edges(

"build",

route_by_status,

{

"next": "test",

"error": "error_handler",

"end": END

}

)

Test -> Deploy or Error

workflow.add_conditional_edges(

"test",

route_by_status,

{

"next": "deploy",

"error": "error_handler",

"end": END

}

)

Deploy -> End

workflow.add_edge("deploy", END)

Error Handler -> End

workflow.add_edge("error_handler", END)

return workflow

def run(self, pipeline_config: dict):

"""运行流水线

Args:

pipeline_config: 流水线配置

Returns:

流水线执行结果

"""

初始化状态

initial_state = {

"pipeline_id": pipeline_config.get("pipeline_id", "PIPELINE-001"),

"pipeline_name": pipeline_config.get("pipeline_name", "CI/CD Pipeline"),

"pipeline_type": "ci_cd",

"current_stage": "",

"stages": $"checkout", "build", "test", "deploy"$ ,

"stage_results": \[\],

"status": "running",

"errors": \[\],

"retry_count": 0,

"max_retries": 3,

"notifications": \[\],

"metrics": {}

}

编译工作流

app = self.workflow.compile(checkpointer=MemorySaver())

执行流水线

result = app.invoke(

initial_state,

config={"configurable": {"thread_id": initial_state $"pipeline_id"$ }}

)

return result

```

**4. 数据处理流水线示例：**

```python

class DataProcessingPipeline:

"""数据处理流水线"""

def init(self):

self.llm = ChatOpenAI(model="gpt-4o")

self.workflow = self._build_workflow()

def _build_workflow(self):

"""构建数据处理流水线"""

def extract_node(state: PipelineState) -> dict:

"""数据提取阶段"""

模拟数据提取

result = execute_command.invoke({

"command": "python extract_data.py --source database",

"timeout": 60

})

return {

"current_stage": "extract",

"stage_results": [{

"stage": "extract",

"success": result $"success"$ ,

"records": 1000, # 模拟提取记录数

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}]

}

def transform_node(state: PipelineState) -> dict:

"""数据转换阶段"""

result = execute_command.invoke({

"command": "python transform_data.py --input extracted_data.csv",

"timeout": 120

})

return {

"current_stage": "transform",

"stage_results": [{

"stage": "transform",

"success": result $"success"$ ,

"transformed_records": 950, # 模拟转换记录数

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}]

}

def load_node(state: PipelineState) -> dict:

"""数据加载阶段"""

result = execute_command.invoke({

"command": "python load_data.py --input transformed_data.csv --target warehouse",

"timeout": 180

})

记录指标

metrics = record_metrics.invoke({

"pipeline_id": state $"pipeline_id"$ ,

"stage": "load",

"metrics": {

"total_records": 950,

"load_time": 180,

"success_rate": 0.95

}

})

return {

"current_stage": "load",

"stage_results": [{

"stage": "load",

"success": result $"success"$ ,

"loaded_records": 950,

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}],

"metrics": {"record": metrics}

}

构建工作流

workflow = StateGraph(PipelineState)

workflow.add_node("extract", extract_node)

workflow.add_node("transform", transform_node)

workflow.add_node("load", load_node)

workflow.set_entry_point("extract")

workflow.add_edge("extract", "transform")

workflow.add_edge("transform", "load")

workflow.add_edge("load", END)

return workflow

def run(self, pipeline_config: dict):

"""运行数据处理流水线"""

initial_state = {

"pipeline_id": pipeline_config.get("pipeline_id", "DATA-001"),

"pipeline_name": pipeline_config.get("pipeline_name", "Data Processing"),

"pipeline_type": "data_processing",

"current_stage": "",

"stages": $"extract", "transform", "load"$ ,

"stage_results": \[\],

"status": "running",

"errors": \[\],

"retry_count": 0,

"max_retries": 3,

"notifications": \[\],

"metrics": {}

}

app = self.workflow.compile()

result = app.invoke(initial_state)

return result

```

**5. 使用示例：**

```python

CI/CD流水线示例

cicd = CICDPipeline()

pipeline_config = {

"pipeline_id": "CI-2026-001",

"pipeline_name": "Python项目CI/CD"

}

result = cicd.run(pipeline_config)

print(f"流水线状态：{result $'status'$ }")

print(f"执行阶段：{result $'stage_results'$ }")

数据处理流水线示例

data_pipeline = DataProcessingPipeline()

data_config = {

"pipeline_id": "DATA-2026-001",

"pipeline_name": "用户数据处理"

}

data_result = data_pipeline.run(data_config)

print(f"数据处理状态：{data_result $'status'$ }")

print(f"处理记录数：{data_result $'metrics'$ }")

```

🧪 测试用例

**测试用例1：CI/CD流水线测试**

```python

import unittest

class TestCICDPipeline(unittest.TestCase):

"""CI/CD流水线测试"""

def setUp(self):

"""测试初始化"""

self.pipeline = CICDPipeline()

def test_checkout_stage(self):

"""测试代码检出阶段"""

initial_state = {

"pipeline_id": "TEST-CI-001",

"pipeline_name": "测试流水线",

"pipeline_type": "ci_cd",

"current_stage": "",

"stages": $"checkout", "build", "test", "deploy"$ ,

"stage_results": \[\],

"status": "running",

"errors": \[\],

"retry_count": 0,

"max_retries": 3,

"notifications": \[\],

"metrics": {}

}

app = self.pipeline.workflow.compile()

result = app.invoke(initial_state)

验证检出阶段

checkout_result = $r for r in result\['stage_results'$ if r $'stage'$ == 'checkout']

self.assertTrue(len(checkout_result) > 0)

def test_full_pipeline_success(self):

"""测试完整流水线成功执行"""

pipeline_config = {

"pipeline_id": "TEST-CI-002",

"pipeline_name": "完整测试"

}

result = self.pipeline.run(pipeline_config)

验证流水线完成

self.assertEqual(result $'status'$ , 'success')

self.assertTrue(len(result $'stage_results'$ ) == 4)

def test_pipeline_failure_handling(self):

"""测试流水线失败处理"""

模拟失败场景（实际测试中需要模拟命令失败）

initial_state = {

"pipeline_id": "TEST-CI-003",

"pipeline_name": "失败测试",

"pipeline_type": "ci_cd",

"current_stage": "build",

"stages": $"checkout", "build", "test", "deploy"$ ,

"stage_results": [{

"stage": "checkout",

"success": True,

"timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")

}],

"status": "build_failed",

"errors": $"构建失败"$ ,

"retry_count": 0,

"max_retries": 3,

"notifications": \[\],

"metrics": {}

}

验证错误处理节点被触发

self.assertIn("error_handler", self.pipeline.workflow.nodes)

if name == "main":

unittest.main()

```

**测试用例2：数据处理流水线测试**

```python

class TestDataProcessingPipeline(unittest.TestCase):

"""数据处理流水线测试"""

def setUp(self):

"""测试初始化"""

self.pipeline = DataProcessingPipeline()

def test_extract_stage(self):

"""测试数据提取阶段"""

initial_state = {

"pipeline_id": "TEST-DATA-001",

"pipeline_name": "数据测试",

"pipeline_type": "data_processing",

"current_stage": "",

"stages": $"extract", "transform", "load"$ ,

"stage_results": \[\],

"status": "running",

"errors": \[\],

"retry_count": 0,

"max_retries": 3,

"notifications": \[\],

"metrics": {}

}

app = self.pipeline.workflow.compile()

result = app.invoke(initial_state)

验证提取阶段

extract_result = $r for r in result\['stage_results'$ if r $'stage'$ == 'extract']

self.assertTrue(len(extract_result) > 0)

def test_full_pipeline_execution(self):

"""测试完整数据处理流水线"""

pipeline_config = {

"pipeline_id": "TEST-DATA-002",

"pipeline_name": "完整数据处理"

}

result = self.pipeline.run(pipeline_config)

验证流水线完成

self.assertTrue(len(result $'stage_results'$ ) == 3)

self.assertIn('metrics', result)

def test_metrics_recording(self):

"""测试指标记录"""

metrics_result = record_metrics.invoke({

"pipeline_id": "TEST-001",

"stage": "load",

"metrics": {"records": 100, "time": 60}

})

验证指标记录

self.assertIn("指标已记录", metrics_result)

if name == "main":

unittest.main()

```

**测试用例3：流水线工具测试**

```python

class TestPipelineTools(unittest.TestCase):

"""流水线工具测试"""

def test_execute_command_success(self):

"""测试命令执行成功"""

result = execute_command.invoke({

"command": "echo 'Hello World'",

"timeout": 10

})

验证执行成功

self.assertTrue(result $'success'$ )

self.assertEqual(result $'return_code'$ , 0)

self.assertIn('Hello World', result $'stdout'$ )

def test_execute_command_failure(self):

"""测试命令执行失败"""

result = execute_command.invoke({

"command": "ls /nonexistent_directory",

"timeout": 10

})

验证执行失败

self.assertFalse(result $'success'$ )

self.assertTrue(result $'return_code'$ != 0)

def test_execute_command_timeout(self):

"""测试命令执行超时"""

result = execute_command.invoke({

"command": "sleep 10", # 睡眠10秒

"timeout": 5 # 超时5秒

})

验证超时

self.assertFalse(result $'success'$ )

self.assertIn("超时", result.get('error', ''))

def test_notification_tool(self):

"""测试通知工具"""

result = send_pipeline_notification.invoke({

"recipient": "测试团队",

"message": "测试通知",

"level": "info"

})

验证通知

self.assertIn("发送给测试团队", result)

self.assertIn(" $INFO$ ", result)

if name == "main":

unittest.main()

```

附录：学习资源推荐

官方文档

LangChain: https://python.langchain.com
LangGraph: https://langchain-ai.github.io/langgraph
AutoGen: https://microsoft.github.io/autogen
CrewAI: https://docs.crewai.com

学习路径

**基础阶段**：理解Agent概念、LLM调用
**进阶阶段**：工具调用、RAG、记忆机制
**高级阶段**：Multi-Agent、工作流、部署