LangChain 核心技术拆解：从语言模型(Model)到记忆（Memory）全解读

原创于 2025-08-08 09:44:57 发布 · 776 阅读

26 ·

CC 4.0 BY-SA版权

文章标签：

#langchain #语言模型 #人工智能 #chatgpt #大模型 #算法 #prompt

一、Langchain是什么

Langchain 是一个用于开发由大型语言模型提供支持的Python框架。它提供了一系列工具和组件，帮助我们将的语言模型集成到自己的应用程序中。

有了它之后，我们可以更轻松地实现对话系统、文本生成、文本分类、问答系统等功能。
请添加图片描述

二、Langchain官网文档

官网：https://python.langchain.com/docs/introduction/

三、Langchain的核心组件

语言模型(Model) ：如 OpenAI 的 GPT-3
提示管理(Prompt)：Prompt 管理
链(Chain) ：允许你将多个组件（如语言模型、提示模板、记忆等）串联起来，形成一个工作流。
记忆(Memory) :记忆模块用于保存对话历史或上下文信息，以便在后续对话中使用。
代理(Agent) :代理是一种智能组件，可以根据用户的输入自动选择和执行不同的操作。
工具(Tool) :工具是一些内置的功能模块，如文本处理工具、数据查询工具等。

接下来我们来学习其中的一些核心组件

1、语言模型(Model)

把不同的模型，统一封装成一个接口，方便更换模型而不用重构代码。

以下是使用语言模型从输入到输出的基本流畅。

在这里插入图片描述

以下是对每一块的总结:

Format(格式化):将原始数据格式化成模型可以处理的形式,插入到一个模板问题中,然后送入模型进行处理。
Predict(预测):接受被送进来的问题，然后基于这个问题的进行预测或生成回答。
Parse(生成): 预测的输出被进一步格式化成一个结构化的JSON对象。

单轮对话

from langchain_openai import ChatOpenAI

from dotenv import load_dotenv
import os

os.environ['http_proxy'] = 'http://127.0.0.1:7890'
os.environ['https_proxy'] = 'http://127.0.0.1:7890'
load_dotenv()


llm = ChatOpenAI()
print(llm.invoke("你是谁").content)

gpt-3.5-turbo 我是一个人工智能助手，可以回答您的问题并提供帮助。您有什么需要我帮忙的吗？

多轮对话

from dotenv import load_dotenv
from langchain.schema import (
    AIMessage,  # 代表AI生成的消息。
    HumanMessage,  # 代表用户输入的消息。
    SystemMessage  # 代表系统生成的消息或指令。通常用于指导AI的行为，比如设定AI的初始状态、行为模式或对话的总体目标。
)
from langchain_openai import ChatOpenAI
import os

os.environ['http_proxy'] = 'http://127.0.0.1:7890'
os.environ['https_proxy'] = 'http://127.0.0.1:7890'
load_dotenv()

llm = ChatOpenAI()

messages = [
    SystemMessage(content="你是langchain的课程助理。"),
    HumanMessage(content="我是学员，我叫 Tom"),
    AIMessage(content='欢迎'),  # 提前模拟场景，为后续交互做准备.
    HumanMessage('我是谁,你是谁？')
]
print(llm.invoke(messages).content)

您是一位学员，名叫 Cat。您参加了AGI Class的课程。有什么我可以帮助您的吗？

通过这种方式，我们可以：

测试AI模型在特定上下文下的表现。
确保AI模型能够正确理解并响应用户的输入。
调整和优化对话流程，以便在实际应用中提供更好的用户体验。

2、Prompt模版封装(Prompt)

Prompt作为输入输入的控制是相当重要的。Langchain 也是提供了多种管理方法

PromptTemplate

基本的提示模板，可以定义输入变量和模板文本。适用于大多数自定义的提示需求。

from langchain.prompts import PromptTemplate

template = PromptTemplate.from_template("给我讲个关于{name}的笑话")
print(template)
print(template.format(name='小明'))

给我讲个关于小明的笑话

ChatPromptTemplate

针对聊天场景的提示模板，支持定义多个角色的消息（用户、AI 和系统）。

from dotenv import load_dotenv
from langchain.prompts.chat import SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

load_dotenv()
llm = ChatOpenAI()

