模型的创建与调用

pip install -r .\requirements.txt

#安装ChatOpenAI依赖包 
pip install langchain-openai 
#安装ChatDeepSeek 依赖包 
pip install langchain-deepseek 
# 用于环境管理的包 
pip install python-dotenv

DEEPSEEK_API_KEY=<Your API Key> 
DEEPSEEK_BASE_URL=https://api.deepseek.com

from langchain_deepseek import ChatDeepSeek 
import os 
from dotenv import load_dotenv 
# 通过load_dotenv()将.env中的变量加载为环境变量
# override=True表示：无论你当前的操作系统、终端或者虚拟环境中是否已经存在同名的环境变量， 都会强行用.env 文件里写的值去覆盖它
load_dotenv(override=True) 
# 从环境变量读取配置
DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL")
# 创建DeepSeek LLM
deepseek_llm = ChatDeepSeek(
    api_key=DEEPSEEK_API_KEY,
    api_base=DEEPSEEK_BASE_URL, # 注意：这里是api_base，不是base_url
    model_name="deepseek-v4-flash",
)
print(deepseek_llm.invoke("请介绍一下你自己"))

from langchain_deepseek import ChatDeepSeek
# 创建DeepSeek LLM
deepseek_llm = ChatDeepSeek(
    model="deepseek-v4-flash",
)
print(deepseek_llm.invoke("请介绍一下你自己"))

from langchain_deepseek import ChatDeepSeek
# 创建DeepSeek LLM
deepseek_llm = ChatDeepSeek(
    api_key="sk-2nkIWkv6M...U1Ra4P0NGa", # 明文暴露密钥
    api_base="https://api.deepseek.com",
    model="deepseek-v4-flash",
)
print(deepseek_llm.invoke("请介绍一下你自己"))

# 安装 Langchain 社区依赖包，包含ChatHunyuan、ChatTongyi、ChatZhipuAI 
pip install langchain-community 
# ChatZhipuAI / 智谱 AI 认证相关依赖 
pip install pyjwt

ZHIPUAI_API_KEY=<Your API Key>
ZHIPUAI_BASE_URL=https://open.bigmodel.cn/api/paas/v4/chat/completions

from langchain_community.chat_models import ChatZhipuAI
from dotenv import load_dotenv
import os
# override=True 确保.env文件优先
load_dotenv(override=True)
ZHIPUAI_API_KEY = os.getenv("ZHIPUAI_API_KEY")
ZHIPUAI_BASE_URL = os.getenv("ZHIPUAI_BASE_URL")
zhipu_llm = ChatZhipuAI(
    model="glm-4.7",
    api_base=ZHIPUAI_BASE_URL, #可选
    api_key=ZHIPUAI_API_KEY #可选
)
print(zhipu_llm.invoke("请介绍一下你自己"))

from langchain_community.chat_models import ChatZhipuAI
zhipu_llm = ChatZhipuAI(
    model="glm-4.7",
)
print(zhipu_llm.invoke("请介绍一下你自己"))

# ChatTongyi / 阿里通义千问依赖包 
pip install dashscope

DASHSCOPE_API_KEY=<Your API Key>

import os
from langchain_community.chat_models import ChatTongyi
from dotenv import load_dotenv
# override=True 确保.env文件优先
load_dotenv(override=True)
DASHSCOPE_API_KEY = os.getenv("DASHSCOPE_API_KEY")
tongyi_llm = ChatTongyi(
    api_key=DASHSCOPE_API_KEY,
    model="qwen3-max",
)
print(tongyi_llm.invoke("请介绍一下你自己"))

from langchain_community.chat_models import ChatTongyi
tongyi_llm = ChatTongyi(
    model="qwen3-max",
)
print(tongyi_llm.invoke("请介绍一下你自己"))

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv(override=True)
DEEPSEEK_API_KEY=os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_BASE_URL=os.getenv("DEEPSEEK_BASE_URL")
llm_deepseek=ChatOpenAI(
    model="deepseek-v4-flash",
    api_key=DEEPSEEK_API_KEY,
    base_url=DEEPSEEK_BASE_URL,
)
print(llm_deepseek.invoke("1+1=?"))

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv(override=True)
ZHIPUAI_API_KEY=os.getenv("ZHIPUAI_API_KEY")
ZHIPUAI_BASE_URL=os.getenv("ZHIPUAI_BASE_URL")
llm_zhipuai=ChatOpenAI(
    model="glm-4.7",
    api_key=ZHIPUAI_API_KEY,
    base_url=ZHIPUAI_BASE_URL,
)
print(llm_zhipuai.invoke("1+1=?"))

# OpenRouter 模型集成
pip install langchain-openrouter

OPENROUTER_API_KEY=<YOUR_API_KEY>
OPENROUTER_API_BASE=https://openrouter.ai/api/v1

from langchain_openrouter import ChatOpenRouter
from dotenv import load_dotenv
import os
load_dotenv(override=True)
OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY") 
# OPENROUTER_API_BASE = os.getenv("OPENROUTER_API_BASE") 
model = ChatOpenRouter(
    model="deepseek/deepseek-v4-flash",
    api_key=OPENROUTER_API_KEY,
    # base_url=OPENROUTER_API_BASE,
)
print(model.invoke("一句话介绍下你自己"))

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
import os
load_dotenv(override=True)
OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
OPENROUTER_API_BASE = os.getenv("OPENROUTER_API_BASE")
model = ChatOpenAI(
    model="deepseek/deepseek-v4-flash",
    api_key=OPENROUTER_API_KEY,
    base_url=OPENROUTER_API_BASE,
)
print(model.invoke("一句话介绍下你自己"))

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
import os
load_dotenv(override=True)
CLOSEAI_API_KEY = os.getenv("CLOSEAI_API_KEY")
CLOSEAI_BASE_URL = os.getenv("CLOSEAI_BASE_URL")
model = ChatOpenAI(
    # model="gpt-5-mini",
    model="deepseek-v4-flash",
    api_key=CLOSEAI_API_KEY,
    base_url=CLOSEAI_BASE_URL,
)
print(model.invoke("欧盟都有哪些国家"))

from langchain.chat_models import init_chat_model
model = init_chat_model(
    "provider:model_name", # 提供商:模型名称
    api_key="your-api-key", # API 密钥（可选，可从环境变量读取）
    temperature=0.7, # 温度参数（可选）
    max_tokens=1000, # 最大 token 数（可选）
    **kwargs # 其他模型特定参数
)

import os
from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
# 从.env文件中加载环境变量
load_dotenv(override=True)
# 从环境变量读取配置
DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL")
model = init_chat_model(#model="deepseek-v4-flash",
                        #model_provider="deepseek", # 进入init_chat_model可以查看参数范围
                        model="deepseek:deepseek-v4-flash"
                        api_key=DEEPSEEK_API_KEY,
                        base_url=DEEPSEEK_BASE_URL)
# 向模型发送单条数据
response = model.invoke("你好，用一句话回答")
# 打印响应
print(response)

