langChain学习笔记

#langChain入门学习笔记

大模型应用开发基础-LangChain入门

学习内容:
LangChain 核心: LLM, Prompt Templates, Output Parsers, LCEL

• 要求：LangChain LCEL 编写第一个 LLM Chain

解锁技能:

• 掌握 LangChain 核心组件与 LCEL 表达式语言

教程:

路线指导：https://github.com/adongwanai/AgentGuide
练习demo: https://github.com/yunzhongxiaoma/praticeLangChain

LangChain 快速入门

LangChain基本概念

• 提供了一套工具、组件和接口
• 简化了创建LLM应用的过程

基础 LLM 调用验证

项目根目录创建.env文件，写入LLM的模型类型、API Key、base_url

# 智谱 ZHIPU_MODEL=glm-4.5-flash ZHIPU_API_KEY=...... ZHIPU_BASE_URL=https://open.bigmodel.cn/api/paas/v4

# pip install langchain langchain-openai python-dotenvfromlangchain_openaiimportChatOpenAIimportosfromdotenvimportload_dotenv load_dotenv()# 加载 .env 文件中的 API Keyllm=ChatOpenAI(model=os.getenv("ZHIPU_MODEL"),api_key=os.getenv("ZHIPU_API_KEY"),base_url=os.getenv("ZHIPU_BASE_URL"))# 测试调用response=llm.invoke("请解释 LangChain 的核心价值")print(response.content)

LangChain 是 LLM 应用开发框架，用于解决模型调用、流程编排、组件复用等痛点。

LangChain 六大核心模块

核心速记口诀

调模型，写模板，解析输出结构化；

串链条，存记忆，索引助力 RAG 化。

关键提醒

1. LCEL 是串联核心：六大模块均可通过|符号组合，实现极简链式调用。
2. 模块解耦是关键：每个模块独立负责一个功能，可按需替换（如更换 LLM 提供商、切换输出解析格式）。

1. LLMs/Chat Models（模型调用）

核心作用：作为和底层大模型交互的入口，是所有 LangChain 应用的基础。
LangChain 区分两种模型类型：

• LLM：（偏传统）纯文本输入.invoke("xxx")，输出。
• Chat Model：接收结构化的消息列表（含角色：system/human/ai），返回消息格式输出（更贴合现代对话模型）。

感悟：想喂给ai一段设计好供参考的历史消息列表[ ]，就需要用Chat Model方式输入

# Models(LLMs/Chat Models) 测试调用模型fromlangchain_openaiimportChatOpenAIfromdotenvimportload_dotenvimportos load_dotenv()# 初始化Chat Model（推荐优先使用）chat_model=ChatOpenAI(model=os.getenv("ZHIPU_MODEL"),api_key=os.getenv("ZHIPU_API_KEY"),base_url=os.getenv("ZHIPU_BASE_URL"))# 方式1：基础调用（消息列表格式）messages=[("system","你是专业的AI开发工程师，回答简洁准确,越短越好"),("human","LLM和Chat Model的核心区别是什么？")]response=chat_model.invoke(messages)print("Chat Model调用结果：\n",response.content)# 方式2：流式调用（实时返回结果，适合前端展示）print("\n流式调用结果：")forchunkinchat_model.stream(messages):print(chunk.content,end="",flush=True)''' Chat Model调用结果： LLM是通用大型语言模型，Chat Model是专为对话优化的LLM。 流式调用结果： LLM是通用大语言模型，可处理多种任务；Chat Model是专为对话优化的LLM，注重交互性和上下文理解。 '''

2. Prompt Templates（提示词模板）

核心作用：解决提示词硬编码、复用性差的问题，支持动态传参，标准化提示词格式，减少手动拼接字符串的错误。

关键代码：

1. ChatPromptTemplate.from_messages 创建带变量的提示词模板ChatPromptTemplate
2. 模板.format_messages(参数) 传入参数生成提示词，返回list[BaseMessage]
3. llm.invoke(提示词) 调用大模型