template = ChatPromptTemplate.from_messages(
    [
        SystemMessagePromptTemplate.from_template("你是{product}的客服助手。你的名字叫{name}"),
        HumanMessagePromptTemplate.from_template("hello 你好吗？"),
        AIMessagePromptTemplate.from_template("我很好 谢谢!"),
        HumanMessagePromptTemplate.from_template("{query}"),
    ]
)

prompt = template.format_messages(
    product="AGI课堂",
    name="Bob",
    query="你是谁"
)

print(llm.invoke(prompt).content)  # 将模板给到模型进行提问

‘我是AGI课堂的客服助手，可以帮助您解答问题和提供信息。我的名字是Bob。有什么可以帮到您的吗？’

FewShotPromptTemplate

在之前文章Prompt优化中，我们提到Prompt中给几个例子可以让大模型更好地生成正确的结果。这个模板就是给例子的。

from dotenv import load_dotenv
from langchain.prompts import PromptTemplate
from langchain.prompts.few_shot import FewShotPromptTemplate
from langchain_openai import ChatOpenAI

load_dotenv()
llm = ChatOpenAI()

# 例子
examples = [
    {"input": "北京天气怎么样", "output": "北京市"},
    {"input": "南京下雨吗", "output": "南京市"},
    {"input": "武汉热吗", "output": "武汉市"}
]

# 例子拼装的格式
example_prompt = PromptTemplate(
    input_variables=["input", "output"],
    template="Input: {input}\nOutput: {output}"
)

# Prompt模板
prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_prompt,
    suffix="Input: {input}\nOutput:",  # 要放在示例后面的提示模板字符串。
    input_variables=["input"]  # 传入的变量
)

prompt = prompt.format(input="长沙多少度")

print("===Prompt===")
print(prompt)

print("===Response===")
response = llm.invoke(prompt)
print(response.content)
===Prompt===
Input: 北京天气怎么样
Output: 北京市

Input: 南京下雨吗
Output: 南京市

Input: 武汉热吗
Output: 武汉市

Input: 长沙多少度
Output:
===Response===
长沙市

从文档中加载Prompt模版

simple_prompt.json

{
    "_type": "prompt",
    "input_variables": [
        "name",
        "love"
    ],
    "template": "我的名字叫{name}，我喜欢{love}"
}
from langchain.prompts import load_prompt

prompt = load_prompt("simple_prompt.json", encoding="utf-8")
print(prompt.format(name="小明", love="run"))

当我们的prompt模板数据较大时，我们可以使用外部导入的方式进行管理和维护.

3、格式化输出

OutputParser

CSV parser 当您想要返回以逗号分隔的项目列表时，可以使用此输出解析器。

from langchain.output_parsers import CommaSeparatedListOutputParser

output_parser = CommaSeparatedListOutputParser()
# 返回一些指令或模板，这些指令告诉系统如何解析或格式化输出数据
print(output_parser.get_format_instructions())

# 输入的字符串按照特定的规则进行解析和转换
reply = 'foo,bar,baz'
print(output_parser.parse(reply))
from dotenv import load_dotenv
from langchain.prompts.chat import HumanMessagePromptTemplate
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

llm = ChatOpenAI()
load_dotenv()

chat_prompt = ChatPromptTemplate.from_messages(
    [
        HumanMessagePromptTemplate.from_template("{request}\n{format_instructions}"),
    ]
)

model_request = chat_prompt.format_prompt(
    request="给我5个心情",
    format_instructions=output_parser.get_format_instructions()
)

result = llm.invoke(model_request)
print(result.content)
date = output_parser.parse(result.content)
print(date, type(date))

[‘kind’, ‘ambitious’, ‘outgoing’, ‘loyal’, ‘compassionate’]

Datetime parser

用于将大模型的输出解析为日期时间格式。

from langchain.output_parsers import DatetimeOutputParser

output_parser = DatetimeOutputParser()
print(output_parser.get_format_instructions())

print(output_parser.parse('1547-06-23T21:24:07.078384Z'))
from langchain_openai import ChatOpenAI
from langchain.prompts.chat import HumanMessagePromptTemplate
from langchain_core.prompts import ChatPromptTemplate
from dotenv import load_dotenv
from langchain.output_parsers import DatetimeOutputParser
output_parser = DatetimeOutputParser()

load_dotenv()

llm = ChatOpenAI(model_name='gpt-3.5-turbo')

chat_prompt = ChatPromptTemplate.from_messages(
    [
        HumanMessagePromptTemplate.from_template(
            "{request}\n{format_instructions}"),
    ]
)


