《RAG与Agent：AI应用的两条腿，一条管记忆，一条管行动》

原创

资源shanxueit.com

发布于 2026-08-19 12:02:36

1210

你以为RAG和Agent是新技术？不，RAG是"外挂知识库"，Agent是"自动执行脚本"。合在一起，就是能查资料、能动手的AI实习生。

一、RAG：让AI"开卷考试"

RAG（检索增强生成）的核心思想很简单：模型不懂的问题，先去文档库查，查到答案再回答。它不是让模型"知道更多"，而是让模型"能查资料"。

一个极简RAG实现（不用框架，纯Python）：

# 极简RAG：文档检索 + LLM生成（仅15行核心）
import numpy as np
from openai import OpenAI

class SimpleRAG:
    def __init__(self, documents):
        # 文档库（实际生产用向量数据库）
        self.docs = documents
        self.client = OpenAI()
    
    def retrieve(self, query, top_k=2):
        # 关键词匹配检索（实际用Embedding相似度）
        scores = []
        for doc in self.docs:
            # 简单的词重叠计算（实际用余弦相似度）
            overlap = len(set(query.split()) & set(doc.split()))
            scores.append(overlap)
        
        # 返回Top-K文档
        indices = np.argsort(scores)[-top_k:][::-1]
        return [self.docs[i] for i in indices]
    
    def answer(self, query):
        # 检索相关文档
        context = self.retrieve(query)
        
        # 构建Prompt（上下文注入）
        prompt = f"""基于以下参考文档回答问题：
        
参考文档：
{chr(10).join(context)}

问题：{query}
答案："""
        
        # 生成答案
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content

# 使用
docs = [
    "DeepSeek是深度求索公司开发的AI模型",
    "RAG技术结合了检索和生成能力",
    "Agent系统能够自主调用工具完成任务"
]
rag = SimpleRAG(docs)
print(rag.answer("DeepSeek是什么公司开发的？"))
# 输出: DeepSeek是深度求索公司开发的AI模型

工程要点拆解：

检索不是"问模型"：检索系统（向量数据库、ES）负责找资料，LLM负责"阅读理解"
上下文注入：把检索到的文档拼进Prompt，模型基于这些内容回答
幻觉降低80%：有参考文档，模型不会凭空编造

RAG的生产级流程：

用户提问 → 向量检索（Top-K相关文档） → 重排序（精排Top-N） → 
构建Prompt（文档+问题） → LLM生成 → 答案+引用来源

二、Agent：让AI"动手干活"

Agent不是"聊天机器人"，是能调用工具、执行动作的自主系统。它的核心循环是：思考 → 行动 → 观察 → 再思考。

一个极简Agent实现（用Function Calling）：

# 极简Agent：LLM + 工具调用（仅20行核心）
from openai import OpenAI

class SimpleAgent:
    def __init__(self):
        self.client = OpenAI()
        # 定义工具（模拟）
        self.tools = {
            "get_weather": lambda city: f"{city}今天晴，25°C",
            "calculate": lambda expr: eval(expr)  # 危险！生产环境用安全计算
        }
    
    def run(self, user_input):
        # 1. LLM决定调用哪个工具
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": user_input}],
            functions=[{
                "name": "get_weather",
                "description": "查询城市天气",
                "parameters": {"type": "object", "properties": {"city": {"type": "string"}}}
            }]
        )
        
        # 2. 解析工具调用
        call = response.choices[0].message.function_call
        if call:
            func_name = call.name
            args = eval(call.arguments)  # 解析参数
            result = self.tools[func_name](**args)
            
            # 3. 将工具结果返回给LLM，生成最终答案
            final = self.client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "user", "content": user_input},
                    {"role": "assistant", "content": f"调用{func_name}结果: {result}"}
                ]
            )
            return final.choices[0].message.content
        
        return response.choices[0].message.content

# 使用
agent = SimpleAgent()
print(agent.run("北京今天天气怎么样？"))
# 输出: 北京今天晴，25°C（通过工具查询）

Agent的三种模式：

模式	特点	适用场景	代码复杂度
ReAct（思考-行动-观察）	循环推理，每次一个工具	复杂多步任务	中等
Plan-and-Solve	先规划步骤，再执行	任务明确、步骤固定	低
Reflection	执行后自我反思修正	需要高质量输出	高

ReAct模式的核心循环（关键代码）：

def react_loop(agent, user_input, max_steps=5):
    """
    ReAct循环：Thought → Action → Observation → (循环)
    """
    history = [{"role": "user", "content": user_input}]
    
    for step in range(max_steps):
        # 1. Thought：LLM推理
        response = agent.chat(history)
        thought = response.content
        
        # 2. Action：提取工具调用
        action = extract_action(thought)  # 正则匹配"Action: get_weather(city='北京')"
        
        if action is None:
            # 没有工具调用，直接返回答案
            return thought
        
        # 3. Observation：执行工具
        tool_name, params = action
        result = agent.execute_tool(tool_name, params)
        
        # 4. 把观察结果加入历史
        history.append({"role": "assistant", "content": thought})
        history.append({"role": "user", "content": f"Observation: {result}"})
    
    return "超过最大步数，任务未完成"

三、RAG + Agent：黄金组合

RAG负责"知识"，Agent负责"行动"。合在一起，就是一个能查资料、能执行操作的完整AI系统。

协作模式示例：

用户: "帮我查一下昨天北京的天气，然后对比一下今天，算出温差"

