day12-LangChain-v1.2.9核心组件之Agents和Models

今日内容

1 LangChain 介绍

1.1 LangChain是什么

# 1 LangChain 是一个用于构建【基于大语言模型（LLM）】应用的开源框架，其目标是让开发者更容易地将 LLM 与外部数据、工具和业务逻辑集成，从而构建出强大、灵活、可扩展的 AI 应用（如聊天机器人、智能代理、文档问答系统等），智能体--》都可以基于LangChain开发，低代码平台Coze，dify。

# 2 LangChain 并不是一个单一库，而是一个模块化、可组合的生态系统，常被称为 “LangChain 家族”。
	-LangChain 生态
        -LangChain ：框架
        -Lang graph
        -LangSmith
        -LangServe
        -。。。。
-------------官网写的，有些晦涩----------------------       
# 3 LangChain 是一个开源框架，具有预构建的Agent架构，并集成了任何模型[modle]或工具[tools]，因此您可以构建能够随着生态系统发展而快速适应的Agent智能体

# 4 LangChain 是构建由 LLMs 驱动的AGENT和应用程序的最简单方式。只需不到 10 行代码，你就可以连接到 OpenAI、Google,国产DeepSeek 等。LangChain 提供了预构建的代理架构和模型集成，帮助你快速开始，并无缝地将 LLMs 集成到你的智能体和应用程序中

# 5 如果你想要快速构建代理和自主应用程序，我们推荐使用 LangChain。当你有更高级的需求，需要结合确定性流程和代理式工作流、重度定制以及严格控制延迟时，使用我们的低级代理编排框架和运行时 LangGraph。

# 6 LangChain 代理建立在 LangGraph 之上，以提供持久执行、流式传输、人工参与、持久化等功能。对于基本的 LangChain 代理使用，你不需要了解 LangGraph

LangChain 很多东西，基于LangGraph，直接用了LangGraph组件或模块--》如果只做单智能体开发，不需要了解LangGraph，如果想做多智能体开发，可以选择LangGraph，不选也没问题


# 7 市面上可以用LangChain 开发的软件：京东京言。。。
	-结合大模型，结合公司相关业务--》开发出智能客服

大模型要访问公司的数据库

访问公司数据库的是工具---》工具访问完，拿到数据---》给大模型分析

大模型是可以使用本地的

1.2 LangChain发展史

## 1.1 2022 年 11 月 项目诞生:  GPT 还没出
-LM----》LLM---》GPT 是第一款：LLM
创始人：Harrison Chase  当时只有几百行代码的demo
首次开源：在 GitHub 发布初版，目标是“简化 LLM 应用开发”
核心概念：引入 Chain（链式调用）、PromptTemplate、基础 LLM 集成（如 OpenAI）
定位：实验性工具，面向开发者快速构建
- Chain：链

## 1.2 2023 年 3 月｜v0.1.0（首个稳定版）
模块化设计初步成型
支持：
    基础 Chains（LLMChain, SequentialChain）
    简单 Memory（对话历史）
    工具调用雏形
文档和示例大幅完善

##1.3  2023 年中 – 2024 年初｜v0.2.x ~ v0.3.x：生态扩张期
v0.2.0（2023 Q2）：
    引入 Agent 抽象（ReAct、Plan-and-Execute）
    支持自定义工具（Tools）
v0.3.0（2023 Q4）：重大版本
    多模态初步支持
    LangChain Hub 上线（共享 Prompt 和 Chains）
    性能优化与错误处理改进
问题暴露：
    API 不统一（几十种 create_xxx_agent）
    包体积臃肿（“全量安装”模式）
    抽象过重，定制困难
    
## 1.4 2024 年｜模块化重构启动
开始拆分 monorepo：
    langchain-core（抽象层）
    langchain-community（社区集成）
    独立 LLM 包（如 langchain-openai）
目标：轻量化 + 可组合

## 1.5 2025 年 9 月｜LangChain 1.0 Alpha
全新架构预览：
    统一 Agent 创建接口：create_agent()
    引入 Middleware（中间件）机制
    与 LangGraph 深度整合（作为底层运行时）
    
## 1.6  2025 年 10 月 23 日｜LangChain 1.0 正式发布（里程碑！）
-标志着从“原型工具”迈向“生产就绪框架”---》应用于企业智能体开发
-生产级特性：
    内置重试、限流、日志、监控钩子
    支持流式输出、结构化输出（JSON Schema）
    动态模型/工具选择
    状态持久化（通过 LangGraph）