DASHSCOPE_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
DASHSCOPE_API_KEY=<YOUR_API_KEY>

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os
load_dotenv(override=True)
DASHSCOPE_API_KEY=os.getenv("DASHSCOPE_API_KEY")
DASHSCOPE_BASE_URL=os.getenv("DASHSCOPE_BASE_URL")
model = init_chat_model(model="qwen3-max",
                        model_provider="openai",
                        api_key=DASHSCOPE_API_KEY,
                        base_url=DASHSCOPE_BASE_URL)
print(model.invoke("你好，用一句话回答"))

CLOSEAI_API_KEY=<YOUR_API_KEY>
CLOSEAI_BASE_URL=https://api.openai-proxy.org/v1

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os
load_dotenv(override=True)
CLOSEAI_API_KEY=os.getenv("CLOSEAI_API_KEY")
CLOSEAI_BASE_URL=os.getenv("CLOSEAI_BASE_URL")
model = init_chat_model(model="deepseek-v4-flash",
                        model_provider="openai",
                        api_key=CLOSEAI_API_KEY,
                        base_url=CLOSEAI_BASE_URL)
print(model.invoke("你好，用一句话回答"))

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os

load_dotenv(override=True)
model_llm = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="deepseek",
    temperature=0,
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
print(model_llm.invoke("帮我写一首关于春天的七言绝句").content)

《七绝·春》
暄风一夜入庭除，桃李纷披柳眼疏。
燕啄芹泥争旧垒，春光何处不清书？

注：我的诗中，“暄风”暗合春信，“柳眼疏”点染初春萌态。后两句借燕啄芹泥的动景与“春光清书”的静观相映成趣，末句以反问收束，既赞春色无死角，又暗喻天地如卷、万象皆可品读的哲思。通篇未着“春”字却句句含春机，足见匠心。

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os

load_dotenv(override=True)
model_llm = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="deepseek",
    temperature=1.9,
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
print(model_llm.invoke("帮我写一首关于春天的七言绝句").content)

《七绝·春思》
移花才发两三枝，又恐风来花暗落。
不见游蜂采蜜时，雕梁独坐春风薄。

注：我的诗作《七绝·春思》通过细腻的笔触描绘春天的微妙变化。首句“移花才发两三枝”暗示春意初萌，次句“又恐风来花暗落”以担忧口吻道出对春光易逝的敏感。后两句借“游蜂采蜜”与“雕梁独坐”的对比，既展现春天本应热闹的生机，又反衬出孤寂者对春光的独特感受，在传统伤春题材中注入现代性的孤独感。

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os
# 从.env文件中加载环境变量
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="deepseek",
    temperature=0,
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
# 向模型发送单条数据
response = model.invoke("张三，男，30岁，拥有8年编程开发经验，目前在某互联网大厂担任技术专家。帮我从上文中提取数据，返回JSON格式")
print(response.content)

{"name": "张三", "gender": "男", "age": 30, "experience_years": 8, "position": "技术专家", "company": "某互联网大厂"}

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os
# 从.env文件中加载环境变量
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="deepseek",
    temperature=1.5,
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
# 向模型发送单条数据
response = model.invoke("请为一款极致静音的机械键盘写3个充满诗意且极具张力的广告语。")
print(response.content)

好的，为你创作了三款关于极致静音机械键盘的广告语，希望能引发共鸣：

### 1. **无声的雷霆**
> **指尖落下，是无声的雷霆；**
> **唯有灵感，在寂静中炸裂。**

### 2. **战车的静默**
> **告别键盘的喧嚣，唤醒直觉的轰鸣。**
> **让我，做你凌晨四点的战车，**
> **在无人知晓的战场上，永动前行。**

### 3. **宇宙的坍缩**
> **每一次敲击，都是指尖的宇宙坍缩。**
> **千钧之力，化作一场寂静的诗篇。**

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os
# 从.env文件中加载环境变量
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="deepseek",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
    max_tokens=15,
)
# 向模型发送单条数据
print(model.invoke("请介绍你自己"))

content='' additional_kwargs={'refusal': None, 'reasoning_content': '好的，用户让我介绍自己。这是一个非常常见且直接的问题。我需要'} response_metadata={'token_usage': {'completion_tokens': 15, 'prompt_tokens': 7, 'total_tokens': 22, 'completion_tokens_details': {'accepted_prediction_tokens': None, 'audio_tokens': None, 'reasoning_tokens': 15, 'rejected_prediction_tokens': None}, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 7}, 'model_provider': 'deepseek', 'model_name': 'deepseek-v4-flash', 'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402', 'id': 'ddb205af-8a53-4e8d-b976-b615f62829b5', 'finish_reason': 'length', 'logprobs': None} id='lc_run--019f99ac-56be-7d00-a592-c6676b9d98a6-0' tool_calls=[] invalid_tool_calls=[] usage_metadata={'input_tokens': 7, 'output_tokens': 15, 'total_tokens': 22, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 15}}

#pip install langchain-ollama
pip install -qU langchain-ollama
pip install -U ollama

from langchain_ollama import ChatOllama

model = ChatOllama(
    model="qwen3.5:0.8b",
    #如果Ollama在本地默认端口运行，则可省略，或使用http://localhost:11434
    base_url="http://localhost:11434",
)
print(model.invoke("一句话介绍一下你自己"))

content='我是人工智能助手，致力于为用户提供准确、高效的解答和服务。' additional_kwargs={} response_metadata={'model': 'qwen3.5:0.8b', 'created_at': '2026-07-27T01:00:01.0663671Z', 'done': True, 'done_reason': 'stop', 'total_duration': 124127732100, 'load_duration': 2176758600, 'prompt_eval_count': 13, 'prompt_eval_duration': 105496300, 'eval_count': 2785, 'eval_duration': 120608456400, 'logprobs': None, 'model_name': 'qwen3.5:0.8b', 'model_provider': 'ollama'} id='lc_run--019fa114-19c6-7011-af10-6bd70990863d-0' tool_calls=[] invalid_tool_calls=[] usage_metadata={'input_tokens': 13, 'output_tokens': 2785, 'total_tokens': 2798}

from langchain.chat_models import init_chat_model

model = init_chat_model(
    model="qwen3.5:0.8b",
    model_provider="ollama",
    #如果Ollama在本地默认端口运行，则可省略，或使用http://localhost:11434
    base_url="http://localhost:11434",
)
print(model.invoke("一句话介绍一下你自己"))

content='你好！我是 Qwen3.5，阿里巴巴集团研发的超智能助手，专注于为您提供高质量解答。' additional_kwargs={} response_metadata={'model': 'qwen3.5:0.8b', 'created_at': '2026-07-27T01:20:22.4013713Z', 'done': True, 'done_reason': 'stop', 'total_duration': 120418948400, 'load_duration': 3484715500, 'prompt_eval_count': 13, 'prompt_eval_duration': 134080200, 'eval_count': 2741, 'eval_duration': 115750052200, 'logprobs': None, 'model_name': 'qwen3.5:0.8b', 'model_provider': 'ollama'} id='lc_run--019fa126-cb1b-7ad3-b29d-8f344437b642-0' tool_calls=[] invalid_tool_calls=[] usage_metadata={'input_tokens': 13, 'output_tokens': 2741, 'total_tokens': 2754}

response = model.invoke(input, config=None)

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
prompt="翻译成英文：你好世界"
print(model.invoke(prompt))

