一般不会说的秘密：RAG与AGent还有这样的关系？

云青黛

359人浏览 · 2026-03-08 20:02:12

云青黛 · 2026-03-08 20:02:12 发布

前言：

为了顺应时代发展，拥抱新时代，我们当以昂扬之姿，踏浪而行。时代的浪潮奔涌向前，每一次变革都孕育着无限可能，每一次前行都承载着使命担当。我们不必畏惧未知的挑战，也不必沉溺过往的成就，而是以初心为舵，以实干为桨，在时代的坐标系中找准方向，在奋斗的征程中积蓄力量。

新时代的舞台无比广阔，每一份坚守都有意义，每一次突破都有回响。我们以青春之我、奋斗之我，勇立潮头、敢为人先，用汗水浇灌梦想，用脚步丈量远方，让个人的成长与时代的脉搏同频共振，让平凡的日子在拼搏中绽放出不凡的光芒。

顺应时代，不是被动跟随，而是主动引领；拥抱未来，不是空喊口号，而是脚踏实地。让我们以无畏的勇气、坚定的信念，在新时代的画卷上书写属于我们的精彩篇章，不负韶华，不负时代，不负每一个滚烫的梦想！（总结来说就是找一份好的工作）

文章仅用来记录我的agent学习路径

初始agent-openai

OpenAI 是当前大模型领域的重要标杆，它的 API 设计、工具调用范式（如 Function Calling）深刻影响了整个行业。
理解 OpenAI 的模型能力和 API 使用方式，是学习大模型应用开发（包括 Agent）的重要基础，但这并不意味着 OpenAI 库是 Agent 的底层逻辑。
安装openai：
```
pip install openai 
```
学习的话模型可以使用大模型服务平台百炼控制台

也可以部署本地大模型：（后期补充）

通过配置环境变量隐藏key{
windows：用户变量名称：名字，值为密钥
linux：。bashrc文件：添加 export DASHSCOPE_API_Key = xxxx
}

使用例子（关于openai的一些操作，将在这个例子中进行讲解）

