框架介绍

LangChain 是一个构建 LLM 应用的框架，目标是把 LLM 与外部工具、数据源和复杂工作流连接起来 —— 支持从简单的 prompt 封装到复杂的 Agent（能够调用工具、做决策、执行多步任务）。它不仅仅是对LLM API的封装，而是提供了一套完整的工具和架构，让开发者能够更轻松地构建上下文感知和具备推理能力的AI应用。LangChain 1.0 版本把“Agent 的稳定化、结构化输出、可观测性与生产化”作为核心改进目标。

用LangChain能做什么？

• 构建 Retrieval-Augmented Generation（RAG）问答系统
• 把 LLM 当作“Agent”去调用外部 API（搜索、数据库、文件系统）并返回任务结果
• 组织 prompt → 模型 → 后处理 的可复用流水线（Chains）
• 实现多轮对话带记忆（Memory）与长会话管理
• 在生产中管理可观测性与评估（配合 LangSmith/LangGraph）

1.0 的架构风格可以用一句话概括:以“统一智能体抽象 + 标准化内容表示 + 可插拔治理中间件”为设计骨干,以 LangGraph 为底座运行时,实现“开发简单性”与“生产可控性”的兼顾。它一方面通过 create_agent 提供低门槛的构建入口,另一方面保留足够的钩子点与下探能力,以满足复杂工作流与高标准治理的需求。

LangChain生态概览

模型层（Models）

LangChain 1.0 的统一模型抽象层，为所有模型提供标准化调用，覆盖文本、多模态、Embedding、Rerank 等多类型模型，实现跨供应商一致体验

• 统一抽象：init_chat_model() 适配20+模型厂商
• 异步/流式/批处理：ainvoke()，stream(), batch()
• 执行方式：完全兼容 LCEL 与 LangGraph
• 扩展能力：with_structured_output()、Tool Calling、多模态 Content Blocks

工具层（Tools）

工具系统提供统一 Tool 抽象，支持所有主流模型的 Tool Calling，深度集成 LangGraph，构建可执行 agent 环境的关键能力层

• 内置工具：搜索、计算、代码执行等100+工具
• 自定义工具：@tool装饰器 / BaseTool / ToolNode
• 工具包：Toolkit（如GitHub、Slack集成）

记忆层（Memory）

记忆层提供统一 State 管理、对话记录、长期检索、多模态 Memory 等能力，支持持久化与复杂工作流状态流转

• 短期记忆：消息历史自动管理
• 长期记忆：向量数据库存储（Chroma, Pinecone）
• 存储接口：Store（跨会话持久化）

Agent层（Agents）

LangChain 1.0 Agents系统实现从碎片化到标准化升级，以create_agent为核心接口，基于LangGraph构建统一Agent抽象，10行代码即可创建基础Agent，封装"模型调用→工具选择→执行→结束"闭环流程

• 核心API：create_agent()
• 执行引擎：LangGraph Runtime（自动持久化）
• 中间件：Middleware（HITL、压缩、路由）

工作流层（Workflows）

Workflows 体系实现从 线性链式（Chain）到图结构（Graph） 的范式转移，以 StateGraph 为核心画布，将业务逻辑解耦为 "节点（Node）+ 边（Edge）+ 状态（State）"，原生支持循环（Loop）与条件分支，完美适配复杂任务编排、容错重试及长会话保持。

• 简单链：Chain（快速串联）
• 复杂图：LangGraph（条件分支、循环）
• 模板库：LangChain Hub（共享Agent模板）

调试监控层（Debugging）

LangChain 1.0 调试监控层实现了从 日志黑盒到全链路可观测性（Observability） 的质变，深度集成 LangSmith 平台，自动捕获链（Chain）与图（Graph）的每一步骤状态、Token 消耗及延迟，支持"Trace → Playground"一键回放调试，彻底解决复杂 Agent 逻辑难以排查的痛点。

• 本地日志：verbose=True
• 云端平台：LangSmith（可视化链路追踪）
• 评估工具：LangChain Evaluate（效果评估）

其他关键组件 (LangGraph & LangServe)

• langgraph: 这是一个底层的Agent 调度框架 (Agent Runtime)，是一个相对“低级”（Low-level）的编排框架，它专注于解决复杂的“控制流”问题，用于构建健壮且有状态的多角色 LLM 应用程序。LangChain 1.0 中的新 Agents (通过 create_agent()) 就是建立在 LangGraph 之上的。
• langserve: 用于将任何 LangChain chain 或 agent 部署为 REST API 的包，方便快速将应用投入生产环境。