messages = [
    {"role": "system", "content": "系统提示"},
    {"role": "user", "content": "用户消息"},
    {"role": "assistant", "content": "AI回复"}, # 可选，用于对话历史
    {"role": "user", "content": "继续提问"}
]

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
messages = [
    {"role":"system","content":"你是小默的私人助手，负责回复小默的私人问题，比如小默的age=21，sex=boy，birth=20061111"},
    {"role":"user","content":"你老板多大了？"}
]
print(model.invoke(messages).content)

我的老板就是你呀！你之前告诉我你今年21岁，所以你的年龄是21岁～ 😄

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
messages = [
    {"role":"system","content":"你是小默的私人助手，负责回复小默的私人问题，比如小默的age=21，sex=boy，birth=20061111"},
    {"role":"user","content":"你老板多大了？"},
    {"role": "assistant", "content": "我的老板就是你呀！你之前告诉我你今年21岁，所以你的年龄是21岁～"},
    {"role":"user","content":"我刚刚问了什么？"}
]
print(model.invoke(messages).content)

你刚刚问的是：“你老板多大了？” 😄

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)

messages1 = [
    {"role":"system","content":"你是友好的私人助手"},
    {"role":"user","content":"我的名字叫小默"}
]
print("AI回复1：",model.invoke(messages1).content)

messages2 = [
    {"role":"system","content":"你是友好的私人助手"},
    {"role":"user","content":"我叫什么名字？"}
]
print("AI回复2：",model.invoke(messages2).content)

AI回复1： 你好呀，小默！很高兴认识你！😊 有什么需要我帮忙的吗？可以随便聊聊，也可以告诉我你想做什么，我会尽力帮你解答～
AI回复2： 很抱歉，目前我并不知道您的名字哦！您还没有告诉我呢～可以悄悄告诉我您叫什么吗？😊

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
# 第一次对话
conversation = [
    {"role":"system","content":"你是友好的私人助手"},
    {"role":"user","content":"我的名字叫小默"}
]
response1 = model.invoke(conversation)
print("AI回复1：",response1.content)
# 添加记忆
conversation.append({"role": "assistant", "content":response1.content})
# 第二次对话
conversation.append({"role": "user", "content":"我叫什么名字？"})
print("AI回复2：",model.invoke(conversation).content)

AI回复1： 小默你好！很高兴认识你！😊 我是你的私人助手，名字你可以随便叫。有什么需要帮忙的，随时告诉我哦～你最近在忙些什么呢？
AI回复2： 啊，你叫小默呀！刚才你告诉我了，我记得呢～😊 不过如果还有其他想让我称呼的名字，随时告诉我哦！

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.messages import SystemMessage, HumanMessage

load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)

messages = [
    SystemMessage(content="你是小默的私人助手，负责回复小默的私人问题，比如小默的age=21，sex=boy，birth=20061111"),
    HumanMessage(content="小默今年多大了？")
]
print(model.invoke(messages).content)

小默今年21岁啦！

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage

load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)

# 第一次对话
messages = [
    SystemMessage(content="你是友好的私人助手"),
    HumanMessage(content="我的名字叫小默")
]
response1 = model.invoke(messages)
print(f"AI回复1：{response1.content}")
# 添加记忆
messages.append(AIMessage(response1.content))
# 第二次对话
messages.append(HumanMessage("我的名字叫什么？"))
print(f"AI回复2：{model.invoke(messages).content}")

AI回复1：你好，小默！很高兴认识你。我是你的私人助手，随时准备帮助你解答问题、提供建议或完成日常任务。请随时告诉我你的需求，无论是生活琐事、工作学习还是其他任何方面，我都会尽力提供支持。需要我为你做些什么吗？ 😊
AI回复2：你的名字叫小默呀！(◠‿◠) 刚刚你告诉过我的～需要我帮你做些什么吗？

AIMessage(
    # ====================== 核心应答内容 ======================
    content='2 + 3 * 2 = **8**',

    # 附加参数：拒绝标识，None=正常作答，未触发安全拦截
    additional_kwargs={
        'refusal': None
    },

    # ====================== API 原始响应元数据 ======================
    response_metadata={
        # Token 消耗统计
        'token_usage': {
            'completion_tokens': 15,        # 输出回答消耗Token
            'prompt_tokens': 16,             # 用户输入Prompt消耗Token
            'total_tokens': 31,              # 本次交互总消耗Token
            # 生成侧Token细分
            'completion_tokens_details': {
                'accepted_prediction_tokens': 0,
                'audio_tokens': 0,
                'reasoning_tokens': 0,       # 思考推理过程占用Token（推理模型生效）
                'rejected_prediction_tokens': 0
            },
            # 输入侧Token细分
            'prompt_tokens_details': {
                'audio_tokens': 0,
                'cached_tokens': 0           # 命中缓存Token数（缓存可降成本、提速）
            }
        },

        # 各阶段耗时监控（单位：毫秒 ms）
        'latency_checkpoint': {
            'engine_tbt_ms': 4,          # 引擎Token间平均间隔
            'engine_ttft_ms': 36,        # 引擎首个Token生成耗时
            'engine_ttlt_ms': 100,       # 引擎全部内容生成完毕耗时
            'pre_inference_ms': 86,      # 推理前预处理耗时：安全审核、分词、编码等
            'service_tbt_ms': 4,         # 服务端逐Token间隔，决定流式打字流畅度
            'service_ttft_ms': 280,      # 服务端收请求至输出首个字符总耗时
            'service_ttlt_ms': 338,      # 服务端完整回复输出总耗时
            'total_duration_ms': 259,    # 整条请求系统总运行时长
            'user_visible_ttft_ms': 194  # 用户肉眼感知到首个文字出现的等待时间
        },

        'model_provider': 'openai',                     # 模型厂商
        'model_name': 'gpt-5.4-mini-2026-03-17',        # 具体模型版本
        'system_fingerprint': None,                     # 后端配置指纹（追踪模型迭代变更）
        'id': 'chatcmpl-DgWobsxhDOqzjqVFwbZYKRnovpEiV', # OpenAI API 会话唯一ID
        'service_tier': 'default',                      # 服务套餐档位
        'finish_reason': 'stop',                        # 生成终止原因：stop=自然生成完毕
        'logprobs': None                                # 词汇对数概率（文本概率分析用）
    },

    # ====================== LangChain 框架内部属性 ======================
    id='lc_run--019e3659-5ee2-7b62-bc8a-741e27374b43-0', # LangChain 链路追踪ID

    # 工具调用记录
    tool_calls=[],                # 正常调用外部工具列表（本次无工具调用）
    invalid_tool_calls=[],        # 格式错误/调用失败的工具列表

    # LangChain 标准化Token用量元数据
    usage_metadata={
        'input_tokens': 16,
        'output_tokens': 15,
        'total_tokens': 31,
        'input_token_details': {
            'audio': 0,
            'cache_read': 0
        },
        'output_token_details': {
            'audio': 0,
            'reasoning': 0
        }
    }
)