model_request = chat_prompt.format_prompt(
    request="中华人民共和国是什么时候成立的",
    format_instructions=output_parser.get_format_instructions()
)

# print(model_request)
result = llm.invoke(model_request)
print(output_parser.parse(result.content))

1949-10-01T00:00:00.000000Z

1949-10-01 00:00:00 <class ‘datetime.datetime’>

Pydantic OutputParser

自定义要输出的结构

from dotenv import load_dotenv
from langchain.output_parsers import PydanticOutputParser
from langchain_openai import ChatOpenAI

from pydantic import BaseModel, Field

load_dotenv()
llm = ChatOpenAI(model_name="gpt-4")


class Writer(BaseModel):
    """作家类"""
    name: str = Field(description="name of a Writer")  # 作者名
    nationality: str = Field(description="nationality of a Writer")  # 国籍
    magnum_opus: list = Field(description="python List of discoveries")  # 代表作


outputparser = PydanticOutputParser(pydantic_object=Writer)
print(outputparser.get_format_instructions())
The output should be formatted as a JSON instance that conforms to the JSON schema below.

As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}
the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.

Here is the output schema:
```
{"description": "作家类", "properties": {"name": {"description": "name of a Writer", "title": "Name", "type": "string"}, "nationality": {"description": "nationality of a Writer", "title": "Nationality", "type": "string"}, "magnum_opus": {"description": "python List of discoveries", "items": {}, "title": "Magnum Opus", "type": "array"}}, "required": ["name", "nationality", "magnum_opus"]}
```
from dotenv import load_dotenv
from langchain.output_parsers import PydanticOutputParser
from langchain_core.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field

load_dotenv()
llm = ChatOpenAI()  # model_name="gpt-4" 使用gpt-4模型效果更好


class Writer(BaseModel):
    name: str = Field(description="name of a Writer")  # 作者名
    nationality: str = Field(description="nationality of a Writer")  # 国籍
    magnum_opus: list = Field(description="python List of discoveries")  # 代表作


outputparser = PydanticOutputParser(pydantic_object=Writer)

chat_prompt = ChatPromptTemplate.from_messages(
    [HumanMessagePromptTemplate.from_template("{request}\n{format_instructions}")]
)

model_request = chat_prompt.format_prompt(
    request="莫言是谁？",
    format_instructions=outputparser.get_format_instructions()
)

result = llm.invoke(model_request)
print(result.content)
parse_data = outputparser.parse(result.content)
print(parse_data)
print(parse_data.name)  # 获取其中的数据
{
  "name": "Mo Yan",
  "nationality": "Chinese",
  "magnum_opus": ["Red Sorghum", "Big Breasts and Wide Hips", "Frog"]
}
name='Mo Yan' nationality='Chinese' magnum_opus=['Red Sorghum', 'Big Breasts and Wide Hips', 'Frog']
Mo Yan

4、数据加载

在这里插入图片描述

数据源（Source）:数据源的种类型多种多样，如：视频、图片、文本、代码、文档等。
加载（Load）:将这些数据加载到到电脑中。
转换（Transform）:对数据进行转换可能包括数据清洗、预处理、格式转换等操作。
嵌入（Embed）:转换后的数据进一步处理以生成嵌入向量。如 [0.5, 0.2, …, 0.1, 0.9] 等。
存储（Store）：生成的嵌入向量存储在数据库或存储系统中。
检索（Retrieve）：从存储系统中检索数据。

文档加载

加载csv文件

from langchain_community.document_loaders import CSVLoader

loader = CSVLoader("data.csv", encoding="utf-8")
pages = loader.load_and_split()

print(type(pages), len(pages))  # 查看类型和数量
print(type(pages[0]))  # <class 'langchain_core.documents.base.Document'>
print(pages[0].page_content)  # 查看第一个的内容

加载pdf文件

from langchain_community.document_loaders import PyPDFLoader

# pip install pypdf 需要先安装 pypdf2
loader = PyPDFLoader("中国人工智能系列白皮书.pdf")
pages = loader.load_and_split()
print(pages[13].page_content)

文档分割

按字符递归拆分

它在遇到特定字符（如换行符、空格等）时进行分割。

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("中国人工智能系列白皮书.pdf")
pages = loader.load_and_split()