底层运行架构

• LCEL：提供Runnable接口（invoke, stream, batch）和组合原语（|运算符），是无状态的函数式编排，构建“流水线（pipeline）”的工具
• LangGraph：在LCEL基础上增加状态管理（State）、循环控制（Cycles）、持久化（Checkpoints），是有状态的图结构编排，构建“流程图（workflow/graph）”的工具

Runnable底层执行引擎

Runnable 是 LangChain 1.0 的“统一接口标准”，任何可以运行的组件——模型、Prompt、工具、解析器、Memory、Graph 节点——在 1.0 中都被抽象为 Runnable。

Runnable 使所有 LangChain 组件能够以统一接口组合、执行、链式调用，并支撑 LCEL（LangChain Expression Language）的整个运行语义，支撑可组合、可并行、可路由的链式执行，是 LangChain 1.0 的核心底座之一。

• LangChain 1.0 将所有链式元素统一为 Runnable（执行模型）：

• • LLM（OpenAI、vLLM、Ollama……）
  • Prompt
  • Parser
  • Retriever
  • Tool
  • Agent
  • 自定义函数

所有对象都可以 .invoke()、.batch()、.stream()、.astream_events()，这实现了真正的统一调用接口。

• 工程价值：

• • 链路清晰。
  • 任意组件之间可无缝组合。
  • 所有执行方式（同步 / 异步 / 批处理 / 事件流）统一。
  • 这是 LangChain 1.0 最具革命性的改变，使其成为“模型调用管道”的事实标准。

技术	在 LangChain 1.0 的角色
LangChain	构建 LLM + prompt + tool + outputparser 的组件生态
LangGraph	构建 Agent / 多步工作流 / 状态机的框架
LCEL / Runnable	LangChain 的底层执行引擎，依然核心

LangChain模块化管理的定位和描述

langchain-core	核心抽象层和 LCEL	定义所有组件（如模型、消息、提示词模板、工具、运行环境）的标准接口和基本抽象。它包含了 LangChain 表达式语言 (LCEL)，这是构建链式应用的基础。这是一个轻量级、不含第三方集成的基石包。
langchain	应用认知架构（主包）	包含构建 LLM 应用的通用高阶逻辑，如 Agents (如新的 create_agent() 函数)、Chains 和通用的检索策略 (Retrieval Strategies)。它建立在 langchain-core 之上，是用于组合核心组件的“胶水”层。
langchain-community	社区第三方集成	包含由 LangChain 社区维护的非核心或不太流行的第三方集成，例如：大部分的文档加载器 (Document Loaders)、向量存储 (Vector Stores)、不太流行的 LLM/Chat Model 集成等。为了保持包的轻量，所有依赖项都是可选的。
langchain-openai / langchain-[厂商名称]	特定厂商深度集成	针对 关键合作伙伴 的集成包（如 langchain-openai, langchain-anthropic）。它们被单独分离出来，以提供更好的支持、可靠性和更轻量级的依赖。它们只依赖于 langchain-core。
langchain-classic	旧版本兼容	包含 LangChain v0.x 版本中的已弃用 (deprecated) 或旧版功能，如旧的 LLMChain、旧版 Retrievers、Indexing API 和 Hub 模块。它的主要作用是为用户提供一个平稳的迁移期，确保旧代码在升级到 v1.0 后仍能运行。

langchain-core

• 包含 核心抽象与接口：LLM/ChatModel 抽象、Prompt 抽象、Chain/Agent 的基类、schema、消息格式等。
• 不包含具体厂商的实现（例如没有 OpenAI client 的封装），而是定义“合同（interfaces）”，其他包在此之上实现具体功能。
• 这是构建 LangChain 应用生态的最小公共底座。

langchain 主包

• 对外的主入口包：把 langchain-core 的核心抽象与“常用实现”组合在一起，便于快速上手。
• 在 v1.0 中，langchain 的命名空间被 显著精简，只保留构建 agent 的关键 API（更轻、更专注）。官方建议大多数用户直接使用此主包以获得“开箱即用”的体验。

模块	核心内容	来源说明
langchain.agents	create_agent, AgentState	智能体创建核心
langchain.messages	AIMessage, HumanMessage, trim_messages	从langchain-core重新导出
langchain.tools	@tool, BaseTool	从langchain-core重新导出
langchain.chat_models	init_chat_model, BaseChatModel	统一模型初始化
langchain.embeddings	init_embeddings	嵌入模型管理