AIMessage(
    # ====================== 核心应答内容 ======================
    content='2',

    # 附加参数：拒绝标识、思考过程文本
    additional_kwargs={
        'refusal': None,  # None表示正常回答，未触发安全策略拒绝输出
        'reasoning_content': 'We are asked: "1+1=?" This is a simple arithmetic question. The answer is 2. So I\'ll respond with the answer.'
    },

    # ====================== API 原始响应元数据 ======================
    response_metadata={
        # Token 消耗统计
        'token_usage': {
            'completion_tokens': 33,   # 输出回答整体消耗总Token数（包含推理思考+最终答案）
            'prompt_tokens': 8,        # 用户输入提示词消耗Token数
            'total_tokens': 41,        # 本次交互输入+输出合计消耗总Token
            # 输出端Token细分统计
            'completion_tokens_details': {
                'accepted_prediction_tokens': None,
                'audio_tokens': None,    # 音频生成消耗Token（本次无音频输出）
                'reasoning_tokens': 31,  # 模型内部推理思考过程占用的Token数量
                'rejected_prediction_tokens': None
            },
            # 输入端Token细分统计
            'prompt_tokens_details': {
                'audio_tokens': None,    # 输入内容不含音频，音频Token为None
                'cached_tokens': 0       # 未命中缓存输入文本，缓存读取Token数量为0
            },
            'prompt_cache_hit_tokens': 0,  # 提示词缓存命中条数
            'prompt_cache_miss_tokens': 8  # 提示词未命中缓存、需要重新编码计算的Token数
        },

        'model_provider': 'deepseek',      # 大模型服务商厂商
        'model_name': 'deepseek-v4-flash', # 调用的具体模型版本名称
        # 后端系统指纹，用于追踪模型配置、版本迭代变更
        'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402',  
        # API 请求维度唯一响应ID，用于日志排查溯源
        'id': 'a2bd2d25-eb52-47fc-b874-c1fafa59acc3',  
        'finish_reason': 'stop',   # 生成终止原因：stop=内容自然生成完毕，无截断/超限
        'logprobs': None           # 词汇对数概率，用于文本生成概率分析，本次未开启
    },

    # ====================== LangChain 框架内部属性 ======================
    # LangChain链路追踪唯一运行ID，调试链路使用
    id='lc_run--019fa635-36ae-7360-884e-c2d7d58ddf3a-0',  

    # 工具调用相关记录
    tool_calls=[],                # 本次交互未调用任何外部工具，工具调用列表为空
    invalid_tool_calls=[],        # 不存在格式错误、调用失败的无效工具调用

    # LangChain 框架标准化后的Token用量元数据
    usage_metadata={
        'input_tokens': 8,                     # 标准化输入Token总数
        'output_tokens': 33,                   # 标准化输出Token总数
        'total_tokens': 41,                    # 标准化合计总Token消耗
        'input_token_details': {
            'cache_read': 0                    # 输入侧读取缓存的Token数量
        },
        'output_token_details': {
            'reasoning': 31                    # 输出里推理思考过程占用Token数量
        }
    }
)

response = model.invoke("用一句话解释什么是 AI")
# 1. 获取回复内容
print("AI 回复:", response.content)
# 2. 获取响应元数据
metadata = response.response_metadata
print(f"使用的模型: {metadata['model_name']}")
print(f"结束原因: {metadata['finish_reason']}")
print(f"模型提供商：{metadata['model_provider']}\n")
# 3. 获取 Token 使用情况
usage = metadata.get('token_usage', {})
print(f"输入 tokens: {usage.get('prompt_tokens')}")
print(f"输出 tokens: {usage.get('completion_tokens')}")
print(f"总计 tokens: {usage.get('total_tokens')}")
# 4. 获取消息 ID
print(f"消息 ID: {response.id}")

AI 回复: AI（人工智能）就是让机器模拟人类的学习、推理、感知和决策等智能行为，使其能够像人一样“听、看、说、想”。
使用的模型: deepseek-v4-flash
结束原因: stop
模型提供商：deepseek

输入 tokens: 9
输出 tokens: 189
总计 tokens: 198
消息 ID: lc_run--019fa64f-9458-7b00-8e1a-8b795ecb0c29-0

import os
from dotenv import load_dotenv
from langchain_deepseek import ChatDeepSeek
load_dotenv(override=True)
model = ChatDeepSeek(
    model="deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
for chunk in model.stream("写一首七言律诗，总结大模型的发展"):
    print(chunk.text, end="", flush=True) # 逐Token输出

《咏大模型》
千亿参数隐玄机，数据为薪炼一炉。
破壁忽成通慧眼，隔空能作应声奴。
文生万象凭吞吐，理蕴百科任卷舒。
莫道今朝终局定，江山代有妙思出。

注：本诗以七律形式概括大模型发展历程。首联“千亿参数”点明规模特征，“炼一炉”喻训练过程；颔联“破壁”“隔空”对应跨模态与交互能力；颈联“吞吐”“卷舒”展现生成与推理能力；尾联以“终局”反思当前极限，借“江山代有”展望未来突破。全诗通过意象组合与技术隐喻，展现大模型从数据训练到智能涌现的演进图景。

import os
from dotenv import load_dotenv
from langchain_deepseek import ChatDeepSeek
load_dotenv(override=True)
model = ChatDeepSeek(
    model="deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
messages = [
    "一句话介绍你自己",
    "2+2*2=?",
    "中国国土面积多大？"
]
responses = model.batch(messages)
for response in responses:
    print(response.content)

我是DeepSeek，一个由深度求索公司创造的AI助手，致力于为你提供高效、准确的帮助。
The answer is 6, following the order of operations (multiplication before addition).
中国国土面积约为960万平方公里，包括陆地和水域面积。

import os
from dotenv import load_dotenv
from langchain_deepseek import ChatDeepSeek
load_dotenv(override=True)
model = ChatDeepSeek(
    model="deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
messages = [
    "一句话介绍你自己",
    "2+2*2=?",
    "中国国土面积多大？"
]
responses = model.batch_as_completed(messages)
for response in responses:
    print(response)

(1, AIMessage(content='The result of 2+2×2 is 6, following the order of operations (multiplication before addition).', additional_kwargs={'refusal': None, 'reasoning_content': 'We need to calculate 2+2*2. According to order of operations (PEMDAS/BODMAS), multiplication comes before addition. So 2*2 = 4, then 2+4 = 6. So answer is 6.'}, response_metadata={'token_usage': {'completion_tokens': 79, 'prompt_tokens': 10, 'total_tokens': 89, 'completion_tokens_details': {'accepted_prediction_tokens': None, 'audio_tokens': None, 'reasoning_tokens': 54, 'rejected_prediction_tokens': None}, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 10}, 'model_provider': 'deepseek', 'model_name': 'deepseek-v4-flash', 'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402', 'id': '707266ea-576f-4caa-9c5d-595fe4b46b08', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--019fa66a-fd5e-7310-92a2-2529dfd6356b-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 10, 'output_tokens': 79, 'total_tokens': 89, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 54}}))
(0, AIMessage(content='你好，我是DeepSeek，一个由深度求索公司创造的免费AI助手，擅长回答各种问题、处理文本任务、支持文件上传和长上下文对话，还能联网搜索帮助你获取最新信息！', additional_kwargs={'refusal': None, 'reasoning_content': '嗯，用户让我用一句话介绍自己。这是一个简单直接的请求。我需要用简洁、清晰的一句话概括我的核心身份和功能。我是DeepSeek，由深度求索公司创造的AI助手。我的主要特点是免费、文本处理、文件支持、长上下文以及联网搜索。把这些关键信息浓缩成一句话，保持流畅自然。'}, response_metadata={'token_usage': {'completion_tokens': 113, 'prompt_tokens': 7, 'total_tokens': 120, 'completion_tokens_details': {'accepted_prediction_tokens': None, 'audio_tokens': None, 'reasoning_tokens': 69, 'rejected_prediction_tokens': None}, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 7}, 'model_provider': 'deepseek', 'model_name': 'deepseek-v4-flash', 'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402', 'id': 'df7a27e4-e0fc-4283-98cb-92f73775c352', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--019fa66a-fd5c-74b0-873a-1d86cc68b720-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 7, 'output_tokens': 113, 'total_tokens': 120, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 69}}))
(2, AIMessage(content='中国的国土面积约为**960万平方公里**（陆地面积），位居世界第三。这一数据通常不包括领海面积。若加上管辖的海域面积（约470多万平方公里），中国的国土总面积则更为广阔。需要注意的是，不同统计口径下（如是否计入争议地区、内水等），具体数字可能存在细微差异，但“960万平方公里”是官方普遍引用的核心数据。', additional_kwargs={'refusal': None, 'reasoning_content': '嗯，用户问的是中国国土面积，这是一个基础且常见的地理知识问题。需要给出准确的数据，并且最好说明一下统计口径，因为不同来源（如陆地面积、加上领海等）的数据会略有差异。\n\n通常普遍引用的数据是约960万平方公里的陆地面积，这是中国官方公布的数值，也常见于教材和官方文件中。如果考虑管辖海域，面积会更大，但“国土面积”一般主要指陆地。所以回答时应该明确给出960万平方公里这个核心数字，并补充说明这是陆地总面积，不包括领海，以免用户混淆。\n\n另外，可以简洁提一下中国的地形特点或世界排名，但问题只要求面积，所以回答应聚焦在数据本身，避免过度展开。想到了直接给出数字，并说明其官方性和主要构成。'}, response_metadata={'token_usage': {'completion_tokens': 248, 'prompt_tokens': 9, 'total_tokens': 257, 'completion_tokens_details': {'accepted_prediction_tokens': None, 'audio_tokens': None, 'reasoning_tokens': 166, 'rejected_prediction_tokens': None}, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}, 'prompt_cache_hit_tokens': 0, 'prompt_cache_miss_tokens': 9}, 'model_provider': 'deepseek', 'model_name': 'deepseek-v4-flash', 'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402', 'id': '6c01136e-5829-4fe0-a425-cac90b8d74b1', 'finish_reason': 'stop', 'logprobs': None}, id='lc_run--019fa66a-fd5f-7ff3-a038-f633587235b6-0', tool_calls=[], invalid_tool_calls=[], usage_metadata={'input_tokens': 9, 'output_tokens': 248, 'total_tokens': 257, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 166}}))