-核心变革
# 版本变化介绍
1.0
1.1
1.2 
---添加功能---
1.2.1
1.2.6
1.2.x 
---改bug---几乎一周一个版---
python3.11
python3.12 加功能
python3.1.2.3 改bug

# 官网：
https://www.langchain.com/
文档：https://docs.langchain.com/oss/python/langchain/overview
LangChain 有两种语言版本
	-python
    -ts
    
# 最新版本：
python：1.2.9版本
ts:     1.2.16版本

1.3 LangChain家族

# 1 LangChain 是一个生态,很多组件，框架
############## 家族 ###################
## 1. LangChain Core（langchain-core）
## # 定义 LangChain 的基础抽象和接口（如 LLM、ChatModel、Tool、Document、Retriever 等），不依赖具体实现。
    提供统一的接口规范（类似“协议”）
    所有其他组件都基于它构建
    轻量、无第三方依赖
    开发者通常不直接使用，但它是整个生态的基石
    
## 2 LangChain（langchain）
### 作用：
LangChain 的主包，提供完整的链（Chains）、记忆（Memory）、索引（Indexing）、代理（Agents）等高级功能，并集成了大量第三方工具。
### 核心能力
Chains：将多个步骤（如提示 + LLM + 解析）串联成工作流
Agents：让 LLM 能够调用工具（如搜索、计算器、API）自主决策
Retrieval：从向量数据库等检索相关文档（RAG 的核心）
Memory：在对话中保持上下文（短期/长期记忆）
Callbacks：监控、日志、流式输出等


## 3 LangChain Community（langchain-community）
## 作用：
包含社区贡献的集成（如各种 LLM、向量数据库、文档加载器、工具等），从主 langchain 包中剥离出来以保持核心轻量。


## 5 LangGraph
### 作用：用于构建有状态、多参与者、循环逻辑的智能体（Agent）工作流，支持复杂控制流（如条件分支、循环、人工干预）。
    基于 State Graph 模型
    适合构建 自主 Agent 系统（如 AutoGen 类应用）
    支持持久化、中断恢复、人类反馈回路

## 6 LangServe
### 作用：将 LangChain 链（Chain）或 Runnable 快速部署为 RESTful API 或 FastAPI 服务。
    一行代码部署 LLM 应用
    自动生成 OpenAPI 文档和 Playground UI
    支持异步、流式响应、输入验证
   
## 7  LangSmith：企业中不使用：1 收费    2 企业觉得不安全
### 作用：LangChain 官方提供的 开发、测试、监控和调试平台（SaaS 服务）。
### 功能包括：
    Trace 可视化：查看 LLM 调用链、Token 使用、延迟
    Dataset 管理：创建测试集评估模型效果
    Prompt 管理：版本控制、A/B 测试
    监控告警：生产环境性能监控
    Human-in-the-loop：人工审核与反馈
    
    
## 8 DeepAgents：新产品--》构建单智能体--》想法：让单智能体开发更简单：个人观点
	- 取代LangChain
    -以后LangChain 指的是整个生态：很多产品LangSmith，LangGraph，DeepAgents，而不是某个框里
    	-目前LangChain 还是框架
    -大家历史上认为LangChain 是个框架---》需要一点点把框架概念淡化
    -以后：单智能体开发用 DeepAgents，多智能体开发用 LangGraph，监控：LangSmith，部署用：LangServe
    -一套生态叫：LangChain

组件	用途	是否必须
langchain-core	基础接口	✅（自动安装）
langchain	主功能（Chains, Agents, RAG）	✅（主包）
langchain-community	社区集成（向量库、文档加载器等）	⚠️ 按需安装
langchain-openai 等	商业 LLM 集成	⚠️ 按需安装
langgraph	复杂 Agent 工作流	❌（高级场景）
langserve	部署为 API	❌（需要部署时）
LangSmith	调试/监控平台	❌（推荐用于生产）

场景	所需组件
本地 PDF 问答（RAG）	langchain + langchain-community（PDF loader + FAISS）+ langchain-openai
智能客服 Agent	langchain（Agents）+ langchain-anthropic + langsmith（监控）
部署 LLM API	langchain + langserve
自主研究 Agent	langgraph + langchain + langchain-community（搜索工具）

1.4 安装

# 0 langchain 0.3.x  ,官方要求是 3.8版本
# 1 Python 解释器环境：langchain 1.x 版本 官方要求 > Python 3.10---》我用了 Python 3.13，推荐你们用