langchain-community 第三方集成库

langchain-community 作为 LangChain 1.0 的“功能扩展层”，通过社区贡献的非官方集成组件显著扩展了主包的功能边界，其核心价值体现在工具类组件与平台集成两大维度。工具类组件覆盖文档处理全流程，包括 DirectoryLoader 文档加载器（支持 PDF、文本等多格式文件批量导入）、RecursiveCharacterTextSplitter 文本分割器（按语义边界将文档切分为检索友好的 Chunk）、PGVector 向量存储（PostgreSQL 生态的向量数据库适配）及 HuggingFaceEmbeddings 嵌入模型（本地部署模型的向量化能力），这些组件共同构成了 RAG 应用的技术基础。平台集成方面，支持与 DeepSeek、阿里云通义千问等模型的对接，例如通过 langchain_community.chat_models.ChatTongyi 类初始化通义千问模型，或利用 Ollama 类调用本地部署的 DeepSeek-R1 模型。

• 收集并维护 社区/第三方贡献的集成（例如某些云厂商、开源向量库、特殊工具适配器等）。这些集成实现了 **langchain-core 定义的接口**，但不属于主包维护范畴。官方会把这些放到 langchain-community 仓库/包，便于社区共同维护。

包含内容：

• 数据库：MySQL, PostgreSQL, MongoDB, Neo4j等连接器
• 存储服务：AWS S3, 阿里云OSS, Google Cloud Storage
• 工具集成：Slack, Notion, GitHub, ArXiv, YouTube等API
• 向量数据库：Chroma, Pinecone, Qdrant, Milvus等
• 文档加载器：PDF, CSV, HTML, Markdown解析器

特点：

• 质量参差不齐：社区贡献，需自行验证稳定性
• 更新滞后：依赖社区维护，响应速度慢于官方包
• 功能丰富：覆盖95%的第三方服务集成需求

langchain-openai（厂商/提供者集成包）

厂商特定集成包（如 langchain-openai、langchain-anthropic、langchain-google 等）通过封装 API 细节，为开发者提供“零适配成本”的模型对接方案，其核心价值在于简化特定 API 对接流程，使开发者能够直接使用厂商特有功能。以 langchain-openai 为例，其关键组件包括模型客户端、工具调用适配和多模型支持三大模块。

此外，该类还支持通过配置 openai_api_base 和 openai_api_key 参数对接兼容 OpenAI API 格式的第三方模型，如 DeepSeek 模型

• 专门负责把 OpenAI 的 SDK 与 LangChain 抽象连接起来：提供 ChatOpenAI、OpenAIEmbeddings、OpenAI等类的实现。
• 这类包通常是 “按厂商拆分”：langchain-openai、langchain-azure、langchain-anthropic、langchain-deepseek等。
• 官方深度集成特定LLM提供商，更新频繁，功能最全.

维度	langchain-openai	langchain-community 中的OpenAI
维护方	OpenAI官方 + LangChain团队	社区维护
更新频率	即时跟进API更新	延迟数周
功能完整性	支持所有新特性（如音频、视觉）	仅基础功能
生产可用性	✅ 强烈推荐	⚠️ 谨慎使用

langchain-classic

• 兼容包 / 迁移包：把 LangChain v0.x 中的“老 API / legacy 功能”搬到单独包里，以便 v1.0 保持精简，但仍给用户向后兼容的迁移通道。
• 包含如：老的 Chain 实现、旧版 retrievers、索引 API、hub 模块等被标记为“legacy”的功能。

• • 旧版AgentExecutor
  • Legacy Chains（LLMChain, SequentialChain等）

核心概念与组件

LLM/ChatModel大模型接口

DeepSeek

# 1 导入 ChatDeepSeek
from langchain_deepseek import ChatDeepSeek

# 2 初始化模型参数
model = ChatDeepSeek(
    model="deepseek-chat",
    temperature=0.0,    # 温度参数，用于控制模型的随机性，值越小则随机性越小
    max_tokens=512,     # 最大生成token数
    timeout=30,         # 超时时间，单位秒
    base_url=DeepSeek_BASE_URL # 默认为https://api.deepseek.com
)

# 3 定义问题
question = "你好，请你介绍一下你自己。"

# 4 调用模型
result = model.invoke(question)

# 5 输出结果
print(result.content)