import os
from dotenv import load_dotenv
from langchain_deepseek import ChatDeepSeek
load_dotenv(override=True)
model = ChatDeepSeek(
    model="deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
# 准备多个输入
inputs = [
    "翻译成英文：春天来了",
    "翻译成英文：夏天很热",
    "翻译成英文：秋天落叶",
    "翻译成英文：冬天下雪"
] 
# 批量调用（高效）
import time
start = time.time()
responses = model.batch(inputs)
batch_time = time.time() - start
print("批量调用结果：")
for i, response in enumerate(responses):
    print(f"{i+1}. {response.content}")
print(f"耗时: {batch_time:.2f}秒\n")

批量调用结果：
1. Spring has come.
2. Summer is very hot.
3. Autumn leaves falling
4. In winter, it snows.
耗时: 3.55秒

# 循环调用（低效，仅用于对比）
inputs = [
    "翻译成英文：春天来了",
    "翻译成英文：夏天很热",
    "翻译成英文：秋天落叶",
    "翻译成英文：冬天下雪"
]
start = time.time()
loop_responses = []
for inp in inputs:
    response = model.invoke(inp)
    loop_responses.append(response)
loop_time = time.time() - start
for i, response in enumerate(responses):
    print(f"{i+1}. {response.content}")
print(f"循环调用耗时: {loop_time:.2f}秒")
print(f"批量调用节省: {((loop_time - batch_time) / loop_time * 100):.1f}%")

1. Spring has come.
2. Summer is very hot.
3. Autumn leaves falling
4. In winter, it snows.
循环调用耗时: 6.03秒
批量调用节省: 41.0%

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os
import asyncio
import time
# 从.env文件中加载环境变量
load_dotenv(override=True)
DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL")
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=DEEPSEEK_API_KEY,
    base_url=DEEPSEEK_BASE_URL
)
async def demo_async_invoke():
    print("=== 演示：ainvoke 的异步（非阻塞）效果 ===")
    start_time = time.perf_counter()
    # 记录开始时间
    print("程序开始...")
    # 1. 创建任务 (Task)
    print(">>> 发起异步模型调用 (ainvoke)...")
    async_task = asyncio.create_task(model.ainvoke("用一句话解释人工智能。"))
    # 2. 并行执行其他任务
    print(">>> 模型请求已在后台发送，继续执行本地逻辑...")
    for i in range(3):
        await asyncio.sleep(1)
        # 使用异步等待，释放控制权
        print(f">>> 正在执行第{i + 1}个任务... (已耗时 {time.perf_counter() - start_time:.2f}s)")
    # 3. 获取模型结果
    print(">>> 本地任务完成，检查模型状态...")
    response = await async_task
    end_time = time.perf_counter()
    print(f">>> 模型返回: {response.content}")
    print(f"=== 总运行耗时: {end_time - start_time:.2f}s ===")
async def main():
    """主函数"""
    await demo_async_invoke()
if __name__ == "__main__":
    asyncio.run(main())

=== 演示：ainvoke 的异步（非阻塞）效果 ===
程序开始...
>>> 发起异步模型调用 (ainvoke)...
>>> 模型请求已在后台发送，继续执行本地逻辑...
>>> 正在执行第1个任务... (已耗时 1.00s)
>>> 正在执行第2个任务... (已耗时 2.01s)
>>> 正在执行第3个任务... (已耗时 3.02s)
>>> 本地任务完成，检查模型状态...
>>> 模型返回: 人工智能是让机器模拟人类智能的理论、方法和技术，使其能够学习、推理、感知和自主决策。
=== 总运行耗时: 3.02s ===

import asyncio
import os
from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import time

# 从.env文件中加载环境变量
load_dotenv(override=True)
DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL")
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=DEEPSEEK_API_KEY,
    base_url=DEEPSEEK_BASE_URL
)