# 2 安装LangChain
	pip install langchain # 装最新
    # 跟大模型 对接，正常来讲，对接不同大模型，需要装不同的模块
    pip install langchain-openai   # 不同厂商，绝大部分都会兼容openai接口---》对接千问，deepseek，都可以使用 langchain-openai对接，但是跟官方还是有少许区别
    pip install langchain-deepseek   
    pip install langchain-ollama
    pip install -U langchain-anthropic # 对接 claude 模型
    pip install python-dotenv # 环境变量管理
    
# 3 最终：
pip install langchain  langchain-openai python-dotenv
# pip install langchain==1.2.9
# 4 查看最新版本--》学这个课程同学，后期langchain 可能会更新
# 更新后，可能有的不一样--》99.9%是没问题--》python3.10 和python3.13 没有本质差距的
# LangChain 1.2 和 LangChain 1.3 没有本质差距的
# 但是 langChain 0.3.x 和 1.X有差距
# 像 python2.7和 python3.7 是有差距一样
# 如果更新了，建议同学学习的时候，也是用 1.2.9
import langchain
print(langchain.__version__)
# 1.2.9


# 4 同学们在看官方文档示例时
	-一般都是基于：claude 模型，openai   大模型写的示例
    -国内访问不了：claude ，openai--》可以用代理
    -没有代理--》我们会适配国产模型---》跟openai还是有点点差距的
    -我的示例都做好适配了--》如果大家从官方贴，可能运行不了

1.5 快速案例-不需要懂

# 1 用到  Agent，用到  tools，用到 models 模型--》这个案例使用了三个核心组件---》大家不懂，不重要--》能跑通即可

BASE_URL=http://127.0.0.1:11434/v1
API_KEY=ollama3
MODEL_NAME=qwen3-vl:2b

1.5.1 案例一：使用直接调用Models-也可以使用工具但是麻烦，后面讲

# 模型配置对接--》使用 openai 通用接口---》绝大部分大模型都支持 openai 通用接口
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os
load_dotenv()
llm=ChatOpenAI(
    model=os.getenv("MODEL_NAME"),
    api_key=os.getenv("API_KEY"),
    base_url=os.getenv("BASE_URL"),
)
if __name__ == '__main__':
    # 案例一：可以直接调用大模型---》非常像我们之前讲 Python对接大模型的代码
    # 邮件运行
    res=llm.invoke("中国的首都是哪里？")
    print(res.content)

1.5.2 案例二：使用Agent调用大模型-可以使用工具

.env01

BASE_URL=https://api.deepseek.com
API_KEY=sk-4a782de8e69b0
MODEL_NAME=deepseek-chat

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from dotenv import load_dotenv
import os
load_dotenv() # 调用 本地 ollama
# load_dotenv('.env01') # # 调用 远程deepseek
# llm=ChatOpenAI() # 写 这句会从环境变了拿--》环境变量又没有，连接不上，就报错了

llm=ChatOpenAI(
    model=os.getenv("MODEL_NAME"),
    api_key=os.getenv("API_KEY"),
    base_url=os.getenv("BASE_URL"),
)
# 1 写了一个工具--》查询天气--》没有具体实现，非常简单，传入城市，返回天气
# 要提供文档介绍，告诉大模型，这个工具干嘛用的
def get_weather(city: str) -> str:
    '''
    根据成城市名，返回城市的天气
    '''
    # 可以调用mcp--》得到结果
    return f"城市 {city}，今天天气很晴朗，没有风没有雨!"
# 2 对接本地ollama中的千问模型--》使用了OpenAI 通用接口
# 正常来讲要用：ChatOllama--》需要额外安装，后面会讲的
# 注意：.env01 配置改了后，对接的是远程 deepseek，就不是本地 ollama的千问了

# 3 创建 Agent，传入model对象

agent = create_agent(
    model=llm,
    tools=[get_weather], # 传入的工具
    system_prompt="你是一个有用的小助手", # 系统提示词
)

# 4 运行Agent，问问题
res=agent.invoke(
    {"messages": [{"role": "user", "content": "今天上海天气怎么样"}]}
)
# 5 底层也是多次调用--》只不过：LangChain封装好了
# 打印结果
print(res)

1.6 LangChain 整套体系