DashScope

from langchain_community.chat_models.tongyi import ChatTongyi

model = ChatTongyi() # 默认qwen-turbo模型

question = "你好，请你介绍一下你自己。"

result = model.invoke(question)
print(result.content)

OpenAI

# 1 导入 OpenAI
from langchain_openai import OpenAI

# 2 初始化模型
llm = OpenAI(model="gpt-4o-mini")

# 3 定义问题
question = "你好，请你介绍一下你自己。"

# 4 调用模型
result = llm.invoke(question)

# 5 打印结果
print(result)

Ollama

# 1 导入 OllamaLLM
from langchain_ollama import OllamaLLM

# 2 初始化本地模型
llm = OllamaLLM(model="deepseek-r1:8b")

# 3 定义问题
question = "你好，请你介绍一下你自己。"

# 4 调用模型
result = llm.invoke(question)

# 5 打印结果
print(result)

Vllm

# 连接本地vLLM服务
from langchain_openai import ChatOpenAI

# 连接到本地 vLLM 服务,配置长连接池，减少握手开销
model = ChatOpenAI(
    model="qwen-32b-chat",                  # 指定使用的模型名称
    base_url="http://localhost:8000/v1",    # vLLM 的 OpenAI API 地址
    api_key="EMPTY",                        # vLLM 不验证 key，可以随便写
    max_retries=5,                          # 增加重试次数
    timeout=120.0,                          # 超时时间设长
    http_client={                           # 自定义 HTTP 客户端
        "limits": {
            "max_connections": 100,         # 最大连接数
            "max_keepalive_connections": 20    # 最大保持活动连接数
        }
    }
)

init_chat_model（）

# 使用init_chat_model初始化DeepSeek模型
from langchain.chat_models import init_chat_model

# 1. 初始化模型（自动识别供应商）
model = init_chat_model(
    "deepseek-chat",                # 指定DeepSeek的聊天模型
    model_provider="deepseek",      # 指定模型提供商为deepseek
)

# 一行代码切换模型，业务代码0改动
# model = init_chat_model("gpt-4o", model_provider="openai")
# model = init_chat_model("claude-3-5-sonnet", model_provider="anthropic")

question = "你好，请你介绍一下你自己。"

result = model.invoke(question)
print(result.content)

init_embeddings（）

# 1. 使用init_embeddings初始化嵌入模型
from langchain.embeddings import init_embeddings

# 2. 初始化OpenAI的text-embedding-3-small嵌入模型
embedding = init_embeddings(model="text-embedding-3-small",provider="openai")   

# 3. 将文本转换为向量表示
res = embedding.embed_query("Hello world")    

# 4. 打印向量的前10个元素
print(res[:10])

消息列表messages

role	作用
system	设定模型的身份、风格、规则，是“最高优先级”
user	表示用户提问内容，是本轮对话的主体输入
assistant/ai	表示模型历史回答，有助于形成上下文记忆
tool	工具调用结果（用于 Agent）
developer	开发者提示（OpenAI 新增 role），模型的功能逻辑 / 工程约束

# 导入OpenAI官方SDK，用于调用兼容OpenAI接口的模型服务
from openai import OpenAI

# 初始化DeepSeek的API客户端
client = OpenAI(api_key=DeepSeek_API_KEY, base_url="https://api.deepseek.com")

# 指定模型为deepseek-chat，构造系统提示和用户提问
response = client.chat.completions.create(
    model="deepseek-chat",  # 使用的模型名称
    messages=[
        {"role": "system", "content": "你是乐于助人的助手，请根据用户的问题给出回答"},  # 系统角色，定义助手行为
        {"role": "user", "content": "你好，请你介绍一下你自己。"},  # 用户提问内容
    ],
)

messages 的执行顺序与优先级（非常关键）

LLM 按如下顺序解析：

• 1.system（最高优先级）
• 2.developer（模型的功能逻辑 / 工程约束）
• 3.user/human 用户当前输入的 query
• 4.assistant 历史对话
• 5.tool 调用

Prompt提示词模板

PromptTemplate

from langchain_core.prompts import PromptTemplate

# 创建一个带有{product}占位符变量的模板，{} 中的变量会被动态替换
prompt_template = PromptTemplate.from_template(
    "为生产{product}的公司起一个好名字？"
)

# 使用具体值格式化模板
formatted_prompt = prompt_template.format(product="智能水杯")
# 输出: "为生产智能水杯的公司起一个好名字？"