fromlangchain_core.promptsimportChatPromptTemplatefromlangchain_openaiimportChatOpenAIfromdotenvimportload_dotenvimportos load_dotenv()llm=ChatOpenAI(model=os.getenv("ZHIPU_MODEL"),api_key=os.getenv("ZHIPU_API_KEY"),base_url=os.getenv("ZHIPU_BASE_URL"))# 1. 创建带变量的提示词模板prompt_template=ChatPromptTemplate.from_messages([("system","你是{field}领域的专家，擅长用{style}风格解释概念"),("human","请解释{concept}的核心原理")])# 2. 动态传入参数生成提示词formatted_prompt=prompt_template.format_messages(field="大模型应用开发",style="通俗易懂",concept="Prompt Engineering")# 3. 结合模型调用response=llm.invoke(formatted_prompt)print("模板化调用结果：\n",response.content)

感悟：

• 觉得看效果太慢可以换成stream流式调用（略）
• 可直接参数传入invoke(xx)或stream(xx)的有：PromptValue, str, list[BaseMessages]。不能直接传入ChatPromptTemplate
  了解模板化调用流程：
  ┌─────────────────┐ with input data ┌─────────────┐ to_messages() ┌──────────────────┐ ┌───────────────┐
  │ Prompt Template │ ────────────────→ │ PromptValue │ ──────────────→ │ List of Messages │ ──────→ │ LLM.invoke() │
  └─────────────────┘ └─────────────┘ └──────────────────┘ └───────────────┘

3. Output Parsers（输出解析器）

核心作用：将 LLM 返回的非结构化文本，转换成 JSON、列表、自定义对象等结构化数据，方便后续业务逻辑处理（如数据存储、条件判断）。

关键代码：

• str_parser = StrOutputParser()
• Schema(BaseModel)、Field
• json_parser = JsonOutputParser(pydantic_object=RAGSchema)
• promptTemplate.partial(xxx=json_parser.get_format_instructions())

fromlangchain_core.promptsimportChatPromptTemplatefromlangchain_core.output_parsersimportStrOutputParser,JsonOutputParserfromlangchain_core.pydantic_v1importBaseModel,Fieldfromlangchain_openaiimportChatOpenAIfromdotenvimportload_dotenvimportos load_dotenv()llm=ChatOpenAI(model=os.getenv("ZHIPU_MODEL"),api_key=os.getenv("ZHIPU_API_KEY"),base_url=os.getenv("ZHIPU_BASE_URL"))# 示例1：字符串解析（基础款，直接提取文本）str_parser=StrOutputParser()simple_prompt=ChatPromptTemplate.from_messages([("human","请用一句话总结RAG的核心流程")])# 组合调用链simple_chain=simple_prompt|llm|str_parser str_result=simple_chain.invoke({})print("字符串解析结果：\n",str_result)# 示例2：JSON解析（进阶款，结构化输出）# 定义JSON结构（用Pydantic约束）classRAGSchema(BaseModel):core_steps:list=Field(description="RAG的核心步骤列表")core_value:str=Field(description="RAG的核心价值")# 创建JSON解析器json_parser=JsonOutputParser(pydantic_object=RAGSchema)# 提示词中加入格式说明（让模型按指定结构输出）json_prompt=ChatPromptTemplate.from_messages([("human","请详细说明RAG的核心步骤和价值\n{format_instructions}")]).partial(format_instructions=json_parser.get_format_instructions())# 组合JSON解析链json_chain=json_prompt|llm|json_parser json_result=json_chain.invoke({})print("\nJSON解析结果（结构化）：")print("核心步骤：",json_result.core_steps)print("核心价值：",json_result.core_value)

感悟

1. ChatPromptTemplate可以作为chain组件用|连接。如果需要动态提示词参数，可在chain.invoke({…})中以json对象传入。
2. LCEL链式调用优点：像拼积木一样，组件解耦，代码简洁（用|连接），还支持批量处理等高级功能。

# 1. 使用 invoke() 参与 LCEL 链式调用chain=prompt_template|llm|parser# 2. 调用链result=chain.invoke(inputs)

在这个过程中：

• prompt_template.invoke(inputs) 返回 PromptValue 对象
• PromptValue 对象被传递给 llm.invoke()
• llm.invoke() 的结果被传递给 parser.invoke()

4. Chains（链）

核心作用：将 Prompt Templates、LLMs、Output Parsers 等独立组件串联起来，实现复杂的多步骤工作流，避免重复编写调用逻辑。LCEL（LangChain Expression Language）是 Chains 的核心语法，通过|符号实现组件组合。

知识点：

• chain.invoke 传入字典参数即可调用，同一链可复用不同输入。
• 批量调用：chain.batch(batch_inputs) 一次处理多个输入，返回结果列表，for idx, res in enumerate(batch_results)按索引输出对应结果。