text_splitter = RecursiveCharacterTextSplitter(
    # 每个块中的最大字符数。
    chunk_size=200,
    # 邻块之间重叠的字符数。重叠的块可以确保如果重要信息横跨两个块，它不会被错过。
    chunk_overlap=50,
)

paragraphs = text_splitter.create_documents([pages[13].page_content])
for para in paragraphs:
    print(para.page_content)
    print('-------')

按照token进行拆分

它基于 tiktoken 库进行分词和编码。tiktoken 通常用于处理与 OpenAI 相关的文本内容，因为它使用 OpenAI 的编码方式。

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader

loader = PyPDFLoader("中国人工智能系列白皮书.pdf")
pages = loader.load_and_split()

text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
    chunk_size=200,
    chunk_overlap=50,
)
texts = text_splitter.split_text(pages[13].page_content)
print(len(texts))
for text in texts:
    print(text)
    print('-' * 50)

文本向量化模型

from dotenv import load_dotenv
from langchain_community.document_loaders import CSVLoader
from langchain_openai import OpenAIEmbeddings

load_dotenv()
embeddings = OpenAIEmbeddings()

loader = CSVLoader("data.csv", encoding="utf-8")
pages = loader.load_and_split()

# 存放的是每一个trunk的embeding。
embeded_docs = embeddings.embed_documents([i.page_content for i in pages])
print(len(embeded_docs))
# 表示的是每一个trunk的embeding的维度
print(len(embeded_docs[0]))

# 示例 将文本 text 转换为其嵌入表示形式
text = 'this is a text'
embedding_text = embeddings.embed_query(text)  # 单个文本进行向量转换
print(embedding_text, len(embedding_text))

向量数据存储

从文档中加载数据，向量化后存储到数据库

from dotenv import load_dotenv
from langchain.text_splitter import CharacterTextSplitter
from langchain_community.document_loaders import CSVLoader
from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

load_dotenv()

# 加载文档
loader = CSVLoader("data.csv", encoding='utf-8')
pages = loader.load_and_split()

# 加载文档------>文本拆分
text_spliter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=500)
docs = text_spliter.split_documents(pages)

# 文本嵌入
embeddings = OpenAIEmbeddings()
# 向量存储存储
db_path = './chroma_db'
db = Chroma.from_documents(docs, embeddings, persist_directory=db_path)

向量检索

from langchain.text_splitter import CharacterTextSplitter
from langchain_chroma import Chroma
from langchain_community.document_loaders import CSVLoader
from langchain_openai import OpenAIEmbeddings

# 加载文档
loader = CSVLoader("data.csv", encoding='utf-8')
pages = loader.load_and_split()

# 加载文档------>文本拆分
text_spliter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=500)
docs = text_spliter.split_documents(pages)

# 文本嵌入
embeddings = OpenAIEmbeddings()
# 向量存储存储
db_path = './chroma_db'
db = Chroma.from_documents(docs, embeddings, persist_directory=db_path)

# 以下为使用示例-----------------------------------------------
db_new_connection = Chroma(
    persist_directory=db_path,
    embedding_function=embeddings
)

# 在这个例子中，给定一个新的文本输入"嘉柏湾的房子有那一些"，通过相似性搜索找到与之最相似的文档。
question = '嘉柏湾的房子有那一些'
# 快速查找与特定问题或查询最相关的文档
similar_docs = db_new_connection.similarity_search(question)
# 默认获取top 4的数据
for doc in similar_docs:
    print(doc.page_content)

retriever = db_new_connection.as_retriever()
# 创建检索器,可用实现更多的功能,更多案例请看函数介绍
sim_docs = retriever.invoke('嘉柏湾的房子有那一些')
for doc in sim_docs:
    print(doc.page_content)

5、记忆（Memory）

大多数的大模型应用程序都会有一个会话接口，允许我们进行多轮的对话，并有一定的上下文记忆能力。

但实际上，模型本身是不会记忆任何上下文的，只能依靠用户本身的输入去产生输出。

而实现这个记忆功能，就需要额外的模块去保存我们和模型对话的上下文信息，然后在下一次请求时，把所有的历史信息都输入给模型，让模型输出最终结果。

而在 LangChain 中，提供这个功能的模块就称为 Memory，用于存储用户和模型交互的历史信息。

在这里插入图片描述