async def demo_async_stream():
    """演示异步调用的非阻塞特性"""
    print("=== 演示：astream 的异步（非阻塞）效果 ===")
    start_time = time.perf_counter()  # 记录开始时间
    print("程序开始...")
    # 1. 发起异步流式请求
    # 注意：此时请求已发出，返回的是一个异步生成器
    print(">>> 发起异步流式调用 (astream)...")
    stream_resp = model.astream("请用一句话解释机器学习的基本概念。")
    # 2. 在等待流式响应的同时，执行其他任务
    print(">>> 流式请求已发送，程序无需等待，继续执行其他异步任务...")
    for i in range(3):
        # 使用 asyncio.sleep 而非 time.sleep
        # 这允许事件循环在等待时去处理上面的 stream_resp 网络 IO
        await asyncio.sleep(1)
        # print(f">>> 正在执行并发任务 {i + 1}... ")
        print(f">>> 正在执行第{i + 1}个任务... (已耗时 {time.perf_counter() - start_time:.2f}s)")
        # 3. 现在开始处理流式结果
    print(">>> 模拟任务已完成，开始读取缓冲区中的流式结果...")
    end_time = time.perf_counter()
    print(">>> 流式输出: ", end="", flush=True)
    async for chunk in stream_resp:
        # LangChain 的消息块通常通过 .content 获取内容
        content = chunk.content if hasattr(chunk, 'content') else str(chunk)
        print(content, end="", flush=True)
    print("\n>>> 流式输出结束\n")
    print(f"=== 总运行耗时: {end_time - start_time:.2f}s ===")

async def main():
    """主函数"""
    await demo_async_stream()

if __name__ == "__main__":
    asyncio.run(main())

=== 演示：astream 的异步（非阻塞）效果 ===
程序开始...
>>> 发起异步流式调用 (astream)...
>>> 流式请求已发送，程序无需等待，继续执行其他异步任务...
>>> 正在执行第1个任务... (已耗时 1.01s)
>>> 正在执行第2个任务... (已耗时 2.01s)
>>> 正在执行第3个任务... (已耗时 3.02s)
>>> 模拟任务已完成，开始读取缓冲区中的流式结果...
>>> 流式输出: 机器学习是通过让计算机从数据中自动发现模式并优化自身性能，而无需人为编写明确规则的方法。
>>> 流式输出结束

=== 总运行耗时: 3.02s ===

import asyncio
import os
from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import time
# 从.env文件中加载环境变量
load_dotenv(override=True)
DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL")
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=DEEPSEEK_API_KEY,
    base_url=DEEPSEEK_BASE_URL
)

async def demo_async_batch():
    """演示异步批量的非阻塞特性"""
    print("=== 演示：abatch 的异步（非阻塞）效果 ===")
    start_time = time.perf_counter() # 记录开始时间
    print("程序开始...")
    # 准备批量输入
    questions = ["用一句话说明深度学习与传统机器学习的区别", "中国首都在哪里？"]
    # 1. 发起异步批量请求
    # 关键修改：使用 create_task 让协程立即在后台执行
    print(">>> 发起异步批量调用 (abatch)...")
    batch_task = asyncio.create_task(model.abatch(questions))
    # 2. 在等待批量处理的同时，执行其他任务
    print(">>> 批量任务已在后台运行，主程序继续执行...")
    for i in range(3):
        # 关键修改：使用 asyncio.sleep 允许后台任务获取 CPU 时间片进行网络请求
        await asyncio.sleep(1)
        print(f">>> 正在执行第{i + 1}个任务... (已耗时 {time.perf_counter() - start_time:.2f}s)")
    # 3. 等待批量处理结果
    print(">>> 其他任务已完成，现在获取后台批量任务的结果...")
    # 此时 batch_task 可能已经完成，或者我们在这里等待它完成
    responses = await batch_task
    end_time = time.perf_counter()
    for response in responses:
        content = response.content if hasattr(response, 'content') else str(response)
        print(f">>> 响应内容: {content}")
    print(f"=== 总运行耗时: {end_time - start_time:.2f}s ===")
    
async def main():
    """主函数"""
    await demo_async_batch()
    
if __name__ == "__main__":
    asyncio.run(main())

=== 演示：abatch 的异步（非阻塞）效果 ===
程序开始...
>>> 发起异步批量调用 (abatch)...
>>> 批量任务已在后台运行，主程序继续执行...
>>> 正在执行第1个任务... (已耗时 1.01s)
>>> 正在执行第2个任务... (已耗时 2.02s)
>>> 正在执行第3个任务... (已耗时 3.03s)
>>> 其他任务已完成，现在获取后台批量任务的结果...
>>> 响应内容: 深度学习通过多层神经网络自动提取特征，而传统机器学习依赖人工设计的特征。
>>> 响应内容: 中国首都是北京。
=== 总运行耗时: 3.03s ===

try:
    response = model.invoke("Hello")
    print(response.content)
except ValueError as e:
    print(f"配置错误: {e}")
except ConnectionError as e:
    print(f"网络错误: {e}")
except Exception as e:
    print(f"未知错误: {e}")

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
messages = [
    {"role":"system","content":"你是小默的私人助手，负责回复小默的私人问题，比如小默的age=21，sex=boy，birth=20061111"},
    {"role":"user","content":"你老板多大了？"}
]
response = model.invoke(messages)
# 美化输出
response.pretty_print()

================================== Ai Message ==================================

我的老板小默今年21岁哦！

import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from rich import print as rprint
load_dotenv(override=True)
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL"),
)
messages = [
    {"role":"system","content":"你是小默的私人助手，负责回复小默的私人问题，比如小默的age=21，sex=boy，birth=20061111"},
    {"role":"user","content":"你老板多大了？"}
]
response = model.invoke(messages)
# 美化输出
rprint(response)

AIMessage(
    content='我的老板小默今年21岁。',
    additional_kwargs={
        'refusal': None,
        'reasoning_content': 
'我们已知小默的年龄是21岁。但用户问的是“你老板”，这里的“老板”可能是指小默自己（
因为我是小默的私人助手）。需要明确：我的老板就是小默。所以根据小默的age=21，直
接回答即可。'
    },
    response_metadata={
        'token_usage': {
            'completion_tokens': 67,
            'prompt_tokens': 41,
            'total_tokens': 108,
            'completion_tokens_details': {
                'accepted_prediction_tokens': None,
                'audio_tokens': None,
                'reasoning_tokens': 58,
                'rejected_prediction_tokens': None
            },
            'prompt_tokens_details': {
                'audio_tokens': None,
                'cached_tokens': 0
            },
            'prompt_cache_hit_tokens': 0,
            'prompt_cache_miss_tokens': 41
        },
        'model_provider': 'deepseek',
        'model_name': 'deepseek-v4-flash',
        'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402',
        'id': 'a395c1c4-7b1f-429d-802f-647b2e6df2fd',
        'finish_reason': 'stop',
        'logprobs': None
    },
    id='lc_run--019fa8ec-fc13-7950-b7bb-efd5620a3b8c-0',
    tool_calls=[],
    invalid_tool_calls=[],
    usage_metadata={
        'input_tokens': 41,
        'output_tokens': 67,
        'total_tokens': 108,
        'input_token_details': {'cache_read': 0},
        'output_token_details': {'reasoning': 58}
    }
)

from dotenv import load_dotenv
from langchain_deepseek import ChatDeepSeek
load_dotenv(override=True)

model = ChatDeepSeek(
    model="deepseek-v4-flash",
)

print(model.profile)

{}