fromlangchain_core.promptsimportChatPromptTemplatefromlangchain_core.output_parsersimportStrOutputParserfromlangchain_openaiimportChatOpenAIfromdotenvimportload_dotenvimportos load_dotenv()llm=ChatOpenAI(model=os.getenv("ZHIPU_MODEL"),api_key=os.getenv("ZHIPU_API_KEY"),base_url=os.getenv("ZHIPU_BASE_URL"))# 1. 定义组件prompt=ChatPromptTemplate.from_messages([("system","你是LangChain专家，回答简洁且突出重点"),("human","请解释{component}的核心用法")])parser=StrOutputParser()# 2. LCEL链式组合（核心语法：|）chain=prompt|llm|parser# 3. 调用链（支持多参数复用）result1=chain.invoke({"component":"Chains"})result2=chain.invoke({"component":"LCEL"})print("Chains解释：\n",result1)print("\nLCEL解释：\n",result2)# 4. 批量调用（一次处理多个输入）batch_inputs=[{"component":"Prompt Templates"},{"component":"Output Parsers"}]batch_results=chain.batch(batch_inputs)print("\n批量调用结果：")foridx,resinenumerate(batch_results):print(f"{batch_inputs[idx]['component']}：{res}")

5. Memory（记忆）

核心作用：为 Chains 提供上下文记忆能力，让模型能记住多轮对话的历史内容，解决单次调用“无记忆”的问题。常见类型包括：

• ConversationBufferMemory：简单存储所有对话历史；
• ConversationSummaryMemory：总结对话历史（节省Token）。

知识点：

• 记忆组件：ConversationBufferMemory() 保存完整对话历史。
• 带记忆的链：ConversationChain(llm=llm, memory=memory, verbose=True)，支持多轮对话且打印执行细节。
• 多轮调用：predict(input=…) 连续提问，模型会利用历史上下文。
• 查看记忆：memory.load_memory_variables({}) 可直接获取当前累积的对话历史。

fromlangchain.chainsimportConversationChainfromlangchain.memoryimportConversationBufferMemoryfromlangchain_openaiimportChatOpenAIfromdotenvimportload_dotenvimportos load_dotenv()llm=ChatOpenAI(model=os.getenv("ZHIPU_MODEL"),api_key=os.getenv("ZHIPU_API_KEY"),base_url=os.getenv("ZHIPU_BASE_URL"))# 1. 初始化记忆组件memory=ConversationBufferMemory()# 2. 创建带记忆的对话链conversation_chain=ConversationChain(llm=llm,memory=memory,verbose=True# 开启详细日志，可查看链执行过程)# 3. 多轮对话（模型会记住历史）print("第一轮对话：")conversation_chain.predict(input="什么是Naive RAG？")print("\n第二轮对话：")conversation_chain.predict(input="它和进阶RAG的核心区别是什么？")# 4. 查看记忆中的对话历史print("\n对话记忆内容：")print(memory.load_memory_variables({}))

控制台告警ConversationChain弃用，替换位RunnableWithMessageHistory，见整合demo(比之前复杂，提取成了个函数)

弃用的原因

• 多会话支持不足：ConversationChain 需要在链外单独管理记忆类，难以支持多线程/多会话场景。
• 参数不够明确：包含隐藏的默认提示模板，容易造成混淆。
• 流式处理支持有限：仅通过回调支持流式，不如新 API 直接。
• 不符合 LCEL 设计：LangChain 统一到 LCEL（LangChain Expression Language）。

6. Indexes（索引）

核心作用：为 RAG（检索增强生成）提供文档处理能力，包括文档加载、文本分割、向量化、向量存储等，是实现“文档问答”的核心模块。

基础预热Demo代码（提前了解）：

1. 文档创建：

   docs=[Document(page_content="LangChain是LLM应用开发框架，核心模块包括LLMs、Prompt Templates、Output Parsers等",metadata={"source":"LangChain官方文档"})]

2. 文本分割器初始化：

   text_splitter=CharacterTextSplitter(chunk_size=100,chunk_overlap=10)

3. 文档分割执行：

   split_docs=text_splitter.split_documents(docs)

关键知识点

• Document对象：

  • 用于表示文档内容的基本单位
  • 包含page_content（文档内容）和metadata（元数据）两个主要属性

• CharacterTextSplitter文本分割器：

  • chunk_size：控制每个文本块的最大字符数
  • chunk_overlap：设置相邻文本块之间的重叠字符数，确保语义连贯性