---------------重点核心部分---------------
# 1 LangChain核心组件之 Agents智能体
# 2 LangChain核心组件之 Models模型
# 3 LangChain核心组件之 Messages消息
# 4 LangChain核心组件之 Tools工具
# 5 LangChain核心组件之 Short-term memory短期记忆
# 6 LangChain核心组件之 Streaming流式传输
# 7 LangChain核心组件之Structured output 结构化输出
---------------高级应用部分---------------
# 8 LangChain高级之Middleware 中间件
# 9 LangChain高级之Guardrails 护栏
# 10 LangChain高级之runtime运行时
# 11 LangChain高级之Context engineering上下文工程
# 12 LangChain高级之Model Context Protocol (MCP)模型上下文协议
# 13 LangChain高级之 Human-in-the-loop 人机交互
# 14 LangChain高级之 Multi-agent 多智能体
# 15 LangChain高级之 Retrieval 检索
# 16 LangChain高级之 Long-term memory 长期记忆
--------------使用LangSmith-需要付费---------------------
# 17 LangSmith Studio
# 18 Test 测试
# 19 Agent 聊天用户界面
# 20 Deployment  部署
# 21 Observability 可观测性

2 LangChain核心组件之Agnents智能体

2.1 介绍

# 1  Agents 将 LLM与tools 结合，创建能够对任务进行推理、决定使用哪些工具并迭代寻求解决方案的系统。

# 2 create_agent 提供了一个生产就绪的 Agent 实现。
	-老版本：0.3 创建agent，有很多方式--》1.x版本，就这一个
    
    
# 3  LLM Agent 会循环运行工具以实现目标 。智能体运行直到满足停止条件——即模型输出最终输出或达到迭代极限


# 4 Agent中的知识点
	-核心组件
    	-模型
        -工具
        -System prompt 系统提示
    -调用
    -高级概念
    	-结构化输出
		-记忆
		-流式传输
		-中间件

2.2 核心组件

# 1 Model模型:大模型 LLM
	-Models 是 Agents的推理引擎。它可以通过多种方式指定，支持静态和动态模型
    -在LangChain运行过程中，支持变换：model
    	# 动态模型
            -第一个问题用了 deepseek
            -第二个问题用了 千问
        # 静态模型
        	-只有一个模型
# 2 工具：大模型 训练数据老，最新的没有。 不能获取实时：天气，今天的新闻
工具（函数）赋予智能体执行行动的能力。智能体超越了简单的仅模型工具绑定，实现了：
    序列中的多个工具调用（由单个提示触发）
    适当的并行工具调用
    基于先前结果的动态工具选择
    工具重试逻辑和错误处理
    工具调用之间的状态持久化
# 3 System prompt 系统提示
	-设定大模型的角色：系统提示词

2.2.1 Model模型

2.2.1.1 方式一：模型标识符‘字符串'

# Models 是 Agents 的推理引擎。它可以通过多种方式指定，支持静态和动态模型
## 1.1 方式一：模型标识符‘字符串'
# 1 导入：create_agent 1.x统一了agent的创建方式---》agent必须有模型---》对接模型
# 2 使用模型字符串方式：用的少：了解即可
from langchain.agents import create_agent
import os

from openai import api_key

# 3 把DEEPSEEK 的api-key放到环境变量中--》https://platform.deepseek.com/api_keys--》花钱购买
os.environ["DEEPSEEK_API_KEY"] = "sk-4a782de375c04ad5b62e08dfac8e69b0"
# 正常还要设置 base_url ，但是不用设置：langchain-deepseek 内置了
# 但是如果：openai:deepseek-chat，必须要设置 base_url，否则默认的base_url连接 openai，就连不上
# 4 模型字符串方式创建
# 格式：
'''
deepseek:deepseek-chat # 必须安装： pip install langchain-deepseek
openai:gpt-5          # 必须安装： pip install langchain-openai
openai:deepseek-chat  # 这样写也可以：不用langchain给某个大模型厂商开发的固定模块，统一使用openai爱的兼容接口
claude:claude-sonnet-4-5-2025092  -->直接写成 claude-sonnet-4-5-2025092 部分大模型也能识别，但是不好  pip install  langchain-anthropic
qianwen:qianwenvl-2B  # 支持这样写的模型，是固定的

# create_agent 没有api-key参数，没有base_url 参数，需要使用 os.environ["DEEPSEEK_API_KEY"]  设置到环境变量中，langchain自动读取环境变量
'''
agent = create_agent(
    model="deepseek:deepseek-chat", # 使用 deepseek 独立接口，需要装langchain-deepseek
    # model="openai:deepseek-chat", # 统一使用openai的兼容接口 ，需要装：langchain-openai
    # api_key='' # 写了就报错
)
res = agent.invoke({
    "messages": [{"role": "user", "content": "介绍一下自己？"}]
})
print(res)

2.2.1.2 方式二：模型对象【推荐】：更好的控制模型的参数--刚刚案例

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