from langchain_openrouter import ChatOpenRouter
from dotenv import load_dotenv
from rich import print as rprint
load_dotenv(override=True)
model = ChatOpenRouter(
    model="deepseek/deepseek-v4-flash",
    temperature=0.7,
    timeout=30,
    max_tokens=1000,
    max_retries=6
)
rprint(model.profile)

{
	'max_input_tokens': 163840,
	'max_output_tokens': 65536,
	'text_inputs': True,
	'image_inputs': False,
	'audio_inputs': False,
	'video_inputs': False,
	'text_outputs': True,
	'image_outputs': False,
	'audio_outputs': False,
	'video_outputs': False,
	'reasoning_output': True,
	'tool_calling': True,
	'structured_output': True
}

from langchain_deepseek import ChatDeepSeek

print(ChatDeepSeek.model_fields.keys())

dict_keys(['name', 'cache', 'verbose', 'callbacks', 'tags', 'metadata', 'custom_get_token_ids', 'rate_limiter', 'disable_streaming', 'output_version', 'profile', 'client', 'async_client', 'root_client', 'root_async_client', 'model_name', 'temperature', 'model_kwargs', 'openai_api_key', 'openai_api_base', 'openai_organization', 'openai_proxy', 'request_timeout', 'stream_usage', 'max_retries', 'presence_penalty', 'frequency_penalty', 'seed', 'logprobs', 'top_logprobs', 'logit_bias', 'streaming', 'n', 'top_p', 'max_tokens', 'reasoning_effort', 'reasoning', 'verbosity', 'tiktoken_model_name', 'default_headers', 'default_query', 'http_client', 'http_async_client', 'stop', 'extra_body', 'include_response_headers', 'disabled_params', 'context_management', 'include', 'service_tier', 'store', 'truncation', 'use_previous_response_id', 'use_responses_api', 'api_key', 'api_base'])

from langchain_openai import ChatOpenAI

print(ChatOpenAI.model_fields.keys())

dict_keys(['name', 'cache', 'verbose', 'callbacks', 'tags', 'metadata', 'custom_get_token_ids', 'rate_limiter', 'disable_streaming', 'output_version', 'profile', 'client', 'async_client', 'root_client', 'root_async_client', 'model_name', 'temperature', 'model_kwargs', 'openai_api_key', 'openai_api_base', 'openai_organization', 'openai_proxy', 'request_timeout', 'stream_usage', 'max_retries', 'presence_penalty', 'frequency_penalty', 'seed', 'logprobs', 'top_logprobs', 'logit_bias', 'streaming', 'n', 'top_p', 'max_tokens', 'reasoning_effort', 'reasoning', 'verbosity', 'tiktoken_model_name', 'default_headers', 'default_query', 'http_client', 'http_async_client', 'stop', 'extra_body', 'include_response_headers', 'disabled_params', 'context_management', 'include', 'service_tier', 'store', 'truncation', 'use_previous_response_id', 'use_responses_api'])

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
load_dotenv(override=True)
# 1. 实例化一个模型对象
model = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="deepseek",
)
# 2. 现在它已经是一个具体的ChatDeepSeek对象了
print(model.model_fields.keys())

dict_keys(['name', 'cache', 'verbose', 'callbacks', 'tags', 'metadata', 'custom_get_token_ids', 'rate_limiter', 'disable_streaming', 'output_version', 'profile', 'client', 'async_client', 'root_client', 'root_async_client', 'model_name', 'temperature', 'model_kwargs', 'openai_api_key', 'openai_api_base', 'openai_organization', 'openai_proxy', 'request_timeout', 'stream_usage', 'max_retries', 'presence_penalty', 'frequency_penalty', 'seed', 'logprobs', 'top_logprobs', 'logit_bias', 'streaming', 'n', 'top_p', 'max_tokens', 'reasoning_effort', 'reasoning', 'verbosity', 'tiktoken_model_name', 'default_headers', 'default_query', 'http_client', 'http_async_client', 'stop', 'extra_body', 'include_response_headers', 'disabled_params', 'context_management', 'include', 'service_tier', 'store', 'truncation', 'use_previous_response_id', 'use_responses_api', 'api_key', 'api_base'])

from langchain_deepseek import ChatDeepSeek
for name, field in ChatDeepSeek.model_fields.items():
    print(name)
    print(" annotation:", field.annotation)
    print(" default:", field.default)
    print(" description:", getattr(field, "description", None))
    print(" alias:", field.alias)
    print()

name
 annotation: str | None
 default: None
 description: None
 alias: None

cache
 annotation: langchain_core.caches.BaseCache | bool | None
 default: None
 description: None
 alias: None

verbose
 annotation: <class 'bool'>
 default: PydanticUndefined
 description: None
 alias: None

# 此处省略大量参数...

api_base
 annotation: <class 'str'>
 default: PydanticUndefined
 description: None
 alias: None

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
from rich import print as rprint

# 加载 .env 环境变量，重复变量强制覆盖
load_dotenv(override=True)

# 初始化 DeepSeek 对话大模型，并绑定天气查询工具
model = init_chat_model(
    model="deepseek:deepseek-v4-flash",
    model_kwargs={
        "tools": [
            {
                "type": "function",
                "function": {
                    "name": "get_weather",
                    "description": "Get weather of a location, the user should supply a location first.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "location": {
                                "type": "string",
                                "description": "The city and state, e.g. San Francisco, CA"
                            }
                        },
                        "required": ["location"]
                    }
                }
            }
        ]
    }
)

# 调用模型，提问查询北京今日天气
response = model.invoke("你好，今天北京的天气如何")

# 优雅打印模型完整返回结果
rprint(response)

AIMessage(
    content='你好！让我帮你查一下北京今天的天气情况。',
    additional_kwargs={
        'refusal': None,
        'reasoning_content': 
'用户想知道北京今天的天气。我可以使用get_weather工具来获取北京今天的天气信息。
让我调用这个工具。'
    },
    response_metadata={
        'token_usage': {
            'completion_tokens': 79,
            'prompt_tokens': 303,
            'total_tokens': 382,
            'completion_tokens_details': {
                'accepted_prediction_tokens': None,
                'audio_tokens': None,
                'reasoning_tokens': 24,
                'rejected_prediction_tokens': None
            },
            'prompt_tokens_details': {
                'audio_tokens': None,
                'cached_tokens': 0
            },
            'prompt_cache_hit_tokens': 0,
            'prompt_cache_miss_tokens': 303
        },
        'model_provider': 'deepseek',
        'model_name': 'deepseek-v4-flash',
        'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402',
        'id': '7eb8dcf6-c287-453a-a9f5-80fa916af027',
        'finish_reason': 'tool_calls',
        'logprobs': None
    },
    id='lc_run--019fab74-9962-70e3-aa2e-e96a9ff67596-0',
    tool_calls=[
        {
            'name': 'get_weather',
            'args': {'location': '北京'},
            'id': 'call_00_fTcw1tPCcejqUx6PEvwD5018',
            'type': 'tool_call'
        }
    ],
    invalid_tool_calls=[],
    usage_metadata={
        'input_tokens': 303,
        'output_tokens': 79,
        'total_tokens': 382,
        'input_token_details': {'cache_read': 0},
        'output_token_details': {'reasoning': 24}
    }
)

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
from rich import print as rprint
load_dotenv(override=True)
model = init_chat_model(
	model="deepseek:deepseek-v4-flash",
    extra_body={"thinking": {"type":"enabled"}},
)
rprint(model.invoke("你好，一句话回答"))