# 将格式化后的提示词直接传递给模型
response = model.invoke(formatted_prompt)

print(f"打印生成的提示词：{formatted_prompt}")
print("=" * 60)
print(response.content)

partial_variables固定变量

partial_variables = 提前填充固定变量，使 PromptTemplate 成为“半成品模版”

• 让模板更简洁,锁定系统设定、风格角色、不变提示词,它仍可以进行覆盖操作，可用于动态函数变量，强烈建议用于 RAG / Agent 中的系统指令管理！
• 一些变量通常是 固定不变 的（例如：风格、角色、系统设定）
• 另一些变量由 用户输入决定（如用户问题、上下文、消息）
• 如果全部变量都在 .format() 填，会很啰嗦，还容易丢变量。
• 因此 LangChain 允许你把不变的变量“预填”到模板中，变成一个 partial prompt。

# 导入 PromptTemplate 类，用于构建可复用的提示词模板
from langchain_core.prompts import PromptTemplate  

# 创建模板：{} 中的变量会被动态替换
# 类比：邮件模板中的{{姓名}}占位符
template = PromptTemplate(
    input_variables=["product", "feature"],  # 明确声明变量名，确保模板知道需要哪些输入
    template="请为{product}的{feature}功能写一段宣传文案。"  # 定义模板字符串，占位符将在运行时被替换
)

# 格式化：填充变量，将具体值传入模板生成最终提示词
prompt_text = template.format(
    product="智能手机",  # 替换模板中的 {product}
    feature="AI摄影"   # 替换模板中的 {feature}
)

print("生成的提示词：")
print(prompt_text)
# 输出：请为智能手机的AI摄影功能写一段宣传文案。

项目	input_variables	partial_variables
是不是用户必须提供？	是	否
何时填入？	.format() 时	Template 定义时/.partial()覆盖
是否可覆盖？	是	是
是否支持函数？	否	支持（动态变量）
适合场景	用户输入内容	prompt 预设、系统指令

ChatPromptTemplate

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage, HumanMessage

# 使用messages模板字符串（最常用）
chat_template = ChatPromptTemplate.from_messages([
        
    # SystemMessage: 定义AI角色和行为准则
    ("system", "你是一个专业的Python代码审查助手。请严格检查代码风格、潜在Bug和性能问题。"),

    # HumanMessage: 用户输入
    ("human", "请审查以下代码：\n\n{code_snippet}"),

    # AIMessage: 可选，提供示例输出（Few-shot）
    ("ai", "我发现了以下问题：1. 缺少类型注解 2. 使用全局变量"),

    # HumanMessage: 用户的后续指令
    ("human", "{follow_up_instruction}")
])

# 格式化：生成消息列表
messages = chat_template.format_messages(
        
    code_snippet="def add(a,b):\n    return a+b", 
        
    follow_up_instruction="请给出优化后的代码"
)

print("生成的消息结构：")
for i, msg in enumerate(messages):
    print(f"\n--- 消息 {i+1} ---")
    print(f"角色: {msg.schema}")
    print(f"内容: {msg.content}")

# 直接传递给模型
response = model.invoke(messages)
print("\n 模型审查结果：")
print(response.content_blocks[0]["text"])

LangChain Hub 模版库

使用提示词模版库之前需要先到LangSmith官网上申请一个api_key,官网地址：https://smith.langchain.com/

import os
from dotenv import load_dotenv
load_dotenv()

# 从langsmith库引入Client类
from langsmith import Client 

# 通过LangSmith的LANGSMITH_API_KEY创建Client实例化
client = Client(api_key=os.getenv("LANGSMITH_API_KEY"))

# 从hub上拉取对应的prompt模版
# 指定prompt标识符"rlm/rag-prompt"，获取可用于RAG场景的提示模板
prompt = client.pull_prompt("rlm/rag-prompt", include_model=True)

print(prompt)

标准化内容块Content Blocks

支持类型：text 、 tool_call 、 image 、 audio 、 video

场景	内容块作用
📄 文档解析（PDF / 图片 / 表格）	用 image block 把 Document OCR 图像传给模型
🔊 语音问答（ASR）	用 audio block 发送语音样本
🎞 多模态 RAG	将检索到的图片、图表、视频帧作为 input blocks 传给模型
🤖 多工具 Agent	工具返回的媒体统一包装成 block 再传回模型
🧪 模型评估（LangSmith / LangChain Playground）	进行 multimodal prompt 测试与 A/B，对 content blocks 标注与评估。