# 1 创建模型--》指定很多参数：api_key，base_url，temperature？，最大上下文max_tokens，超时时间。。
# 便于更细力度控制模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
    temperature=0.1,
    max_tokens=1000,
    timeout=30
    # ...（其他参数），
)
# 2 创建智能体--》把上面创建的model传入即可--》传入对象
# agent = create_agent(model, tools=tools)
agent = create_agent(model)
res= agent.invoke({
    "messages": [{"role": "user", "content": "介绍一下自己？"}]
})
print(res)

# 注意：模型实例为您提供对配置的完全控制。当您需要设置特定参数，如 temperature、max_tokens、timeouts、base_url 和其他提供商特定设置时，请使用它们

2.2.2.3 动态模型-可以用字符串方式，可以用对象方式

# 1  运行时 根据当前 状态 和 上下文 进行选择。这支持复杂的路由逻辑和成本优化--使用中间件【还没学呢】控制

# 动态模型：运行时 根据当前 状态 和上下文进行选择。这支持复杂的路由逻辑和成本优化-使用中间件控制
from langchain_openai import ChatOpenAI
from langchain.agents import create_agent
from langchain.agents.middleware import wrap_model_call, ModelRequest, ModelResponse
import random
# 1 使用 对接模型方式二：对象方式
# 1.1 创建一个 deep_seek 模型
deep_seek = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)
# 1.1 创建一个 千问 模型 https://bailian.console.aliyun.com/cn-beijing/?spm=5176.12818093_47.resourceCenter.1.559c2cc9dVo9dq&tab=app#/api-key
qian_wen = ChatOpenAI(
    model="qwen-plus", # 对话大模型
    api_key="sk-6459007b813946289da12857950c955b",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 2 通过中间件控制：先不用特别理解--》内部控制选择使用哪个大模型
@wrap_model_call
def dynamic_model_selection(request: ModelRequest, handler) -> ModelResponse:
    """根据对话复杂性选择模型。"""
    # message_count = len(request.state["messages"])
    if random.choice([True, False]): # 逻辑是我们写的--》还可以根据不同问题，问题长度，选择使用不同模型message_count>10
        # 随机选择模型
        model = qian_wen
    else:
        model = deep_seek
    return handler(request.override(model=model)) # 替换模型

agent = create_agent(
    model=qian_wen,  # 默认模型选了千问,但在实际使用过程中，可能会用千问，可能会用deepseek--》我们控制的：中间件中
    middleware=[dynamic_model_selection]
)
for i in range(5):
    res= agent.invoke({
        "messages": [{"role": "user", "content": "介绍一下自己？"}]
    })
    print(res)

2.2.2 工具

#1  工具赋予智能体执行行动的能力。智能体超越了简单的仅模型工具绑定，实现了：【更多工具的详细知识，后面会讲】
    序列中的多个工具调用（由单个提示触发）
    适当的并行工具调用
    基于先前结果的动态工具选择
    工具重试逻辑和错误处理
    工具调用之间的状态持久化

from langchain.tools import tool
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
# 1 创建模型对接
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)
# 2 定义工具1 --》要带介绍--》不带介绍报错--》使用 @tool 装饰
@tool
def search(query: str) -> str:
    """搜索信息。"""
    return f"结果：{query}"
# 3 定义工具2
@tool
def get_weather(location: str) -> str:
    """获取位置的天气信息。"""
    return f"{location} 的天气：晴朗，温度23度,没有雨"

# 4 创建智能体：使用列表传入多个工具
agent = create_agent(model, tools=[search, get_weather])

res = agent.invoke({
    "messages": [{"role": "user", "content": "今天上海天气怎么样？"}]
})
print(res)

2.2.3 系统提示

# 1 可以通过提供提示来塑造你的Agent 处理任务的方式。system_prompt 参数可以作为字符串表示
	1 案例一：静态系统提示词
    2 案例二：动态系统提示

# 1 案例一：静态系统提示词

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
# 1 对接模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)
# 2 创建智能体---》就可以传入系统提示词
agent = create_agent(
    model,
    system_prompt="你是一个喜剧演员"  # 我们关注
)
# 3 调用大模型---》用户提示词--》先不关注
res = agent.invoke({
    "messages": [{"role": "user", "content": "你是谁？"}]
})
print(res)

# 2  案例二：动态系统提示
from typing import TypedDict
from langchain_openai import ChatOpenAI
from langchain.agents import create_agent
from langchain.agents.middleware import dynamic_prompt, ModelRequest


class Context(TypedDict):
    user_role: str


@dynamic_prompt
def user_role_prompt(request: ModelRequest) -> str:
    """根据用户角色生成系统提示。"""
    user_role = request.runtime.context.get("user_role", "user")
    base_prompt = "你是一个有帮助的助手。"
    if user_role == "expert":
        return f"{base_prompt} 提供详细的技术响应。"
    elif user_role == "beginner":
        return f"{base_prompt} 简单解释概念，避免使用行话。"

    return base_prompt