Agent思考:
  - 需要查天气数据（调用RAG检索历史天气）
  - 需要查询今天天气（调用工具get_weather）
  - 需要做减法计算（调用计算器工具）

执行流程:
  1. Agent调用RAG → 检索到"北京2026-08-18: 晴，30°C"
  2. Agent调用get_weather → "北京今天晴，25°C"
  3. Agent调用calculate → 30 - 25 = 5
  4. Agent生成答案 → "昨天30°C，今天25°C，温差5°C"

RAG-Agent协作实现（核心骨架）：

class RAGAgent:
    def __init__(self):
        self.rag = RAGSystem(documents)
        self.tools = {
            "query_rag": self.rag.search,        # RAG检索
            "calculate": safe_calc,
            "get_current_time": lambda: datetime.now()
        }
    
    def run(self, user_input):
        # Agent决定何时调用RAG
        # 如果是知识型问题 → 调用query_rag
        # 如果是计算/实时数据 → 调用其他工具
        response = self.llm_with_tools(user_input)
        return self.execute(response)
    
    def execute(self, llm_response):
        # 解析LLM输出的工具调用序列
        actions = parse_actions(llm_response)
        results = []
        for action in actions:
            result = self.tools[action.name](**action.params)
            results.append(result)
        
        # 用所有结果生成最终答案
        return self.synthesize(user_input, results)

四、RAG的"坑"：不是查了资料就万事大吉

RAG最常见的三个问题：

1. 检索不到正确答案（召回率低）

# 问题：用户问"深度求索的创始人是谁？"
# 文档里有"梁文锋创立了深度求索"
# 但分片时"深度求索"和"梁文锋"被切到不同段落

# 解决方案：增大chunk_size + 重叠分片
def smart_chunking(text, chunk_size=512, overlap=50):
    chunks = []
    for i in range(0, len(text), chunk_size - overlap):
        chunks.append(text[i:i + chunk_size])
    return chunks

2. 模型忽略检索结果（指令遵循差）

# Prompt里明确强制要求
prompt = f"""
你必须基于以下文档回答，如果文档中没有相关信息，请说"不知道"。
严禁编造文档中没有的信息。

文档：{context}
问题：{query}
答案："""

3. 检索到错误文档（噪声污染）

# 加入重排序（Rerank）阶段
def rerank(query, docs, top_k=5):
    # 用交叉编码器精细计算相似度
    scores = cross_encoder(query, docs)
    return sorted(docs, key=lambda x: scores[x], reverse=True)[:top_k]

五、Agent的"坑"：不是有了工具就万能

Agent系统最危险的不是性能差，是失控：

1. 无限循环

# 解决方案：最大步数限制 + 早期终止
def safe_agent_loop(max_steps=10):
    for i in range(max_steps):
        if i == max_steps - 1:
            return "任务执行时间过长，已终止"
        # ... 正常执行

2. 工具调用失败

# 每次调用都要try-catch
def safe_tool_call(func, *args, **kwargs):
    try:
        return func(*args, **kwargs)
    except Exception as e:
        return f"工具执行失败: {e}"

3. 权限失控（删除文件、发邮件等危险操作）

# 危险工具必须人工确认
dangerous_tools = ["delete_file", "send_email", "execute_command"]

def execute_safe(tool_name, params):
    if tool_name in dangerous_tools:
        return "该操作需要人工确认，已暂停"
    return execute(tool_name, params)

六、RAG vs Agent：一张表说清楚

维度	RAG	Agent
核心能力	检索知识、生成答案	调用工具、执行动作
输入	用户问题	用户指令
输出	文本答案	文本答案 + 工具调用记录
依赖	文档库、向量检索	工具集、LLM推理
适用场景	FAQ、文档问答、客服	自动化任务、数据分析、操作执行
失败代价	答错	执行错误操作（更危险）
实现难度	中等	较高

七、RAG + Agent的未来：自主工作流

当前RAG和Agent正在融合成自主工作流系统：

# 未来形态：多步自主工作流
workflow = Workflow([
    Step("理解意图", model="gpt-4"),
    Step("检索知识", tool="rag_search"),
    Step("规划步骤", model="gpt-4"),
    Step("执行工具", tool="execute_plan"),
    Step("验证结果", model="gpt-4"),
    Step("生成报告", model="gpt-4")
])

result = workflow.run("帮我分析上个月销售数据，找出下降原因并生成报告")

核心趋势：

多Agent协作：规划Agent、执行Agent、验证Agent分工合作
自我反思：执行后检查结果，如果不满意重新规划
持续学习：从错误中改进检索策略和工具调用逻辑

八、最后一句忠告

RAG和Agent不是银弹。RAG解决"模型不懂"的问题，Agent解决"模型不会"的问题。如果你的场景既不需要外部知识，也不需要调用工具，那直接LLM就够了。别为了用而用，先问自己三个问题：

模型需要查资料吗？→ 用RAG
模型需要动手操作吗？→ 用Agent
两者都需要？→ RAG + Agent组合

附加：一句话看透本质：

# RAG的本质
RAG = 检索系统(查询) + LLM(检索结果 + 问题)

# Agent的本质
Agent = LLM(思考) → 执行(工具) → LLM(反思) → (循环)

# RAG + Agent的本质
RAG_Agent = RAG(知识) + Agent(行动) + 自我纠错

把这段代码刻在工位上，每次设计AI系统时默念一遍。

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

agent