from langchain_core.messages import HumanMessage, SystemMessage

# 创建系统提示
system_msg = SystemMessage("你是一个专业的问答专家。")

# 构造用户消息：文本+图像
human_msg = HumanMessage(content=[
    {"type": "text", "text": "请描述图像："},
    {"type": "image_url", 
     "image_url": {"url": "https://zrj18330672592.oss-cn-beijing.aliyuncs.com/20251015134735612.png", 
     "mime_type": "image/jpeg",
     "metadata": "RAG基础流程图"}
    },
])

# 形成消息列表
messages = [system_msg, human_msg]

# 框架会懒解析 content -> content_blocks
for cb in human_msg.content_blocks:
    print(cb)   # content block 对象视图

批处理流程

import time
from datetime import datetime

# 记录开始时间
start_time = time.time()
print(f"⏱️  开始时间: {datetime.now().strftime('%H:%M:%S.%f')[:-3]}")

# 批量提问
responses = model.batch([
    "请介绍下你自己。",
    "请问什么是机器学习？",
    "你知道机器学习和深度学习区别么？"
])

# 记录结束时间
end_time = time.time()
total_duration = end_time - start_time

print(f"⏱️  结束时间: {datetime.now().strftime('%H:%M:%S.%f')[:-3]}")
print(f"📊 总耗时: {total_duration:.2f}s")

for response in responses:
    print(response)

流式传输 (Streaming)

需要注意的是：

1. 流式输出依赖于整个程序链路都支持“逐块处理”。如果程序中的某个环节必须等待完整输出（如需一次性写入数据库），则无法直接使用 Streaming；
2. LangChain 1.0 进一步优化了流式机制，引入 自动流式模式（Auto-streaming）。例如在Agent中，如果整体程序处于 streaming 模式，即便节点中调用 model.invoke()，LangChain 也会自动流式化模型调用。

# 使用.stream()方法进行流式传输
for chunk in model.stream("用一段话描述大海。"):
    print(chunk.content, end="", flush=True)  # 逐块打印
        
# 输出会像真正的打字效果一样，一个一个词地出现。

JsonOutputParser

from langchain_core.output_parsers import JsonOutputParser
import json
from pydantic import BaseModel, Field

# 1. 定义输出结构
class WeatherInfo(BaseModel):
    """天气信息"""
    city: str = Field(description="城市名称")
    temperature: int = Field(description="温度（摄氏度）")
    condition: str = Field(description="天气状况")

# 2. 创建 JSON 输出解析器
json_parser = JsonOutputParser(pydantic_object=WeatherInfo)

# 3. 创建提示模板（关键：必须包含 "json" 这个词）
prompt = ChatPromptTemplate.from_template(
        
"""请根据以下信息提取天气数据，并以 JSON 格式返回。

信息：{weather_info}

请返回包含以下字段的 JSON：
- city: 城市名称
- temperature: 温度（摄氏度）
- condition: 天气状况

必须返回以下 JSON 格式（不要包含任何其他文本）：
{{"city": "城市名称", "temperature": 温度数字, "condition": "天气状况"}}

例如：{{"city": "北京", "temperature": 25, "condition": "晴"}}

JSON 格式：
""")

# 4. 定义模型
model = load_chat_model(
    model="gpt-4o-mini",
    provider="openai",
)

# 5. 构建链
runnable = prompt | model | json_parser

# 6. 调用
result = runnable.invoke({"weather_info": "北京今天晴，温度25度"})
print(result)
print(result["city"])

分类	常用解析器	作用
基础解析	StrOutputParser	将模型输出解析成纯字符串（默认）
JSON 结构化解析	JsonOutputParser	将 LLM 输出强制解析为 JSON
	PydanticOutputParser	使用 Pydantic v1 模型进行结构化输出
	PydanticOutputFunctionsParser	用于 Function Calling 的 Pydantic 结构化解析
列表解析	CommaSeparatedListOutputParser	输出如 "a,b,c" → ["a", "b", "c"]
	ListOutputParser	更通用的列表解析
布尔/数值解析	BooleanOutputParser	输出 "yes" / "no" → True/False
	FloatOutputParser	输出模型内容转 float
	IntOutputParser	输出模型内容转 int
复杂结构化	EnumOutputParser	让模型输出固定几个选项之一
	DataclassOutputParser	使用 Python dataclass 进行结构化输出