# 1 对接模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)
# 2 创建智能体
agent = create_agent(
    model=model,
    middleware=[user_role_prompt],  # 传入中间件
    context_schema=Context     # 传入上下文：承上启下  50集--》1---30--》直接看30集：演的剧情，你能看懂吗，因为没有上下文
)

# 3 调用智能体--》传入context--》通过context控制系统提示词是什么
# 系统提示将根据上下文动态设置：
# 如果是expert：系统提示词是：你是一个有帮助的助手，提供详细的技术响应
# 如果是beginner：系统提示词是：你是一个有帮助的助手，简单解释概念，避免使用行话
res = agent.invoke(
    {"messages": [{"role": "user", "content": "解释LangChain"}]},
    context={"user_role": "expert"}
)
print(res)
res = agent.invoke(
    {"messages": [{"role": "user", "content": "解释LangChain"}]},
    context={"user_role": "beginner"}
)
print(res)

2.3 调用

# 1 可以通过向其 State 传递更新来调用智能体。所有智能体在其状态中包含消息序列；要调用智能体，请传递一条新消息
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
    temperature=0.1,
    max_tokens=1000,
    timeout=30
    # ...（其他参数）
)
agent = create_agent(model)

#### 调用--》传入用户提示词--》message---》message会详细讲
res= agent.invoke({
    "messages": [{"role": "user", "content": "介绍一下自己？"}]
})
print(res)

2.4 高级概念

2.4.1 结构化输出

# 1 后续：LangChain核心组件之Structured output 结构化输出 会详细讲，在这先看一下
    -本来直接返回字符串
    -规定返回对象，字典。。。
    -用途很重要：它输出的结果后续可能会对接其他平台，使用json格式或对象格式，更方便对接
    
# 案例1 ：ToolStrategy实现--》绝大部分模型支持

# 案例2：ProviderStrategy实现---》需要大模型支持，部分大模型不支持

# 案例1 ：ToolStrategy实现--》大模型都支持
# 1 ToolStrategy 使用人工工具调用生成结构化输出。这适用于任何支持工具调用的模型
from pydantic import BaseModel
from langchain.agents import create_agent
from langchain.agents.structured_output import ToolStrategy
from langchain_openai import ChatOpenAI
# 1 对接大模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)

# 3 创建一个类：三个属性 name，email，QQ --》大模型返回的格式--》返回 ContactInfo 的对象格式
class ContactInfo(BaseModel):  # pydantic python中类型标注
    name: str
    email: str
    QQ: str

# 2 创建智能体：response_format 响应格式--》ToolStrategy包了个类
agent = create_agent(
    model=model,
    response_format=ToolStrategy(ContactInfo)
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "从以下内容提取联系信息: LiuQingzheng, liuqingzheng2020@163.com.com, 306334678"}]
})

print(result["structured_response"])

# 案例2：ProviderStrategy实现---》需要大模型支持，部分大模型不支持
# 2 ProviderStrategy 使用模型提供商的原生结构化输出生成。这更可靠，但仅适用于支持原生结构化输出的提供商（例如deepseek不支持，千问支持）
from pydantic import BaseModel
from langchain.agents import create_agent
from langchain.agents.structured_output import ProviderStrategy
from langchain_openai import ChatOpenAI
# deepseek-chat 不支持会报错
# model = ChatOpenAI(
#     model="deepseek-chat",
#     api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
#     base_url="https://api.deepseek.com",
# )
# qwen-plus 支持,不会报错
model = ChatOpenAI(
    model="qwen-plus",
    api_key="sk-6459007b813946289da12857950c955b",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

class ContactInfo(BaseModel):
    name: str
    email: str
    QQ: str

# 使用 ProviderStrategy--》得看模型是否支持
agent = create_agent(
    model=model,
    response_format=ProviderStrategy(ContactInfo)
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "从以下内容提取联系信息: LiuQingzheng, liuqingzheng2020@163.com.com, 306334678"}]
})

print(result["structured_response"])

2.4.2 记忆

# 1 Short-term memory短期记忆
# 2 Long-term memory 长期记忆 
----后续会详细讲---只是演示短期记忆的使用--了解即可----

############ 记忆介绍###############
# 1 智能体通过消息状态自动维护对话历史。还可以配置智能体使用自定义状态模式，在对话期间记住【额外信息】。
# 2 存储在状态中的信息可以被视为智能体的短期记忆
	-对话过程中存储一些变量：可以在对话过程中取出使用--》短期记忆