AIMessage(
    content='好的，请提问，我将用一句话回答您。',
    additional_kwargs={
        'refusal': None,
        'reasoning_content': 
'用户问的是“一句话回答”，要求非常明确：用一句话来回应。我需要给出一个直接、简洁
的答复，不能展开解释或添加多余内容。最简单的办法就是先确认用户的需求，然后表示
愿意配合。所以直接说“好的，请提问，我将用一句话回答您。”这样既符合指令，又为后
续对话做好了准备。'
    },
    response_metadata={
        'token_usage': {
            'completion_tokens': 85,
            'prompt_tokens': 8,
            'total_tokens': 93,
            'completion_tokens_details': {
                'accepted_prediction_tokens': None,
                'audio_tokens': None,
                'reasoning_tokens': 73,
                'rejected_prediction_tokens': None
            },
            'prompt_tokens_details': {
                'audio_tokens': None,
                'cached_tokens': 0
            },
            'prompt_cache_hit_tokens': 0,
            'prompt_cache_miss_tokens': 8
        },
        'model_provider': 'deepseek',
        'model_name': 'deepseek-v4-flash',
        'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402',
        'id': 'e01b7bb7-72b3-446a-b737-5dc83e420bb3',
        'finish_reason': 'stop',
        'logprobs': None
    },
    id='lc_run--019fab7d-42cd-7200-964a-7ff835878343-0',
    tool_calls=[],
    invalid_tool_calls=[],
    usage_metadata={
        'input_tokens': 8,
        'output_tokens': 85,
        'total_tokens': 93,
        'input_token_details': {'cache_read': 0},
        'output_token_details': {'reasoning': 73}
    }
)

AIMessage(
    content='你好！我在这里，随时为你提供帮助，请说。',
    additional_kwargs={'refusal': None},
    response_metadata={
        'token_usage': {
            'completion_tokens': 13,
            'prompt_tokens': 8,
            'total_tokens': 21,
            'completion_tokens_details': None,
            'prompt_tokens_details': {
                'audio_tokens': None,
                'cached_tokens': 0
            },
            'prompt_cache_hit_tokens': 0,
            'prompt_cache_miss_tokens': 8
        },
        'model_provider': 'deepseek',
        'model_name': 'deepseek-v4-flash',
        'system_fingerprint': 'fp_8b330d02d0_prod0820_fp8_kvcache_20260402',
        'id': '6351e395-64ac-4719-9014-daedcf5d6318',
        'finish_reason': 'stop',
        'logprobs': None
    },
    id='lc_run--019fab7e-7c82-7581-a117-9b5042be82ba-0',
    tool_calls=[],
    invalid_tool_calls=[],
    usage_metadata={
        'input_tokens': 8,
        'output_tokens': 13,
        'total_tokens': 21,
        'input_token_details': {'cache_read': 0},
        'output_token_details': {}
    }
)

def invoke(
    self,
    input: LanguageModelInput,
    config: RunnableConfig | None = None,
    *,
    stop: list[str] | None = None,
    **kwargs: Any,
) -> AIMessage

deepseek_llm.invoke(
    "你好",
    config={
        # LangSmith 链路运行名称，追踪时展示自定义名称
        "run_name": "...",
        # 自定义标签，用于LangSmith筛选、归类测试环境运行记录
        "tags": ["test", "development"],
        # 自定义元数据，可存入用户ID等业务字段，用于日志检索溯源
        "metadata": {"user_id": "123"},
        # 注册自定义回调处理器，可监听模型流式输出、调用起止事件
        "callbacks": [custom_handler],
        # 可动态覆盖的模型运行参数配置区
        "configurable": {
            "model": "deepseek-reasoner",   # 指定本次调用使用的推理模型
            "temperature": 0.7,             # 温度系数：控制生成随机性，0=确定 1=发散
            "max_tokens": 100               # 限制单次回复最大输出令牌数量
        }
    }
)

large_list_of_inputs = [..., ..., ...]
model.batch(
	large_list_of_inputs,
    config={
        'max_concurrency': 5 # 限制最大并发数为5
    }
)

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv
import os
from rich import print as rprint

# 从 .env 文件加载环境变量，重复变量强制覆盖原有值
load_dotenv(override=True)

# 读取密钥与接口地址环境变量
DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_BASE_URL = os.getenv("DEEPSEEK_BASE_URL")

# 1. 初始化 DeepSeek 对话大模型
model = init_chat_model(
    model="deepseek-v4-flash",
    model_provider="deepseek",
    api_key=DEEPSEEK_API_KEY,
    base_url=DEEPSEEK_BASE_URL,
    temperature=0.2,
    max_tokens=500,
    # 声明允许通过configurable动态覆写的参数列表，否则无效
    configurable_fields=("model", "model_provider", "temperature", "max_tokens"),
)

# 2. 构造调用配置：链路追踪标签、元数据、单次动态覆写参数
config = {
    "run_name": "joke_generation",          # LangSmith 链路运行名称
    "tags": ["tag1", "tag2"],               # 自定义标签，用于日志筛选分类
    "metadata": {"user_id": "123"},         # 业务自定义元数据，可溯源用户信息
    "configurable": {
        "model": "deepseek-v4-pro",          # 本次调用临时切换模型版本
        "model_provider": "openai",         # 临时指定模型服务商
        "temperature": 0.7,                  # 本次生成随机性参数
        "max_tokens": 1000                  # 本次最大输出token上限
    }
}

# 3. 发起模型调用，传入自定义运行配置
response = model.invoke(
    "1 + 2 = ？",
    config=config
)

# 美化打印模型返回完整结果
rprint(response)

AIMessage(
    content='1 + 2 = 3',
    additional_kwargs={'refusal': None},
    response_metadata={
        'token_usage': {
            'completion_tokens': 35,
            'prompt_tokens': 11,
            'total_tokens': 46,
            'completion_tokens_details': {
                'accepted_prediction_tokens': None,
                'audio_tokens': None,
                'reasoning_tokens': 27,
                'rejected_prediction_tokens': None
            },
            'prompt_tokens_details': {
                'audio_tokens': None,
                'cached_tokens': 0
            },
            'prompt_cache_hit_tokens': 0,
            'prompt_cache_miss_tokens': 11
        },
        'model_provider': 'openai',
        'model_name': 'deepseek-v4-pro',
        'system_fingerprint': 'fp_9954b31ca7_prod0820_fp8_kvcache_20260402',
        'id': 'c3fcc5e4-0a92-41c3-b6a5-1d98a84039a8',
        'finish_reason': 'stop',
        'logprobs': None
    },
    id='lc_run--019fab8c-2f0b-76c3-9bcc-71bd43da424f-0',
    tool_calls=[],
    invalid_tool_calls=[],
    usage_metadata={
        'input_tokens': 11,
        'output_tokens': 35,
        'total_tokens': 46,
        'input_token_details': {'cache_read': 0},
        'output_token_details': {'reasoning': 27}
    }
)