from openai import OpenAI
import os
#创建实例
client = OpenAI(
    # 如果没有配置环境变量，请用阿里云百炼API Key替换：api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
#这是调用模型，qwen3-max是聊天大模型
message是消息列表，相当于你和ai所有的聊天记录
role代表角色
    system：角色设定，类似于cosplay，指定ai的行为
    assistant：ai的回复
    user：用户的消息
content代表内容
stream：流式输出（也就是不一次性全部输出）
注意：ai和user尽量是交叉出现，连续出现某一个也是可以的就是表现得有些混乱
response=client.chat.completions.create(
    model="qwen3-max",
    messages=[
        {"role":"system","content":"你是一名大学老师，并且很有耐心，话也不多"},
        {"role":"assistant","content":"好的，我是一名温柔耐心的大学老师，你有什么问题吗？"},
        {"role":"user","content":"我想问一下openai库是不是爬虫的应用？"}
    ],
    stream=True
)
print(response)
print('!!!!!!!!!!!!!!!!!!!!!!!!!!')
#这是流式输出的打印方法
for i in response:
    print(i.choices[0].delta.content)
#正常打印方法
#调取结果
response.choices[0].message.content#如果忘记了可以直接输出response看看

openai作业：

from openai import OpenAI
import os


client = OpenAI(
    # 如果没有配置环境变量，请用阿里云百炼API Key替换：api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)
seg=["期数","中奖号码",'几等奖',"几注"]

message=[
    {"role":"system","content":"你是一个彩票专家，现在需要你帮我从文本中提取{seg},如果文本中不存在则输出不存在"},
    {"role":"user","content":"2025年88期，开号篮球09，红球01 02 03 04 05 06 一等奖中奖为2注"},
    {"role":"assistant","content":'{"期数":"88","中奖号码":[1,2,3,4,5,6,9],"一等奖":"2注"}'},
    {"role":"user","content":"第12期2025年，开号篮球09，红球01 77 03 04 15 06 二等奖中奖为2注"},
    {"role":"assistant","content":'{"期数":"12","中奖号码":[1,77,3,4,5,15,9],"二等奖":"2注"}'},
    {"role":"user","content":"2025102，开号篮球09，红球01 77 03 04 15 06 二等奖中奖为2注"},
    {"role":"assistant","content":'{"期数":"102","中奖号码":[1,77,3,4,5,15,9],"二等奖":"2注"}'},
]
que=[
    "2025 年第 100 期，开奖红球 22 21 06 01 11 蓝球 07，一等奖中奖为 2 注。",
"2025101 期，有 3 注 1 等奖，10 注 2 等奖，开奖红球 3、5、7、11、12、16。"
]
for i in que:
    mas=message+[{"role":"user","content":f"仿照上述例子，提取下面文本的内容:{i}"}]
    print(i)
    response=client.chat.completions.create(
        model="qwen3-max",
        messages=mas
    )
    print(response.choices[0].message.content)

层层递进 langchain

了解

LangChain 是由 LangChain AI 公司开发的一个独立的开源框架，其核心目标是帮助开发者更高效地构建基于大语言模型（LLM）的应用，好多大模型都有这个的接口

基础

安装命令及其解释（这是前期安装的，随着学习的深入，还需要安装一些些别的库）

pip install langchain langchain-community langchain-allama dashscope chromadb
langchain 核心
langchain-community 社区
dashscope 千问sdk
chromadb轻量向量库

概念解释和常用内容：

#大预言模型：langchain_community。llms.XXXX

#聊天模型：langchain_chat_models.xxx

#wen

#聊天模型中角色:使用时从langchain_core.meessage中导入

设定：SystemMessage

用户：HumanMessage

回答：AIMessage

使用实例：

from langchain_community.chat_models.tongyi import ChatTongyi
from langchain_core.messages import HumanMessage,AIMessage,SystemMessage
#调用模型
model=ChatTongyi(model="qwen3-max")#这里如果配置了本地环境就不需要再写密钥了
#消息列表
#第一种写法 静态直接创建meaage类
# message=[
#     SystemMessage(content="你是一个构石家"),
#     HumanMessage(content="帮我解读下最新的构石"),
#     AIMessage(content="男生和女生相比，雄性激素偏多"),
#     HumanMessage(content="仿照你刚刚的回答，给我新的回答"),
# ]
#第二种写法（更像py） 动态 由langchain内部转换为message类
message=[
    ("system","你是一个构石家"),
    ("human","帮我解读下最新的构石"),
    ("ai","男生和女生相比，雄性激素偏多"),
    ("human","仿照你刚刚的回答，给我新的回答"),
]

#全输出，在常见的大模型中输出方式基本就是这两种，流式输出和全输出
res=model.invoke(input=message)
print(res.content)
#流式输出
res=model.stream(input=message)
for i in res:
    print(i.content,end="",flush=True)
print()

提示词工程

概念了解

思想：

Zero-shot 测试集和训练集完全不同
few-shot 少样本学习，给少量样本例如：训练集（小，大），（左，右）测试：（前，后）

实例

#提示词模板位于from langchain_core.prompts 中，常用有FewshotPromptTemplate，PromptTemplate和ChatPromptTemplate
from langchain_core.prompts import PromptTemplate
from langchain_core.prompts import MessagesPlaceholder#历史对话占位符
from langchain_community.llms.tongyi import Tongyi
#通用提示模板，注意这里是用的是from_template
property_template=PromptTemplate.from_template(
    '我姓{last},专业{name},帮我起个网名'
)
prompt_text=property_template.format(last='宗',name='人工智能')
#第一种
model=Tongyi(model='qwen-max')
# res=model.invoke(input=prompt_text)
# print(res)
#第二种，在大模型开发中使用较多，注意需要链条中的所有类都需要继承于BasePromptTemplate
chain=property_template|model
res=chain.invoke(input={'last':'宗','name':'人工智能'})
print(res)
#聊天提示模板，这使用的是from_messages里面是一个列表，可以使用messafwplaceholder作为占用符，里面的是命名，就像一句话中的变量一样
#构造提示词
chatpro=ChatPromptTemplate.from_messages([
    ('system','你是一名伟大的科学家,话少还非常有idea'),
    ('ai','好的,我是一个伟大的科学家'),
    MessagesPlaceholder("hostor"),
    ('human','针对我们的对话,提出一个非常前沿性的想法')
])
hostor=[
    ('human','找出一个很新的燃料'),
    ('ai','大便,大学生每年产生不少大便')
]
a=chatpro.invoke({'hostor':hostor}).to_string()
print(a)

#模型调用
model=ChatTongyi(model="qwen3-max")
res=model.invoke(input=a)
print(res.content)

#fewshotPromptTemplate
#提示词工程
template=PromptTemplate.from_template(
    "单词:{word},反义词:{un}"
)
examples=[
    {'word':'大','un':'小'},
]
prefix='仿照实例给我单词的反义词'
suffix='根据上述例子,请告诉我单词:{input}'
few=FewShotPromptTemplate(
    example_prompt=template,#提示词模板
    examples=examples,#提示词数据
    prefix=prefix,#提示词前的一句话
    suffix=suffix,#提示此后的一句话,
    input_variables=['input'],#前缀或者后缀的变量
)
res=few.invoke({'input':'左'}).to_string()
#
model=Tongyi(model='qwen-max')
res=model.invoke(input=res)
print(res)

注意rmodel.invoke返回的类型是AiMessage，我们可以通过两个方法重新将其转为可以加入到链的类

序列化

#从名称可以看出str是字符串，json是json格式，因此json要求传入的数据必须是json的Aimessage
from langchain_core.output_parsers import StrOutputParser,JsonOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_community.chat_models.tongyi import ChatTongyi
#自定义
from langchain_core.runnables import RunnableLambda
my_func=RunnableLambda(lambda ai_msg:(
    print(ai_msg.content),
    {"name":ai_msg.content},
)[1])
model=ChatTongyi(model="qwen3-max")
parser=StrOutputParser()
json=JsonOutputParser()
prompt=PromptTemplate.from_template(
    "别人骂你有病怎么办?"
)
se_prompt=PromptTemplate.from_template(
    "{name},你认可这种方式吗?"
)
#报错的形式 chain=prompt|model|model
chain=prompt|model|json|se_prompt|model|parser
res=chain.invoke({})
print(res)

文本，csv，pdf等文件的读取

这三个的类都在from langchain_community.document_loaders中

from langchain_community.document_loaders import PyPDFLoader

#安装pypdf pdf
from langchain_community.document_loaders import TextLoader,CSVLoader，使用基本一样

from langchain_community.document_loaders import PyPDFLoader
ls=PyPDFLoader(
    file_path="./？？？？.pdf",#路径
    mode="page",#默认,每页单独加载,single（输出方式：print(ls.load())）一页
    password=None,#密码
)
for i in ls.load():
    print(i)

向量转化（这是构建数据库的基础，也是rag的基础操作）

#embed_query 单次转换 embed_documents 批次转换
from langchain_community.embeddings import DashScopeEmbeddings

#模型，默认v1 如果需要更改填model=”XXXX“
model=DashScopeEmbeddings()
#单次转换
print(model.embed_query('小傻瓜'))
print(model.embed_documents(['你','傻']))

RAG：

通过数据库增强问题，然后获得更加准确的回答，具体流程：程序会先访问本地数据库得到和问题相关的答案，然后将在本地得到的答案和问题重新组成模板去询问大模型

向量存储

分为临时存储（程序关闭消失）和长期存储（程序关闭，但是历史记录保存下来了）

# from langchain_core.vectorstores import InMemoryVectorStore
# from langchain_community.embeddings import DashScopeEmbeddings
# from langchain_community.document_loaders import TextLoader
# from langchain_text_splitters import RecursiveCharacterTextSplitter
#数据库存储
vector_short= Chroma(
    collection_name='text',#起名
    embedding_function=DashScopeEmbeddings(),#模型
    persist_directory="./a_db"#存储路径
    )
#临时存储

# vector_short= InMemoryVectorStore(embedding=DashScopeEmbeddings())

# ls=TextLoader(
#     file_path="./xuexi.txt",
# )

# splits=RecursiveCharacterTextSplitter(
#     chunk_size=500,#最大字符
#     chunk_overlap=50,#允许重叠数
#     separators=[''],#分隔符
#     length_function=len,#字符统计依据函数
# )

# ll=splits.split_documents(ls.load())
# #添加
# vector_short.add_documents(
#     documents=ll,#需要添加的文档
#     ids=["id"+str(i)for i in range(1,len(ll)+1)]#编号
# )
# #删除
# vector_short.delete(["id1","id2"]);

# #检索
# result=vector_short.similarity_search(
#     query="你今天吃饭了吗?",
#     k=3,
# )
# for i in result:
#     print(i)
#     print('!!!!!')

因为数据分为临时存储和长期存储，倒是会出现两种基于的历史模型：（长期和短期）

要使用的RunnableWithMessageHistory 增强链的函数

长期存储模型建议去看源码

短期存储模型的代码

from langchain_core.runnables.history import RunnableWithMessageHistory#增强原先链(添加历史记录)
from langchain_core.chat_history import InMemoryChatMessageHistory#提供一个内存中的字典来存储每个会话的消息列表
from langchain_core.prompts import PromptTemplate,ChatPromptTemplate,MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_community.chat_models.tongyi import ChatTongyi
chat_history_store={}
def get_history(session_id):
    if not session_id in chat_history_store:
        chat_history_store[session_id]=InMemoryChatMessageHistory()
    return chat_history_store[session_id]
model=ChatTongyi(model='qwen3-max')

# 通用提示词
# pro=PromptTemplate.from_template(
#     "根据历史消息{history},回答:{user}"
# )
#聊条提示词
pro=ChatPromptTemplate.from_messages(
    [
        ("system","我是一个帅哥"),
        MessagesPlaceholder("history"),
        ('human','请回答下面问题:{user}')
    ])
chain=pro|(lambda x:(print(x),x)[1])|model|StrOutputParser()
rm=RunnableWithMessageHistory(
    chain,#附加的历史记录,一般是chain
    get_history, #获取指定历史id,放函数
    input_messages_key="user",#问题占位符
    history_messages_key="history"
)
seccion_config={"configurable":{"session_id":"user_oo1"}}
for i in range(5):
    rm.invoke({"user":"我是什么"},seccion_config)
print(rm.invoke({"user":"小明共几只喵?"},seccion_config))

参考视频：RAG开发-29、RunnablePassthrough的使用_哔哩哔哩_bilibili