##### 案例： 对话期间记住【额外信息】
# 3 自定义状态模式必须扩展 AgentState 作为 TypedDict。
	## 定义自定义状态有两种方式：
        通过 中间件（推荐）：可以使用的范围更广
        通过 create_agent 上的 state_schema
    ## 注意
    	推荐通过中间件定义自定义状态，而不是通过 create_agent 上的 state_schema，因为它允许您将状态扩展概念上限定在相关中间件和工具的范围内。

# 1 案例一：中间件 方式 实现 对话期间记住【额外信息】
# 1 当自定义状态需要被特定中间件钩子和附加到该中间件的工具访问时，使用中间件定义自定义状态
from langchain.agents import AgentState
from langchain.agents.middleware import AgentMiddleware
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from typing import Any
# 1 连接模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)
class CustomState(AgentState):
    user_preferences: dict

class CustomMiddleware(AgentMiddleware):
    state_schema = CustomState
    def before_model(self, state: CustomState, runtime) -> dict[str, Any] | None:
        # 中间件，进入model对话之前--》取到额外信息
        # 还可以在工具中--》取到额外信息--》没写案例，下个案例会有
        print(state.get('user_preferences').get("username"))
        print(state.get('user_preferences').get("age"))

# 2 创建智能体--》目标：在对话过程中，记住额外信息--》使用中间件
agent = create_agent(
    model,
    middleware=[CustomMiddleware()]
)

# 3 调用模型，对话
# 智能体现在可以跟踪消息之外的额外状态
result = agent.invoke({
    "messages": [{"role": "user", "content": "介绍一下自己"}],
    "user_preferences": {"username": "liuqingzheng", "age": "19"}, # 这个不是消息，是额外信息--》想在对话过程中使用：中间件，调用工具 都可以拿到这个额外信息
})
print(result)

# 2 方式二：state_schema 方式实现 对话期间记住【额外信息】-->工具中获取
# state_schema 缺陷在于--》无法像使用中间件方式 在流程的更多位置获取

# 使用 state_schema 参数作为快捷方式，定义仅在工具中使用的自定义状态。
from langchain.agents import AgentState
from langchain.tools import tool, ToolRuntime
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langchain.tools import tool
# 1 对接模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)
class CustomState(AgentState):
    user_preferences: dict

@tool
def get_weather(location: str,runtime: ToolRuntime) -> str:
    """获取位置的天气信息。"""
    print(runtime.state["user_preferences"])
    return f"{location} 的天气：晴朗，温度23度,没有雨"

# 2 创建智能体--》通过中间件可以在进入模型对话前拿到额外信息
# 这个案例是在工具中拿到 额外信息
agent = create_agent(
    model,
    tools=[get_weather],
    state_schema=CustomState
)

# 智能体现在可以跟踪消息之外的额外状态
result = agent.invoke({
    "messages": [{"role": "user", "content": "今天上海天气如何?"}],
    "user_preferences": {"username": "liuqingzheng", "age": "19"},
})
print(result)

2.4.3 流式传输

# 1 原来都是一次性返回
# 2 可以像打字机一样，一个个token返回

from langchain_openai import ChatOpenAI
from langchain.agents import create_agent
from langchain.tools import tool
# 1 对接模型
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)

# 2 定义工具
@tool
def search(query: str) -> str:
    """搜索信息。"""
    return f"结果：{query}"


@tool
def get_weather(location: str) -> str:
    """获取位置的天气信息。"""
    return f"{location} 的天气：晴朗，温度23度,没有雨"

# 3 创建智能体
agent = create_agent(
    model,
    tools=[search, get_weather]
)

# 4 原来调用是：agent.invoke--》会一次性返回
# 现在用：agent.stream--》流式返回--》返回一点，打印一点，有调工具，也返回
for chunk in agent.stream({
    "messages": [{"role": "user", "content": "今天北京天气怎么样?"}]}, stream_mode="values"):
    # 每个块包含该时间点的完整状态
    latest_message = chunk["messages"][-1]
    if latest_message.content:
        print(f"智能体：{latest_message.content}")
    elif latest_message.tool_calls:
        print(f"正在调用工具：{[tc['name'] for tc in latest_message.tool_calls]}")

2.4.4 中间件[介绍]

# 0 钩子函数： 面相切面变成 AOP