• Indexes概念：

  • 索引(Indexes) 文档分割是构建索引的核心步骤之一
  • 将长文档切分为相对较小的块，便于后续处理和检索

• split_documents方法：

  • 用于将文档列表按照指定规则进行分割
  • 返回分割后的文档列表

fromlangchain_core.documentsimportDocumentfromlangchain.text_splitterimportCharacterTextSplitter# 1. 模拟加载文档docs=[Document(page_content="LangChain是LLM应用开发框架，核心模块包括LLMs、Prompt Templates、Output Parsers等",metadata={"source":"LangChain官方文档"})]# 2. 文本分割（Indexes核心步骤之一）text_splitter=CharacterTextSplitter(chunk_size=100,# 每个分片最大长度chunk_overlap=10# 分片重叠长度（保证上下文连续）)split_docs=text_splitter.split_documents(docs)print("文本分割结果：")foridx,docinenumerate(split_docs):print(f"分片{idx+1}：{doc.page_content}")

LCEL整合

LCEL（LangChain Expression Language）是 LangChain 专为组件组合设计的语法，通过 | 符号将 Prompt、LLM、Parser 等组件串联成可复用的链，支持同步 / 异步 / 流式 / 批量调用，是 LangChain 2.0+ 的核心特性。

fromlangchain_core.promptsimportChatPromptTemplate,MessagesPlaceholderfromlangchain_core.output_parsersimportJsonOutputParserfrompydanticimportBaseModel,Fieldfromlangchain_core.runnables.historyimportRunnableWithMessageHistoryfromlangchain_core.chat_historyimportInMemoryChatMessageHistoryfromlangchain_openaiimportChatOpenAIfromdotenvimportload_dotenvimportos load_dotenv()# 1. 初始化基础组件llm=ChatOpenAI(model="glm-4.5-flash",api_key=os.getenv("ZHIPU_API_KEY"),base_url=os.getenv("ZHIPU_BASE_URL"))# 2. 定义输出结构classLCELSchema(BaseModel):definition:str=Field(description="LCEL的定义")usage_scenarios:list=Field(description="LCEL的使用场景")advantages:list=Field(description="LCEL的优势")# 3. 构建提示词模板+解析器parser=JsonOutputParser(pydantic_object=LCELSchema)prompt=ChatPromptTemplate.from_messages([("system","你是LangChain资深工程师，按指定格式输出JSON结果"),("human","请详细介绍LCEL\n{format_instructions}")]).partial(format_instructions=parser.get_format_instructions())# 4. LCEL链式组合chain=prompt|llm|parser# 5. 调用链并输出结果result=chain.invoke({})print("LCEL结构化解析结果：")print(f"定义：{result['definition']}")print(f"使用场景：{result['usage_scenarios']}")print(f"优势：{result['advantages']}")# 6. 结合记忆实现多轮对话# 简化的对话链封装类（类似 ConversationChain 的简单用法）classSimpleConversationChain:"""简化的对话链，使用方式类似 ConversationChain"""def__init__(self,llm,system_message="你是对话助理，回答简洁突出要点",session_id="default"):self.llm=llm self.session_id=session_id self.store={}# 创建带历史的提示模板self.prompt=ChatPromptTemplate.from_messages([("system",system_message),MessagesPlaceholder(variable_name="history"),("human","{input}")])# 构建基础链self.chain_base=self.prompt|llm# 包装为带历史的链self.chain=RunnableWithMessageHistory(self.chain_base,self._get_history,input_messages_key="input",history_messages_key="history")# 会话配置self.config={"configurable":{"session_id":session_id}}def_get_history(self,session_id:str)->InMemoryChatMessageHistory:"""内部方法：获取或创建历史记录"""ifsession_idnotinself.store:self.store[session_id]=InMemoryChatMessageHistory()returnself.store[session_id]defpredict(self,input:str):"""类似 ConversationChain 的 predict 方法"""result=self.chain.invoke({"input":input},config=self.config)returnresult.contentifhasattr(result,'content')elseresultdefinvoke(self,input:str):"""直接调用方法"""returnself.predict(input)conv_chain=SimpleConversationChain(llm=llm,system_message="你是对话助理，回答简洁突出要点",session_id="demo-session")response=conv_chain.predict(input=f"请用通俗的语言解释{result['definition']}")print("\n对话结果：",response)