📚 目录
- Transformer基础：它是什么？
- Transformer在Agent中的作用
- 核心模块关系：LLM、RAG、Prompt、Transformer
- 模块间交互流程详解
- 完整实现代码解析
- 实战演练：一步步构建Agent
- 常见问题与优化
1. Transformer基础：它是什么？
1.1 Transformer的本质
Transformer 是一种深度学习架构，专门用于处理序列数据（如文本、语音等）。
核心特点：
- 📐 架构：基于注意力机制（Attention Mechanism）的神经网络
- 🎯 用途：理解语言、生成文本、翻译、问答等
- 🧠 能力：能够捕捉序列中不同位置之间的依赖关系
1.2 Transformer的物理形态
在Agent系统中，Transformer通常以**大语言模型（LLM）**的形式出现：
Transformer架构
↓
[训练过程：使用海量文本数据]
↓
训练好的模型（如GPT、ChatGLM、DeepSeek）
↓
通过API或本地部署提供服务
↓
我们通过代码调用它实际例子：
- GPT-3.5/GPT-4：OpenAI的Transformer模型
- DeepSeek：国产Transformer模型
- ChatGLM：清华的Transformer模型
1.3 Transformer的工作原理（简化版）
输入文本: "什么是RAG？"
↓
【步骤1: 分词（Tokenization）】
将文本切分成token（词或子词）
["什么", "是", "RAG", "？"]
↓
【步骤2: 词向量化（Embedding）】
每个token转为数字向量
"RAG" → [0.1, 0.3, -0.2, 0.5, ...] (768维向量)
↓
【步骤3: 位置编码（Positional Encoding）】
添加位置信息，告诉模型每个词的位置
↓
【步骤4: 多层Transformer处理】
通过12-96层Transformer层，每层包含：
- 自注意力机制（Self-Attention）：关注重要信息
- 前馈网络（Feed-Forward）：处理信息
- 层归一化（Layer Norm）：稳定训练
↓
【步骤5: 输出层】
生成下一个token的概率分布
↓
【步骤6: 解码】
根据概率分布生成回答
"RAG是检索增强生成技术..."1.4 为什么叫"Transformer"？
Transform = 转换、变换
Transformer的作用是：将输入文本转换为输出文本
输入: "什么是RAG？"
↓ [Transform/转换]
输出: "RAG是检索增强生成技术..."2. Transformer在Agent中的作用
2.1 Agent系统的核心组件
一个完整的Agent系统通常包含：
┌─────────────────────────────────────────┐
│ Agent系统架构 │
├─────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌────────┐│
│ │ Prompt │→ │ LLM │← │ RAG ││
│ │ (提示词) │ │(Transformer)│(检索) ││
│ └──────────┘ └──────────┘ └────────┘│
│ │ │ │ │
│ └────────────┴────────────┘ │
│ │ │
│ ┌─────▼─────┐ │
│ │ Agent │ │
│ │ (协调层) │ │
│ └───────────┘ │
└─────────────────────────────────────────┘2.2 Transformer在Agent中的三大作用
作用1: 理解用户输入（理解能力）
用户输入: "帮我查一下图书馆的开放时间"
↓
[Transformer处理]
↓
理解结果:
- 意图：查询信息
- 实体：图书馆、开放时间
- 动作：检索相关信息作用2: 生成回答（生成能力）
上下文 + 用户问题
↓
[Transformer处理]
↓
生成回答: "图书馆的开放时间是周一至周五 9:00-21:00..."作用3: 处理上下文（记忆能力）
对话历史:
- 用户: "你好"
- Agent: "你好，有什么可以帮助你的？"
- 用户: "图书馆在哪？"
↓
[Transformer记住对话历史]
↓
生成连贯回答: "图书馆位于校园中心..."2.3 Transformer vs 传统规则系统
| 特性 | 传统规则系统 | Transformer-based Agent |
|---|---|---|
| 理解方式 | 关键词匹配 | 语义理解 |
| 灵活性 | 低（需要写规则） | 高（自动学习） |
| 上下文 | 不支持 | 支持多轮对话 |
| 扩展性 | 难（需要改代码） | 易（通过Prompt调整） |
| 准确性 | 依赖规则质量 | 依赖模型能力 |
3. 核心模块关系：LLM、RAG、Prompt、Transformer
3.1 模块定义与关系图
模块1: Transformer（底层架构）
定义：深度学习模型架构，是LLM的基础
位置：最底层，是其他模块的基础
Transformer架构
↓
训练好的模型参数
↓
封装成LLM服务模块2: LLM（大语言模型）
定义：基于Transformer架构训练好的模型，提供文本生成能力
与Transformer的关系：
- LLM = Transformer架构 + 训练好的参数
- 我们通过LLM API调用Transformer的能力
实际例子：
python
# LLM是对Transformer的封装
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="deepseek-chat", # 这是一个基于Transformer的LLM
api_key="your-key"
)
# 调用LLM = 调用底层的Transformer
response = llm.invoke("什么是RAG？")模块3: Prompt（提示词）
定义：给LLM的指令和上下文，告诉它要做什么
与LLM/Transformer的关系：
- Prompt是输入给Transformer的文本
- Transformer根据Prompt生成回答
例子：
python
# Prompt = 系统提示 + 用户问题
prompt = """
你是一个专业的图书馆助手。
请回答用户的问题。
用户问题：图书馆开放时间是多少？
"""
# Transformer根据这个Prompt生成回答
response = llm.invoke(prompt)模块4: RAG（检索增强生成）
定义：从外部知识库检索相关信息，增强LLM的回答
与LLM/Transformer的关系：
- RAG检索到的文档 → 作为Prompt的一部分 → 输入给Transformer
- Transformer基于检索到的信息生成更准确的回答
关系图：
用户问题
↓
[RAG检索] → 找到相关文档
↓
[构建Prompt] → Prompt = 系统提示 + 检索到的文档 + 用户问题
↓
[Transformer处理] → 基于Prompt生成回答
↓
最终回答3.2 完整关系图
┌─────────────────────────────────────────────────────────┐
│ Agent系统 │
└─────────────────────────────────────────────────────────┘
│
┌───────────────────┼───────────────────┐
│ │ │
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Prompt │ │ LLM │ │ RAG │
│ (提示词) │ │ (Transformer)│ │ (检索) │
└──────┬───────┘ └──────┬──────┘ └──────┬───────┘
│ │ │
│ │ │
│ ┌───────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────┐ │
│ │ Transformer │ │
│ │ (底层架构) │ │
│ └──────────────┘ │
│ │
└────────────────────────────────────────┘
│
▼
┌──────────┐
│ Agent │
│ (协调层) │
└──────────┘3.3 数据流向详解
场景1: 简单问答（不使用RAG）
用户输入: "你好"
↓
[构建Prompt]
Prompt = "你是一个友好的助手。\n用户：你好"
↓
[调用LLM（Transformer）]
LLM接收Prompt → Transformer处理 → 生成回答
↓
Agent回答: "你好！有什么可以帮助你的？"场景2: 知识问答（使用RAG）
用户输入: "图书馆开放时间？"
↓
[RAG检索]
查询向量化 → 相似度搜索 → 找到相关文档
"图书馆开放时间是周一至周五 9:00-21:00"
↓
[构建Prompt]
Prompt = """
你是一个图书馆助手。
检索到的信息：
图书馆开放时间是周一至周五 9:00-21:00
用户问题：图书馆开放时间？
"""
↓
[调用LLM（Transformer）]
Transformer基于Prompt（包含检索信息）生成回答
↓
Agent回答: "图书馆开放时间是周一至周五 9:00-21:00"3.4 模块职责总结
| 模块 | 职责 | 输入 | 输出 | 与Transformer的关系 |
|---|---|---|---|---|
| Transformer | 底层架构，处理文本 | Token序列 | Token概率分布 | 核心引擎 |
| LLM | 封装Transformer，提供API | 文本消息 | 文本回答 | LLM = Transformer + 参数 |
| Prompt | 指导Transformer行为 | 用户意图 | 格式化指令 | Prompt是Transformer的输入 |
| RAG | 提供外部知识 | 用户查询 | 相关文档 | RAG结果作为Prompt的一部分 |
| Agent | 协调所有模块 | 用户输入 | 最终回答 | Agent调用LLM（Transformer） |
4. 模块间交互流程详解
4.1 完整交互流程图
┌─────────────────────────────────────────────────────────────┐
│ 步骤0: 用户输入 │
│ "图书馆开放时间是多少？" │
└────────────────────┬────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 步骤1: Agent接收用户输入 │
│ agent.invoke("图书馆开放时间是多少？") │
└────────────────────┬────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 步骤2: 判断是否需要RAG检索 │
│ should_retrieve() → True │
└────────────────────┬────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 步骤3: RAG检索模块 │
│ ┌──────────────────────────────────────┐ │
│ │ 3.1 查询向量化 │ │
│ │ "图书馆开放时间" → [0.1, 0.3, ...] │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────┐ │
│ │ 3.2 相似度搜索 │ │
│ │ 在向量数据库中查找最相似的文档 │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────┐ │
│ │ 3.3 返回相关文档 │ │
│ │ Doc1: "图书馆开放时间：周一至周五..." │ │
│ └──────────────────────────────────────┘ │
└────────────────────┬────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 步骤4: 构建Prompt │
│ ┌──────────────────────────────────────┐ │
│ │ 4.1 系统提示 │ │
│ │ "你是一个图书馆助手..." │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────┐ │
│ │ 4.2 添加RAG检索结果 │ │
│ │ "检索到的信息：图书馆开放时间..." │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────┐ │
│ │ 4.3 添加用户问题 │ │
│ │ "用户问题：图书馆开放时间是多少？" │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────┐ │
│ │ 最终Prompt: │ │
│ │ SystemMessage + 检索信息 + 用户问题 │ │
│ └──────────────────────────────────────┘ │
└────────────────────┬────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 步骤5: 调用LLM（Transformer） │
│ ┌──────────────────────────────────────┐ │
│ │ 5.1 LLM接收Prompt │ │
│ │ messages = [SystemMessage, ...] │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────┐ │
│ │ 5.2 Transformer内部处理 │ │
│ │ - Tokenization: 分词 │ │
│ │ - Embedding: 词向量化 │ │
│ │ - Attention: 注意力计算 │ │
│ │ - Generation: 逐token生成 │ │
│ └──────────────────────────────────────┘ │
│ ┌──────────────────────────────────────┐ │
│ │ 5.3 返回生成的回答 │ │
│ │ AIMessage("图书馆开放时间是...") │ │
│ └──────────────────────────────────────┘ │
└────────────────────┬────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ 步骤6: Agent返回结果 │
│ response = "图书馆开放时间是周一至周五 9:00-21:00" │
└─────────────────────────────────────────────────────────────┘4.2 关键交互点详解
交互点1: RAG → Prompt
python
# RAG检索结果
rag_results = [
"图书馆开放时间：周一至周五 9:00-21:00",
"周末开放时间：10:00-18:00"
]
# 将RAG结果整合到Prompt中
prompt = f"""
你是一个图书馆助手。
检索到的相关信息：
{chr(10).join(rag_results)}
用户问题：图书馆开放时间是多少？
"""交互点2: Prompt → LLM
python
# Prompt转换为消息格式
messages = [
SystemMessage(content="你是一个图书馆助手..."),
HumanMessage(content="图书馆开放时间是多少？")
]
# 调用LLM（内部调用Transformer）
response = llm.invoke(messages)交互点3: LLM → Transformer
python
# LLM内部调用Transformer的过程（简化版）
def llm_invoke(messages):
# 1. 将消息转换为文本
text = format_messages(messages)
# 2. Transformer处理
tokens = tokenize(text) # 分词
embeddings = embed(tokens) # 向量化
hidden_states = transformer_layers(embeddings) # Transformer层处理
output = generate(hidden_states) # 生成
# 3. 返回结果
return decode(output)4.3 多轮对话的交互流程
第一轮对话:
用户: "你好"
↓
[构建Prompt] → "你是一个助手。用户：你好"
↓
[Transformer] → "你好！有什么可以帮助你的？"
↓
[保存对话历史]
第二轮对话:
用户: "图书馆在哪？"
↓
[构建Prompt] → "你是一个助手。
历史对话：
- 用户：你好
- 助手：你好！有什么可以帮助你的？
用户：图书馆在哪？"
↓
[Transformer] → 基于完整上下文生成回答
↓
"图书馆位于校园中心..."5. 完整实现代码解析
5.1 代码结构说明
完整代码在 agent_transformer_demo.py 中，包含三个类：
- SimpleAgent - 基础Agent（只用Transformer/LLM）
- RAGAgent - RAG增强Agent（RAG + Transformer）
- CompleteAgentWorkflow - 完整工作流（所有模块协作）
5.2 关键代码片段解析
片段1: 初始化LLM（Transformer的封装）
python
from langchain_openai import ChatOpenAI
# 这里初始化的是LLM，它内部封装了Transformer
llm = ChatOpenAI(
model="deepseek-chat", # 基于Transformer的模型
api_key=api_key,
base_url="https://api.deepseek.com",
temperature=0.7, # 控制随机性
max_tokens=2000 # 最大输出长度
)
# 当我们调用llm.invoke()时，实际发生的是：
# 1. 将消息转换为文本格式
# 2. 发送到API（或本地模型）
# 3. Transformer处理文本
# 4. 返回生成的文本关键理解：
ChatOpenAI是对Transformer模型的封装llm.invoke()内部调用Transformer- 我们不需要直接操作Transformer，通过LLM API即可
片段2: 构建Prompt
python
from langchain_core.messages import SystemMessage, HumanMessage
# Prompt的构建方式
system_prompt = "你是一个专业的图书馆助手。"
user_question = "图书馆开放时间是多少？"
# 方式1: 简单Prompt
messages = [
SystemMessage(content=system_prompt),
HumanMessage(content=user_question)
]
# 方式2: 带RAG结果的Prompt
rag_context = "检索到的信息：图书馆开放时间是周一至周五 9:00-21:00"
messages = [
SystemMessage(content=f"{system_prompt}\n\n{rag_context}"),
HumanMessage(content=user_question)
]
# 调用LLM（Transformer处理这个Prompt）
response = llm.invoke(messages)关键理解：
- Prompt = 系统提示 + 上下文 + 用户问题
- RAG结果作为上下文的一部分加入Prompt
- Transformer根据完整的Prompt生成回答
片段3: RAG检索与Prompt整合
python
from langchain_community.vectorstores import Chroma
# 1. RAG检索
vectorstore = Chroma(...)
docs = vectorstore.similarity_search("图书馆开放时间", k=2)
# 返回: ["图书馆开放时间：周一至周五 9:00-21:00", ...]
# 2. 将RAG结果整合到Prompt
context = "\n\n".join([doc.page_content for doc in docs])
prompt = f"""
你是一个图书馆助手。
检索到的相关信息：
{context}
用户问题：图书馆开放时间是多少？
"""
# 3. 调用Transformer
messages = [SystemMessage(content=prompt)]
response = llm.invoke(messages)关键理解：
- RAG检索 → 找到相关文档
- 文档内容 → 加入Prompt作为上下文
- Prompt → 输入给Transformer
- Transformer → 基于上下文生成回答
片段4: 完整工作流
python
class CompleteAgentWorkflow:
def process(self, user_input: str):
# 步骤1: 判断是否需要RAG
if self._should_retrieve(user_input):
# 步骤2: RAG检索
context = self._retrieve_context(user_input)
else:
context = ""
# 步骤3: 构建Prompt（包含RAG结果）
messages = self._build_messages(user_input, context)
# 步骤4: 调用LLM（Transformer处理）
response = self.llm.invoke(messages)
# 步骤5: 返回结果
return response.content关键理解：
- Agent协调RAG、Prompt、LLM三个模块
- RAG提供知识 → Prompt整合信息 → LLM（Transformer）生成回答
- 这是一个完整的端到端流程
6. 实战演练：一步步构建Agent
6.1 第一步：最简单的Agent（只用Transformer）
python
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
# 1. 初始化LLM（Transformer）
llm = ChatOpenAI(
model="deepseek-chat",
api_key="your-api-key",
base_url="https://api.deepseek.com"
)
# 2. 构建Prompt（最简单的形式）
messages = [HumanMessage(content="你好")]
# 3. 调用Transformer
response = llm.invoke(messages)
print(response.content) # "你好！有什么可以帮助你的？"理解要点：
- LLM = Transformer的封装
- Prompt = 用户输入
- 调用LLM = 调用Transformer
6.2 第二步：添加系统Prompt
python
from langchain_core.messages import SystemMessage, HumanMessage
# 1. 初始化LLM
llm = ChatOpenAI(...)
# 2. 构建Prompt（包含系统提示）
messages = [
SystemMessage(content="你是一个专业的图书馆助手。"),
HumanMessage(content="图书馆开放时间是多少？")
]
# 3. 调用Transformer
response = llm.invoke(messages)理解要点：
- SystemMessage = 系统提示，告诉Transformer扮演什么角色
- HumanMessage = 用户问题
- Transformer根据系统提示和用户问题生成回答
6.3 第三步：添加RAG检索
python
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document
# 1. 初始化RAG系统
embeddings = HuggingFaceEmbeddings(...)
vectorstore = Chroma(embedding_function=embeddings)
# 2. 添加知识库
docs = [Document(page_content="图书馆开放时间：周一至周五 9:00-21:00")]
vectorstore.add_documents(docs)
# 3. 检索相关文档
query = "图书馆开放时间是多少？"
retrieved_docs = vectorstore.similarity_search(query, k=1)
# 4. 构建Prompt（包含RAG结果）
context = retrieved_docs[0].page_content
messages = [
SystemMessage(content=f"你是一个图书馆助手。\n\n检索到的信息：{context}"),
HumanMessage(content=query)
]
# 5. 调用Transformer
response = llm.invoke(messages)理解要点：
- RAG检索 → 找到相关文档
- 文档内容 → 加入SystemMessage
- Prompt = 系统提示 + RAG结果 + 用户问题
- Transformer基于完整Prompt生成回答
6.4 第四步：完整Agent（所有模块协作）
python
class CompleteAgent:
def __init__(self, api_key):
# 初始化所有模块
self.llm = ChatOpenAI(...) # LLM（Transformer）
self.vectorstore = Chroma(...) # RAG
self.conversation_history = [] # 对话历史
def chat(self, user_input):
# 1. RAG检索
docs = self.vectorstore.similarity_search(user_input, k=2)
context = "\n\n".join([d.page_content for d in docs])
# 2. 构建Prompt
messages = [
SystemMessage(content=f"检索到的信息：{context}"),
*self.conversation_history, # 历史对话
HumanMessage(content=user_input)
]
# 3. 调用Transformer
response = self.llm.invoke(messages)
# 4. 保存历史
self.conversation_history.append(HumanMessage(content=user_input))
self.conversation_history.append(response)
return response.content理解要点：
- Agent协调RAG、Prompt、LLM三个模块
- 完整流程：用户输入 → RAG检索 → 构建Prompt → Transformer处理 → 返回回答
7. 常见问题与优化
7.1 概念澄清
Q1: Transformer和LLM是什么关系？
A:
-
Transformer = 架构（设计图）
-
LLM = 基于Transformer架构训练好的模型（建好的房子）
-
我们通过LLM API调用Transformer的能力
Transformer架构（设计图）
↓ [训练过程]
LLM模型（建好的房子）
↓ [API封装]
我们可以使用的服务
Q2: Prompt和Transformer怎么交互？
A:
-
Prompt是输入给Transformer的文本
-
Transformer读取Prompt，理解意图，生成回答
-
就像给AI下指令，它根据指令执行
Prompt: "你是一个助手。用户：你好"
↓ [输入给Transformer]
Transformer处理
↓ [生成回答]
回答: "你好！有什么可以帮助你的？"
Q3: RAG和Transformer怎么配合？
A:
-
RAG检索相关文档
-
文档内容作为Prompt的一部分
-
Transformer基于包含RAG结果的Prompt生成回答
用户问题
↓
[RAG检索] → 找到文档
↓
[构建Prompt] → Prompt = 系统提示 + RAG文档 + 用户问题
↓
[Transformer] → 基于完整Prompt生成回答
7.2 性能优化
优化1: Prompt优化
python
# ❌ 不好的Prompt
prompt = "回答这个问题：图书馆开放时间？"
# ✅ 好的Prompt
prompt = """
你是一个专业的图书馆助手。
请基于以下信息回答问题。
检索到的信息：
图书馆开放时间：周一至周五 9:00-21:00
用户问题：图书馆开放时间是多少？
请用专业、友好的方式回答。
"""优化2: RAG优化
python
# 增加检索数量
docs = vectorstore.similarity_search(query, k=5) # 从3增加到5
# 使用重排序
# 先检索Top-10，再重排序选择Top-3优化3: 缓存机制
python
from functools import lru_cache
@lru_cache(maxsize=100)
def cached_llm_call(prompt: str):
"""缓存相同的Prompt调用"""
return llm.invoke(prompt)📊 总结
核心概念关系
Transformer（架构）
↓
LLM（模型实现）
↓
通过Prompt调用
↓
RAG提供知识增强
↓
Agent协调所有模块数据流向
用户输入
↓
[RAG检索] → 相关文档
↓
[构建Prompt] → Prompt = 系统提示 + RAG结果 + 用户问题
↓
[LLM/Transformer处理] → 生成回答
↓
Agent返回结果关键理解
- Transformer = 底层架构，是LLM的基础
- LLM = Transformer的封装，我们通过LLM API调用Transformer
- Prompt = 给Transformer的指令和上下文
- RAG = 提供外部知识，结果加入Prompt
- Agent = 协调所有模块，实现完整工作流
下一步学习
- 📖 深入学习Transformer架构细节（Attention机制等）
- 🔧 优化Prompt工程（如何写出更好的Prompt）
- 🚀 扩展RAG能力（重排序、多跳检索等）
- 📈 性能优化（缓存、批处理、流式输出等）
完整项目代码：
python
"""
Agent Transformer 完整演示代码
包含：基础Agent、RAG增强Agent、完整工作流
"""
import os
from typing import List, Optional
from langchain_openai import ChatOpenAI
from langchain_core.messages import (
BaseMessage,
HumanMessage,
AIMessage,
SystemMessage
)
from langchain_core.documents import Document
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import Chroma
# ============================================================================
# 第一部分：基础Agent演示
# ============================================================================
class SimpleAgent:
"""简化版Agent - 展示Transformer核心流程"""
def __init__(self, api_key: str, model: str = "deepseek-chat"):
"""
初始化Agent
Args:
api_key: LLM API密钥
model: 模型名称，默认使用deepseek-chat
"""
# 初始化Transformer模型（通过LangChain封装）
self.llm = ChatOpenAI(
model=model,
api_key=api_key,
base_url="https://api.deepseek.com",
temperature=0.7,
max_tokens=2000
)
# 对话历史
self.conversation_history: List[BaseMessage] = []
def chat(self, user_input: str, context: Optional[str] = None) -> str:
"""
与Agent对话
Args:
user_input: 用户输入
context: 可选的上下文信息（来自RAG检索）
Returns:
Agent的回答
"""
# 步骤1: 构建消息列表
messages = []
# 如果有上下文，添加系统消息
if context:
system_prompt = f"""你是一个智能助手。请基于以下上下文信息回答用户问题：
上下文信息：
{context}
请基于上下文信息，用专业、友好的方式回答用户的问题。"""
messages.append(SystemMessage(content=system_prompt))
# 添加对话历史
messages.extend(self.conversation_history)
# 添加当前用户输入
messages.append(HumanMessage(content=user_input))
# 步骤2: 调用Transformer
print("🔄 正在调用Transformer模型...")
response = self.llm.invoke(messages)
# 步骤3: 保存对话历史
self.conversation_history.append(HumanMessage(content=user_input))
self.conversation_history.append(response)
# 步骤4: 返回回答
return response.content
def reset(self):
"""重置对话历史"""
self.conversation_history = []
print("✅ 对话历史已重置")
# ============================================================================
# 第二部分：RAG增强Agent演示
# ============================================================================
class RAGAgent:
"""RAG增强的Agent - 结合检索和Transformer"""
def __init__(self, api_key: str):
"""
初始化RAG Agent
Args:
api_key: LLM API密钥
"""
# 1. 初始化嵌入模型（用于向量化）
print("📦 初始化嵌入模型...")
self.embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2",
model_kwargs={'device': 'cpu'}
)
# 2. 初始化向量数据库
print("📦 初始化向量数据库...")
self.vectorstore = Chroma(
persist_directory="./demo_vector_db",
embedding_function=self.embeddings
)
# 3. 初始化Transformer模型
print("📦 初始化Transformer模型...")
self.llm = ChatOpenAI(
model="deepseek-chat",
api_key=api_key,
base_url="https://api.deepseek.com",
temperature=0.7,
max_tokens=2000
)
print("✅ RAG Agent初始化完成！\n")
def add_knowledge(self, documents: List[Document]):
"""
添加知识到向量数据库
Args:
documents: 文档列表
"""
print(f"📚 添加 {len(documents)} 个文档到知识库...")
self.vectorstore.add_documents(documents)
print("✅ 文档添加完成！\n")
def chat(self, query: str, k: int = 3) -> str:
"""
使用RAG增强的对话
Args:
query: 用户查询
k: 检索的文档数量
Returns:
Agent的回答
"""
print(f"🔍 检索相关文档（Top-{k}）...")
# 步骤1: 检索相关文档
docs = self.vectorstore.similarity_search(query, k=k)
if not docs:
print("⚠️ 未找到相关文档，将使用Transformer的通用知识回答")
context = ""
else:
print(f"✅ 找到 {len(docs)} 个相关文档")
# 构建上下文
context = "\n\n".join([
f"[文档{i+1}]\n{doc.page_content}"
for i, doc in enumerate(docs)
])
# 步骤2: 构建提示
system_prompt = f"""你是一个智能助手。请基于以下检索到的文档内容回答用户问题。
检索到的文档内容：
{context if context else "（未找到相关文档，请基于你的知识回答）"}
回答要求：
1. 优先使用检索到的文档内容
2. 如果文档中没有相关信息，可以基于你的知识补充
3. 保持回答准确、专业、友好
4. 如果引用了文档内容，可以说明来源
"""
# 步骤3: 调用Transformer
print("🔄 调用Transformer生成回答...")
messages = [
SystemMessage(content=system_prompt),
HumanMessage(content=query)
]
response = self.llm.invoke(messages)
print("✅ 回答生成完成！\n")
return response.content
# ============================================================================
# 第三部分：完整工作流演示
# ============================================================================
class CompleteAgentWorkflow:
"""完整Agent工作流 - 端到端演示"""
def __init__(self, api_key: str):
"""
初始化完整Agent工作流
Args:
api_key: LLM API密钥
"""
print("🚀 初始化完整Agent工作流...")
print()
# 1. 初始化RAG系统
print(" [1/4] 初始化RAG系统...")
self.embeddings = HuggingFaceEmbeddings(
model_name="sentence-transformers/all-MiniLM-L6-v2",
model_kwargs={'device': 'cpu'}
)
self.vectorstore = Chroma(
persist_directory="./demo_vector_db",
embedding_function=self.embeddings
)
print(" ✅ RAG系统就绪")
# 2. 初始化Transformer
print(" [2/4] 初始化Transformer模型...")
self.llm = ChatOpenAI(
model="deepseek-chat",
api_key=api_key,
base_url="https://api.deepseek.com",
temperature=0.7,
max_tokens=2000
)
print(" ✅ Transformer就绪")
# 3. 初始化对话历史
print(" [3/4] 初始化对话历史...")
self.conversation_history = []
print(" ✅ 对话历史就绪")
# 4. 初始化知识库
print(" [4/4] 初始化知识库...")
self._init_knowledge_base()
print(" ✅ 知识库就绪")
print("\n✅ 完整Agent工作流初始化完成！\n")
def _init_knowledge_base(self):
"""初始化知识库"""
docs = [
Document(page_content="""
RAG（Retrieval-Augmented Generation）是检索增强生成技术。
工作流程：1) 用户查询 2) 检索相关文档 3) 构建上下文 4) Transformer生成回答
"""),
Document(page_content="""
Transformer使用自注意力机制处理序列数据。
核心组件：Multi-Head Attention、Feed-Forward Network、Layer Normalization
"""),
Document(page_content="""
Agent工作流包括：输入处理、检索增强、Transformer生成、输出格式化
"""),
]
self.vectorstore.add_documents(docs)
def process(self, user_input: str, verbose: bool = True) -> str:
"""
处理用户输入 - 完整工作流
Args:
user_input: 用户输入
verbose: 是否显示详细步骤
Returns:
Agent的回答
"""
if verbose:
print("=" * 70)
print(f"📥 用户输入: {user_input}")
print("=" * 70)
print()
# 步骤1: 判断是否需要检索
if verbose:
print("[步骤1] 判断是否需要检索...")
should_retrieve = self._should_retrieve(user_input)
if verbose:
print(f" → 需要检索: {should_retrieve}")
print()
# 步骤2: 检索相关文档（如果需要）
context = ""
if should_retrieve:
if verbose:
print("[步骤2] 检索相关文档...")
context = self._retrieve_context(user_input)
if verbose:
print(f" → 检索到 {len(context.split('[文档'))-1 if '[文档' in context else 0} 个相关文档")
print()
# 步骤3: 构建消息列表
if verbose:
print("[步骤3] 构建消息列表...")
messages = self._build_messages(user_input, context)
if verbose:
print(f" → 消息数量: {len(messages)}")
print()
# 步骤4: 调用Transformer
if verbose:
print("[步骤4] 调用Transformer生成回答...")
response = self.llm.invoke(messages)
if verbose:
print(" → Transformer处理完成")
print()
# 步骤5: 保存对话历史
if verbose:
print("[步骤5] 保存对话历史...")
self.conversation_history.append(HumanMessage(content=user_input))
self.conversation_history.append(AIMessage(content=response.content))
if verbose:
print(" → 对话历史已更新")
print()
# 步骤6: 返回结果
if verbose:
print("=" * 70)
print(f"📤 Agent回答: {response.content}")
print("=" * 70)
print()
return response.content
def _should_retrieve(self, query: str) -> bool:
"""判断是否需要检索"""
# 简单策略：如果对话历史为空或查询包含特定关键词，则检索
if not self.conversation_history:
return True
# 如果查询包含"什么是"、"如何"等，可能需要检索
retrieval_keywords = ["什么是", "如何", "怎么", "介绍", "解释"]
return any(keyword in query for keyword in retrieval_keywords)
def _retrieve_context(self, query: str, k: int = 3) -> str:
"""检索相关文档"""
docs = self.vectorstore.similarity_search(query, k=k)
if not docs:
return ""
context_parts = []
for i, doc in enumerate(docs, 1):
context_parts.append(f"[文档{i}]\n{doc.page_content}")
return "\n\n".join(context_parts)
def _build_messages(self, user_input: str, context: str) -> List:
"""构建消息列表"""
messages = []
# 如果有上下文，添加系统消息
if context:
system_prompt = f"""你是一个智能助手。请基于以下检索到的文档内容回答用户问题。
检索到的文档内容：
{context}
回答要求：
1. 优先使用检索到的文档内容
2. 保持回答准确、专业、友好
"""
messages.append(SystemMessage(content=system_prompt))
# 添加对话历史（最近3轮）
recent_history = self.conversation_history[-6:] if len(self.conversation_history) > 6 else self.conversation_history
messages.extend(recent_history)
# 添加当前用户输入
messages.append(HumanMessage(content=user_input))
return messages
def reset(self):
"""重置对话历史"""
self.conversation_history = []
print("✅ 对话历史已重置\n")
# ============================================================================
# 主程序：演示所有功能
# ============================================================================
def demo_simple_agent(api_key: str):
"""演示1: 基础Agent"""
print("=" * 70)
print("🤖 演示1: 简化版Agent演示")
print("=" * 70)
agent = SimpleAgent(api_key=api_key)
# 示例1: 第一次对话（无上下文）
print("\n【示例1】基础对话（无上下文）")
print("-" * 70)
response1 = agent.chat("你好，我是小明")
print(f"你: 你好，我是小明")
print(f"Agent: {response1}")
# 示例2: 带上下文的对话
print("\n【示例2】带上下文的对话（模拟RAG检索）")
print("-" * 70)
context = """
RAG（Retrieval-Augmented Generation）是检索增强生成技术。
它结合了信息检索和文本生成，通过检索相关文档来增强生成质量。
RAG的主要优势包括：
1. 提供准确的信息来源
2. 减少模型幻觉
3. 可以接入外部知识库
"""
response2 = agent.chat("什么是RAG？", context=context)
print(f"你: 什么是RAG？")
print(f"Agent: {response2}")
# 示例3: 利用历史上下文的对话
print("\n【示例3】多轮对话（利用历史上下文）")
print("-" * 70)
response3 = agent.chat("它有什么优势？")
print(f"你: 它有什么优势？")
print(f"Agent: {response3}")
# 示例4: 重置对话
print("\n【示例4】重置对话历史")
print("-" * 70)
agent.reset()
response4 = agent.chat("你还记得我是谁吗？")
print(f"你: 你还记得我是谁吗？")
print(f"Agent: {response4}")
print("\n" + "=" * 70)
print("✅ 演示1完成！")
print("=" * 70)
print("\n")
def demo_rag_agent(api_key: str):
"""演示2: RAG增强Agent"""
print("=" * 70)
print("🤖 演示2: RAG增强Agent演示")
print("=" * 70)
print()
# 初始化Agent
agent = RAGAgent(api_key=api_key)
# 添加知识库
knowledge_docs = [
Document(page_content="""
RAG（Retrieval-Augmented Generation）是检索增强生成技术。
它结合了信息检索和文本生成，通过检索相关文档来增强生成质量。
RAG的主要优势包括：
1. 提供准确的信息来源，减少模型幻觉
2. 可以接入外部知识库，扩展模型知识
3. 支持实时更新知识，无需重新训练模型
"""),
Document(page_content="""
Transformer是一种基于注意力机制的深度学习架构。
它由编码器（Encoder）和解码器（Decoder）组成。
Transformer的核心是自注意力机制（Self-Attention），
能够捕捉序列中不同位置之间的依赖关系。
"""),
Document(page_content="""
Agent（智能体）是能够感知环境、做出决策并执行任务的自主系统。
在AI领域，Agent通常指能够理解用户意图、调用工具、完成任务的应用。
常见的Agent类型包括：对话Agent、工具调用Agent、多模态Agent等。
"""),
Document(page_content="""
LangChain是一个用于构建LLM应用的框架。
它提供了链（Chain）、代理（Agent）、记忆（Memory）等组件。
LangGraph是LangChain的扩展，用于构建复杂的工作流。
"""),
]
agent.add_knowledge(knowledge_docs)
# 示例对话
queries = [
"什么是RAG？",
"Transformer的核心是什么？",
"Agent有哪些类型？",
"LangChain和LangGraph有什么区别？"
]
for i, query in enumerate(queries, 1):
print(f"【示例{i}】")
print("-" * 70)
print(f"你: {query}")
print()
response = agent.chat(query)
print(f"Agent: {response}")
print()
print("=" * 70)
print("✅ 演示2完成！")
print("=" * 70)
print("\n")
def demo_complete_workflow(api_key: str):
"""演示3: 完整工作流"""
print("=" * 70)
print("🤖 演示3: 完整Agent工作流演示")
print("=" * 70)
print()
# 初始化Agent
agent = CompleteAgentWorkflow(api_key=api_key)
# 示例对话
queries = [
"什么是RAG？",
"它如何工作？",
"Transformer的核心是什么？"
]
for i, query in enumerate(queries, 1):
print(f"\n【对话轮次 {i}】")
print()
agent.process(query, verbose=True)
# 重置对话
print("\n" + "=" * 70)
print("🔄 重置对话历史")
print("=" * 70)
agent.reset()
# 继续对话
print("\n【重置后的对话】")
agent.process("你还记得我们刚才聊了什么吗？", verbose=True)
print("=" * 70)
print("✅ 演示3完成！")
print("=" * 70)
# ============================================================================
# 主入口
# ============================================================================
if __name__ == "__main__":
# 从环境变量获取API密钥
api_key = os.getenv("DEEPSEEK_API_KEY", "your-api-key")
if api_key == "your-api-key":
print("⚠️ 请设置环境变量 DEEPSEEK_API_KEY")
print(" 例如: export DEEPSEEK_API_KEY='your-actual-key'")
print(" 或者: set DEEPSEEK_API_KEY=your-actual-key (Windows)")
exit(1)
print("\n" + "=" * 70)
print("🎯 Agent Transformer 完整演示")
print("=" * 70)
print("\n本演示包含三个部分：")
print(" 1. 基础Agent演示（SimpleAgent）")
print(" 2. RAG增强Agent演示（RAGAgent）")
print(" 3. 完整工作流演示（CompleteAgentWorkflow）")
print("\n" + "=" * 70)
print()
try:
# 运行所有演示
demo_simple_agent(api_key)
demo_rag_agent(api_key)
demo_complete_workflow(api_key)
print("\n" + "=" * 70)
print("🎉 所有演示完成！")
print("=" * 70)
print("\n💡 提示：")
print(" - 查看 agent_transformer_guide.md 了解详细原理")
print(" - 修改代码中的参数进行自定义实验")
print(" - 添加自己的知识库文档进行测试")
print()
except KeyboardInterrupt:
print("\n\n👋 演示已中断")
except Exception as e:
print(f"\n❌ 发生错误: {e}")
import traceback
traceback.print_exc()