# 1 中间件 为在执行的不同阶段自定义智能体行为提供了强大的扩展性。您可以使用中间件来：
    在调用模型之前处理状态（例如消息裁剪、上下文注入）
    修改或验证模型的响应（例如防护栏、内容过滤）
    使用自定义逻辑处理工具执行错误
    基于状态或上下文实现动态模型选择
    添加自定义日志、监控或分析
    中间件无缝集成到智能体的执行图中，允许您在关键点拦截和修改数据流，而无需更改核心智能体逻辑
    
    
# 2 有些装饰器
	@before_model、@after_model 和 @wrap_tool_call

3 LangChain核心组件之Models模型

# 1 大语言模型（LLMs） 是强大的 AI 工具，能够像人类一样理解和生成文本。它们用途广泛，可用于撰写内容、翻译语言、总结信息和回答问题，而无需针对每项任务进行专门训练
	-DeeepSeek
    -千问
    -火山方舟
    -openai
    。。。。
    
# 2 除了文本生成之外，许多模型还支持： 文本模型，多模态模型：图片理解，图片生成，视频生成。。。	
    工具调用 - 调用外部工具（如数据库查询或 API 调用）并将结果用于响应中。
    结构化输出 - 模型的响应被限制为遵循定义的格式。
    多模态 - 处理和返回非文本数据，如图像、音频和视频。
    推理 - 模型执行多步推理以得出结论。
    模型是 Agent 的推理引擎。它们驱动Agent的决策过程，决定调用哪些工具、如何解释结果以及何时提供最终答案。
    
# 3  选择的模型的质量和能力直接影响Agent的可靠性和性能【本地小B模型】。不同模型在不同任务上表现出色——有些更擅长遵循复杂指令，有些更擅长结构化推理，有些支持更大的上下文窗口以处理更多信息。

# 4 LangChain 的标准模型接口为您提供对众多不同提供商集成的访问，这使得实验和切换模型以找到最适合您用例的模型变得非常容易
	-支持市面上绝大多数大模型
    
# 5 基本用法-模型可以通过两种方式使用：
    1 与Agent一起使用[上面一直在讲] - 创建代理时可动态指定模型。
    2 独立使用【跟用openai通用接口一样】 - 模型可直接调用（在代理循环之外），用于文本生成、分类或提取等任务，而无需代理框架。 
    
    
# 6 支持的模型
	-主流支持：会随着LangChain 版本更新，一起更新
		-https://docs.langchain.com/oss/python/integrations/providers/overview
    -支持所有：更新可能不会随着LangChain 版本更新，一起更新--》可能会慢
    	-https://docs.langchain.com/oss/python/integrations/providers/all_providers
            
    -绝大多数模型都支持：openai通用接口 ，所有，我们都用 langchain-openai 就可以了【有小差距的】
    
    
################### 这几种方式，没有本质区别################
# 7 对接deepseek：方式一
# pip install langchain_deepseek
from langchain_deepseek import ChatDeepSeek
model = ChatDeepSeek(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    #base_url="https://api.deepseek.com", # 自动识别deepseek的地址
)
# 8 对接deepseek：方式二 通用openai
# pip install langchain_openai
from langchain_openai import ChatOpenAI
model = ChatOpenAI(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)
# 9 对接deepseek：方式三  init_chat_model---》不区分厂商--》根据model名字自适应
from langchain.chat_models import init_chat_model
model = init_chat_model(
    model="deepseek-chat",
    api_key="sk-4a782de375c04ad5b62e08dfac8e69b0",
    base_url="https://api.deepseek.com",
)

####################### 对接千问：三种方式？只有两种，init_chat_model不支持--》不能自适应千问--》################
#方式一：openai方式
from langchain_openai import ChatOpenAI
model = ChatOpenAI(
    model="qwen-vl-max",
    api_key="sk-6459007b813946289da12857950c955b",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 方式二：langchain 官方community 包下的适配器
# pip install langchain-community    # 包含千问的集成适配器
# pip install dashscope              # 千问的sdk
from langchain_community.chat_models import ChatTongyi
# ChatDeepSeek 等同于 ChatTongyi
model = ChatTongyi (
    model="qwen-vl-max", # 多模态模型
    # model="qwen-image-max", # 文生图模型,但是不支持
    api_key="sk-6459007b813946289da12857950c955b",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)

# 方式三：init_chat_model 目前不行
# 因为：init_chat_model 会根据模型自适应
# -deepseek-chat 会自适应成 ChatDeepSeek：官方维护的
# -qwen-vl-max 会自适应成 ChatTongyi ？ 不能 因为是社区维护的--》更新慢
from langchain.chat_models import init_chat_model
model = init_chat_model(
    model="qwen-vl-max",
    api_key="sk-6459007b813946289da12857950c955b",
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
)