输入问题: ({“question”: …})
读取历史消息: 从Memory中READ历史消息（{“past_messages”: […]}）
构建提示（Prompt): 读取到的历史消息和当前问题会被合并，构建一个新的Prompt
模型处理: 构建好的提示会被传递给语言模型进行处理。语言模型根据提示生成一个输出。
解析输出: 输出解析器通过正则表达式 regex(“Answer: (.*)”)来解析,返回一个回答（{“answer”: …}）给用户
得到回复并写入Memory: 新生成的回答会与当前的问题一起写入Memory，更新对话历史。Memory会存储最新的对话内容，为后续的对话提供上下文支持。

记忆管理

最基础的记忆管理方法

Chat Messages 是用于管理和存储对话历史的具体实现。

from langchain_community.chat_message_histories import ChatMessageHistory

history = ChatMessageHistory()
history.add_user_message("hi!")
history.add_ai_message("whats up?")
print(history.messages)

记忆数量管理

from langchain_core.messages import (
    AIMessage,
    BaseMessage,
    HumanMessage,
    SystemMessage,
    trim_messages,
)
from langchain_openai import ChatOpenAI

messages = [
    SystemMessage("you're a good assistant, you always respond with a joke."),
    HumanMessage("i wonder why it's called langchain"),
    AIMessage(
        'Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'
    ),
    HumanMessage("and who is harrison chasing anyways"),
    AIMessage(
        "Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"
    ),
    HumanMessage("why is 42 always the answer?"),
    AIMessage(
        "Because it’s the only number that’s constantly right, even when it doesn’t add up!"
    ),
    HumanMessage("What did the cow say?"),
]

from langchain_core.messages import trim_messages

selected_messages = trim_messages(
    messages,
    token_counter=len,  # <-- len will simply count the number of messages rather than tokens
    max_tokens=5,  # <-- allow up to 5 messages.
    strategy="last",
    # Most chat models expect that chat history starts with either:
    # (1) a HumanMessage or
    # (2) a SystemMessage followed by a HumanMessage
    # start_on="human" makes sure we produce a valid chat history
    start_on="human",
    # Usually, we want to keep the SystemMessage
    # if it's present in the original history.
    # The SystemMessage has special instructions for the model.
    include_system=True,
    allow_partial=False,
)

for msg in selected_messages:
    msg.pretty_print()

将记忆序列化

import json
from langchain.memory import ChatMessageHistory
from langchain.schema import messages_from_dict, messages_to_dict

# 转换为字典格式
dicts = messages_to_dict(conversation.memory.chat_memory.messages)

# 序列化存储到文件中
import pickle

f = open("./memory", 'wb')
pickle.dump(dicts,f)
f.close()

将对话进行存储

import pickle

from langchain.schema import messages_to_dict
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.messages import trim_messages

history = ChatMessageHistory()  # 
history.add_user_message("我叫Bob，你好！")
history.add_ai_message("你好，我是AI")
print(history.messages)

selected_messages = trim_messages(
    history,
    token_counter=len,  # <-- len will simply count the number of messages rather than tokens
    max_tokens=5,  # <-- allow up to 5 messages.
    strategy="last",
    # Most chat models expect that chat history starts with either:
    # (1) a HumanMessage or
    # (2) a SystemMessage followed by a HumanMessage
    # start_on="human" makes sure we produce a valid chat history
    start_on="human",
    # Usually, we want to keep the SystemMessage
    # if it's present in the original history.
    # The SystemMessage has special instructions for the model.
    include_system=True,
    allow_partial=False,
)

for msg in selected_messages:
    msg.pretty_print()

dicts = messages_to_dict(selected_messages)
print(dicts)  # 保存到字典

f = open("./memory", 'wb')
pickle.dump(dicts, f)
f.close()

向对话中添加记忆

import pickle

from dotenv import load_dotenv
from langchain.schema import messages_from_dict
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.messages import HumanMessage
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_openai import ChatOpenAI

load_dotenv()
model = ChatOpenAI()

# 加载之前存储的消息历史
dicts_load = pickle.load(open("./memory", "rb"))
new_messages = messages_from_dict(dicts_load)


def get_session_history():
    return ChatMessageHistory(messages=new_messages)


# 创建可运行的对话链
conversation_reload = RunnableWithMessageHistory(
    model,
    get_session_history
)

# 进行对话
input_message = HumanMessage("我叫什么名字?")
print(conversation_reload.invoke(input=input_message).content)

四、如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】