DeepSeek-V3.2快速上手与Function calling功能实现

课程说明：

体验课内容节选自《2025大模型Agent智能体开发实战》(12月班) 完整版付费课程

体验课时间有限，若想深度学习大模型技术，欢迎大家报名由我主讲的《2025大模型Agent智能体开发实战》(12月班)

《2025大模型Agent智能体开发实战》(12月班) 为【100+小时】体系大课，总共20大模块精讲精析，零基础直达大模型企业级应用！

课程完整介绍

部分课程成果演示

from IPython.display import Video

Dify+DeepSeek搭建智能微信语音客服

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/2f1b47f42c65fd59e8d3a83e6cb9f13b_raw.mp4", width=800, height=400)

Coze自动图文视频创作流程

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/Coze%E5%8A%A8%E6%80%81%E8%A7%86%E9%A2%91%E7%94%9F%E6%88%90%E5%AE%9E%E4%BE%8B.mp4", width=800, height=400)

可视化数据分析Multi-Agent

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/%E5%8F%AF%E8%A7%86%E5%8C%96%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90Multi-Agent%E6%95%88%E6%9E%9C%E6%BC%94%E7%A4%BA%E6%95%88%E6%9E%9C.mp4", width=800, height=400)

高效微调全自动数据集创建

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/easy_daset_yanshi.mp4", width=800, height=400)

MateGen Pro 项目功能演示

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/MG%E6%BC%94%E7%A4%BA%E8%A7%86%E9%A2%91.mp4", width=800, height=400)

智能客服项目展示

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/%E6%99%BA%E8%83%BD%E5%AE%A2%E6%9C%8D%E6%A1%88%E4%BE%8B%E8%A7%86%E9%A2%91.mp4", width=800, height=400)

GraphRAG+多模态文档检索

Video("https://ml2022.oss-cn-hangzhou.aliyuncs.com/7%E6%9C%8817%E6%97%A5%281%29%20%E8%BF%9B%E5%BA%A6%E6%9D%A1.mp4", width=800, height=400)

此外，若是对大模型底层原理感兴趣，也欢迎报名由我和菜菜老师共同主讲的《2025大模型原理与实战课程》(秋季班)

详细信息扫码添加助教，回复“大模型”，即可领取课程大纲&查看课程详情👇

国产最强DeepSeek-V3.2 Agent开发实战

Part 1.DeepSeek-V3.2 Agent开发入门

一、DeepSeek-V3.2模型介绍

两个月前，DeepSeek-V3.2-EXP实验版模型正式发布，首次提出了DSA稀疏注意力机制，在维持模型性能不变的情况下，模型推理和训练成本暴降50%以上，

两个月后，DeepSeek-V3.2正式版重磅发布，在实验版基础上，进一步引入可拓展的GRPO训练框架搭配大规模合成Agent任务数据集，借助海量强化学习后训练，让DeepSeek-V3.2正式版模型一举突破性能极限。

模型在数学、编程、Agent性能方面全面领先GPT-5，跻身全球顶尖大模型第一梯队。并且，DeepSeek团队还做了一项大胆的尝试，那就是为模型的训练过程解除思考链长度限制，并同时引入DeepSeekMath-V2提出的自验证数学推理训练法，最终训练得到DeepSeek-V3.2-Speciale模型，更是在各项指标上整体追平全球性能最强大模型Gemini 3.0 Pro。

最重要的是DeepSeek-V3.2模型的价格不到Gemini 3.0的1/5，不到GPT-5.1模型的1/4，可以说性价比拉满。

目前DeepSeek-V3.2和Speciale两款模型的API已全面上线，模型权重也已全面开源，

模型权重：https://huggingface.co/deepseek-ai/DeepSeek-V3.2

DeepSeek模型演化路径

DeepSeek-V3.2核心技术创新点

而与此同时，DeepSeek-V3.2模型的Agent性能也得到了巨大的提升，和Gemini 3、Claude 4.5等模型的差距已经不到5%。

并且DeepSeek首次引入“思考模式下工具调用”的功能，允许模型在单轮任务调用过程保持多步工具调用思考链记忆，也就是像人一样一边思考一边调用工具，从而大幅提升模型多步调用工具的前后一致性，显著提升模型Agent性能。

而我们团队也对此进行了测试。首先我们将DeepSeek-V3.2模型带入前不久刚开发的生产力级的基于Nano Banana Pro的AI PPT Agent，作为Agent基座模型（注意不是绘图模型），实际运行过程中，无论是多PPT任务拆解、自主提示词编写、还是外部工具调用，都达到了和Gemini 3.0 Pro的同等水平。

而除了DeepSeek-V3.2之外，本次DeepSeek还同步开源了一款实验性质的模型，DeepSeek-V3.2-Speciale。这是一次非常大胆的尝试，和DeepSeek-V3.2不同，这款Speciale模型在训练过程中采用了纯推理数据进行训练，并且放宽了普通模型都会有的推理长度惩罚力度，使得Speciale更加擅长通过长思考来解决问题，同时引入了DeepSeekMath-V2提出的自验证数学推理训练法，借助左右互搏来突破数学能力极限。

最终DeepSeek-V3.2-Speciale模型在各主流评测数据集上，无论是数学、编程、还是HLE（人类最后测试）、Agent性能等各个方面，均达到了Gemini 3.0 Pro模型的同等水平。

并且目前Speciale模型权重也已同步开源，而若要调用模型API，则需要更换如图所示的base_url，

视频地址：https://www.bilibili.com/video/BV13rSHBBEoG/

LangChain 1.0快速入门指南：https://www.bilibili.com/video/BV1uV1yBHE2o/

二、DeepSeek快速上手使用

1.DeepSeek基础调用流程

在进行Agent开发之前，首先需要准备一个可以进行调用的大模型，这里我们选择使用DeepSeek的大模型，并使用DeepSeek官方的API_KEK进行调用。如果初次使用，需要现在DeepSeek官网上进行注册并创建一个新的API_Key，其官方地址为：https://platform.deepseek.com/usage

注册好DeepSeek的API_KEY后，首先在项目同级目录下创建一个env文件，用于存储DeepSeek的API_KEY，如下所示：

接下来通过python-dotenv库读取env文件中的API_KEY，使其加载到当前的运行环境中，代码如下：

# ! pip install python-dotenv

import os
from dotenv import load_dotenv 
load_dotenv(override=True)

DeepSeek_API_KEY = os.getenv("DEEPSEEK_API_KEY")
# print(DeepSeek_API_KEY)  # 可以通过打印查看

我们在当前的运行环境下不使用LangChain，直接使用DeepSeek的API进行网络连通性测试，测试代码如下：

# ! pip install openai

from openai import OpenAI

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

# 调用DeepSeek的API，生成回答
response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "你是乐于助人的助手，请根据用户的问题给出回答"},
        {"role": "user", "content": "你好，请你介绍一下你自己。"},
    ],
)

# 打印模型最终的响应结果
print(response.choices[0].message.content)

如果可以正常收到DeepSeek模型的响应，则说明DeepSeek的API已经可以正常使用且网络连通性正常。

response

response.choices[0]

response.choices[0].message

response.choices[0].message.content

推理模型调用流程

# 调用DeepSeek的API，生成回答
response_reasoner = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[
        {"role": "system", "content": "你是乐于助人的助手，请根据用户的问题给出回答"},
        {"role": "user", "content": "你好，请你介绍一下你自己。"},
    ],
)

response_reasoner

response_reasoner.choices[0].message

response_reasoner.choices[0].message.content

response_reasoner.choices[0].message.reasoning_content

2.DeepSeek-V3.2 Function calling调用流程

Function calling是大模型调用外部工具的关键技术，当我们要查询当前天气时，让大模型调用外部工具的function calling的过程就如图所示：

外部函数创建流程

import os
from dotenv import load_dotenv 
load_dotenv(override=True)

OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY")

import requests,json

def get_weather(loc):
    """
    查询即时天气函数
    :param loc: 必要参数，字符串类型，用于表示查询天气的具体城市名称，\
    注意，中国的城市需要用对应城市的英文名称代替，例如如果需要查询北京市天气，则loc参数需要输入'Beijing'；
    :return：OpenWeather API查询即时天气的结果，具体URL请求地址为：https://api.openweathermap.org/data/2.5/weather\
    返回结果对象类型为解析之后的JSON格式对象，并用字符串形式进行表示，其中包含了全部重要的天气信息
    """
    # Step 1.构建请求
    url = "https://api.openweathermap.org/data/2.5/weather"

    # Step 2.设置查询参数
    params = {
        "q": loc,               
        "appid": os.getenv("OPENWEATHER_API_KEY"),    # 输入API key
        "units": "metric",            # 使用摄氏度而不是华氏度
        "lang":"zh_cn"                # 输出语言为简体中文
    }

    # Step 3.发送GET请求
    response = requests.get(url, params=params)
    
    # Step 4.解析响应
    data = response.json()
    return json.dumps(data)

get_weather("Beijing")

tools = [
    {
        "type": "function",
        "function":{
            'name': 'get_weather',
            'description': '查询即时天气函数，根据输入的城市名称，查询对应城市的实时天气，一次只能输入一个城市名称',
            'parameters': {
                'type': 'object',
                'properties': {
                    'loc': {
                        'description': "城市名称，注意，中国的城市需要用对应城市的英文名称代替，例如如果需要查询北京市天气，则loc参数需要输入'Beijing'",
                        'type': 'string'
                    }
                },
                'required': ['loc']
            }
        }
    }
]

Function calling执行流程

messages=[
    {"role": "user", "content": "请问北京今天天气如何？"}
]

chat_response = client.chat.completions.create(
    model="deepseek-chat",  
    messages=messages,
    tools=tools,
)

chat_response

chat_response.choices[0]

chat_response.choices[0].finish_reason

chat_response.choices[0].message.content

chat_response.choices[0].message.tool_calls

reasoner_response = client.chat.completions.create(
    model="deepseek-reasoner",  
    messages=messages,
    tools=tools,
)

reasoner_response

reasoner_response.choices[0]

reasoner_response.choices[0].finish_reason

reasoner_response.choices[0].message.reasoning_content

reasoner_response.choices[0].message.tool_calls

available_functions = {
            "get_weather": get_weather,
        }

function_call_messages = reasoner_response.choices[0].message.tool_calls
function_call_messages

len(function_call_messages)

function_call_messages[0]

tool_call = function_call_messages[0]

tool_name = tool_call.function.name
tool_args = json.loads(tool_call.function.arguments)

tool_name,tool_args

fuction_to_call = available_functions[tool_name]
fuction_to_call

function_response = fuction_to_call(**tool_args)

function_response

# function call message
reasoner_response.choices[0].message.model_dump()

# function response message
{
    "role": "tool",
    "content": function_response,
    "tool_call_id": tool_call.id,
}

messages

messages.append(reasoner_response.choices[0].message.model_dump())
messages.append(
    {
        "role": "tool",
        "content": function_response,
        "tool_call_id": tool_call.id,
    }
)

messages

# 第二次响应
response = client.chat.completions.create(
    model="deepseek-reasoner",  
    messages=messages,
    tools=tools,
)

response

response.choices[0].message

response.choices[0].finish_reason

基于DeepSeek-V3.2的多工具调用流程

messages2=[
    {"role": "user", "content": "请问北京和杭州今天天气如何？"}
]

response2 = client.chat.completions.create(
    model="deepseek-reasoner",  
    messages=messages2,
    tools=tools,
)

response2.choices[0].message

response2.choices[0].message.tool_calls

function_call_messages = response2.choices[0].message.tool_calls
function_call_messages

response2.choices[0].message.model_dump()

创建create_function_response_messages函数，一次性构建完整回复：

def create_function_response_messages(messages, response):
    function_call_messages = response.choices[0].message.tool_calls
    messages.append(response.choices[0].message.model_dump())
    for function_call_message in function_call_messages:
        tool_name = function_call_message.function.name
        tool_args = json.loads(function_call_message.function.arguments)
        
        # 运行外部函数
        fuction_to_call = available_functions[tool_name]
        try:
            function_response = fuction_to_call(**tool_args)
        except Exception as e:
            function_response = "函数运行报错如下:" + str(e)

        # 拼接消息队列
        messages.append(
            {
                "role": "tool",
                "content": function_response,
                "tool_call_id": function_call_message.id,
            }
        )
    return messages

messages2=[
    {"role": "user", "content": "请问北京和杭州今天天气如何？"}
]
messages2

response2

messages2 = create_function_response_messages(messages2, response2)

messages2

# 第二次响应
response = client.chat.completions.create(
    model="deepseek-reasoner",  
    messages=messages2,
    tools=tools,
)

response.choices[0].message

messages3 = create_function_response_messages(messages2, response)

messages3

# 第三次响应
response = client.chat.completions.create(
    model="deepseek-reasoner",  
    messages=messages3,
    tools=tools,
)

response.choices[0].message

messages3 + [response.choices[0].message.model_dump()]

三、LangChain中调用DeepSeek-V3.2模型完整流程

import langchain

langchain.__version__

1. DeepSeek接入LangChain流程

接下来我们要考虑的是，对于这样一个DeepSeek官方的API，如何接入到LangChain中呢？其实非常简单，我们只需要使用LangChain中的一个DeepSeek组件即可向像述代码一样，直接使用相同的DeepSeek API KEY与大模型进行交互。因此，我们首先需要安装LangChain的DeepSeek组件，安装命令如下：

# ! pip install langchain-deepseek

安装好LangChain集成DeepSeek模型的依赖包后，需要ChatDeepSeek函数来初始化大模型，代码如下：

from langchain_deepseek import ChatDeepSeek

model = ChatDeepSeek(model="deepseek-chat")

其中model用来指定要使用的模型名称，而model_provider用来指定模型提供者，当写入deepseek时，会自动加载langchain-deepseek的依赖包，并使用在model中指定的模型名称用来进行交互。

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

result = model.invoke(question)

print(result.content)

result

model = ChatDeepSeek(model="deepseek-reasoner")

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

result

result.additional_kwargs

result.additional_kwargs['reasoning_content']

2. LangChain 1.1创建Agent基础流程

from langchain.tools import tool

@tool
def get_weather(loc):
    """
    查询即时天气函数
    :param loc: 必要参数，字符串类型，用于表示查询天气的具体城市名称，\
    注意，中国的城市需要用对应城市的英文名称代替，例如如果需要查询北京市天气，则loc参数需要输入'Beijing'；
    :return：OpenWeather API查询即时天气的结果，具体URL请求地址为：https://api.openweathermap.org/data/2.5/weather\
    返回结果对象类型为解析之后的JSON格式对象，并用字符串形式进行表示，其中包含了全部重要的天气信息
    """
    # Step 1.构建请求
    url = "https://api.openweathermap.org/data/2.5/weather"

    # Step 2.设置查询参数
    params = {
        "q": loc,               
        "appid": os.getenv("OPENWEATHER_API_KEY"),    # 输入API key
        "units": "metric",            # 使用摄氏度而不是华氏度
        "lang":"zh_cn"                # 输出语言为简体中文
    }

    # Step 3.发送GET请求
    response = requests.get(url, params=params)
    
    # Step 4.解析响应
    data = response.json()
    return json.dumps(data)

print(get_weather.name)
print(get_weather.description)
print(get_weather.args)

然后即可直接带入到create_agent中，创建一个简易的天气查询Agent：

# 1.导入相关库
from langchain.agents import create_agent
from langchain_deepseek import ChatDeepSeek
from langchain_community.tools.tavily_search import TavilySearchResults

# 2.导入模型
model = ChatDeepSeek(model="deepseek-chat")

# 3.创建Agent
agent = create_agent(
    model=model,
    tools=[get_weather],
    system_prompt="你是一名多才多艺的智能助手，可以调用工具帮助用户解决问题。"
)

# 4.运行Agent获得结果
result = agent.invoke(
    {"messages": [{"role": "user", "content": "请问北京今天天气如何？"}]}
)

result['messages'][-1].content

而同样，这也是一个典型的Fucntion calling流程。

len(result['messages'])

result['messages']

例如：

result = agent.invoke(
    {"messages": [{"role": "user", "content": "请问今天杭州和南昌哪里更冷？"}]}
)

result['messages'][-1].content

此时Agent进行了多工具的并发调用。

result

接下来继续尝试进行工具的多步调用：

import os
from datetime import datetime

@tool
def write_file(content: str) -> str:
    """
    将指定内容写入本地文件。
    :param content: 必要参数，字符串类型，用于表示需要写入文档的具体内容。
    :return: 写入结果提示信息。
    """
    try:
        # ✅ 始终先定义文件名（防止未绑定变量）
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"output_{timestamp}.txt"

        # 写入文件
        with open(filename, "w", encoding="utf-8") as f:
            f.write(content)

        abs_path = os.path.abspath(filename)
        return f"✅ 已成功写入本地文件：{abs_path}"

    except Exception as e:
        return f"❌ 文件写入失败：{str(e)}"

agent = create_agent(
    model=model,
    tools=[get_weather, write_file],
    system_prompt="你是一名多才多艺的智能助手，可以调用工具帮助用户解决问题。"
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "请帮我查询天津、石家庄、上海等地天气，并写入本地文件。"}]}
)

result['messages'][-1].content

而此时就经历了两轮Function calling，也就是先查询天气、然后写入到本地文件中。

len(result['messages'])

result['messages']

而如果出现调用工具报错，则一般会尝试2-3次之后停止尝试。此外，关于调用工具报错信息的输出格式、以及控制报错响应流程，都可以使用稍后介绍的中间件来完成。

4.搭建基于DeepSeek-V3.2 reasoner的Agent流程

正常情况下调用会报错，因为目前LangChain 1.1还未兼容DeepSeek-V3.2的推理调用工具流程

model = ChatDeepSeek(model="deepseek-reasoner")

agent = create_agent(
    model=model,
    tools=[get_weather],
    system_prompt="你是一名多才多艺的智能助手，可以调用工具帮助用户解决问题。"
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "请问北京今天天气如何？"}]}
)

解决方案概览

通过继承 BaseChatModel 创建自定义的 DeepSeekReasonerChatModel，实现：

与 LangChain 1.0 的 create_agent 完全兼容
正确处理 reasoning_content 字段
支持完整的工具调用流程
可以查看模型的推理过程

创建核心类：DeepSeekReasonerChatModel

from typing import Optional, List, Dict, Any
from langchain_core.language_models.chat_models import BaseChatModel

class DeepSeekReasonerChatModel(BaseChatModel):
    """
    自定义 DeepSeek Reasoner 模型

    关键特性：
    1. 保留 reasoning_content 在 additional_kwargs 中
    2. 消息转换时恢复 reasoning_content
    3. 完整支持工具绑定和调用
    """

    api_key: str
    base_url: str = "https://api.deepseek.com"
    model_name: str = "deepseek-reasoner"
    temperature: float = 0.7
    bound_tools: Optional[List[Dict]] = None

创建关键方法：_convert_messages_to_openai_format

def _convert_messages_to_openai_format(self, messages):
    """LangChain 消息 → OpenAI 格式"""
    openai_messages = []

    for msg in messages:
        if isinstance(msg, AIMessage):
            msg_dict = {
                "role": "assistant",
                "content": msg.content or "",
            }

            # 添加 tool_calls
            if msg.tool_calls:
                msg_dict["tool_calls"] = [...]

            # 【关键】恢复 reasoning_content
            if 'reasoning_content' in msg.additional_kwargs:
                msg_dict["reasoning_content"] = msg.additional_kwargs['reasoning_content']

            openai_messages.append(msg_dict)

    return openai_messages

优化响应处理：_create_ai_message_from_response

def _create_ai_message_from_response(self, response):
    """OpenAI 响应 → LangChain AIMessage"""
    message = response.choices[0].message

    # 处理 tool_calls
    tool_calls = [...]

    # 【关键】保存 reasoning_content 到 additional_kwargs
    additional_kwargs = {}
    if hasattr(message, 'reasoning_content'):
        additional_kwargs['reasoning_content'] = message.reasoning_content

    return AIMessage(
        content=message.content or "",
        tool_calls=tool_calls if tool_calls else None,  # 不能是 None
        additional_kwargs=additional_kwargs
    )

进行工具绑定：bind_tools

from langchain_core.tools import BaseTool
def bind_tools(self, tools: List[BaseTool], **kwargs):
    """绑定 LangChain 工具"""
    # 转换为 OpenAI 格式
    openai_tools = []
    for tool in tools:
        openai_tools.append({
            "type": "function",
            "function": {
                "name": tool.name,
                "description": tool.description,
                "parameters": tool.args_schema.model_json_schema()
            }
        })

    # 返回新实例
    return self.__class__(
        api_key=self.api_key,
        base_url=self.base_url,
        model_name=self.model_name,
        temperature=self.temperature,
        bound_tools=openai_tools,  # 保存绑定的工具
        **kwargs
    )

优化生成响应格式：_generate

def _generate(self, messages, stop=None, run_manager=None, **kwargs):
    """核心生成方法"""
    # 转换消息
    openai_messages = self._convert_messages_to_openai_format(messages)

    # 准备请求
    request_params = {
        "model": self.model_name,
        "messages": openai_messages,
        "temperature": self.temperature,
    }

    # 添加工具
    if self.bound_tools:
        request_params["tools"] = self.bound_tools

    # 调用 API
    response = self._client.chat.completions.create(**request_params)

    # 创建响应
    ai_message = self._create_ai_message_from_response(response)

    return ChatResult(generations=[ChatGeneration(message=ai_message)])

实际调用效果

import os
from dotenv import load_dotenv
from langchain_core.tools import tool
from langchain.agents import create_agent

load_dotenv()
# 导入自定义模型
from deepseek_reasoner_chat_model import DeepSeekReasonerChatModel

# 创建自定义模型
model = DeepSeekReasonerChatModel(
    api_key=os.environ.get("DEEPSEEK_API_KEY"),
    model_name="deepseek-reasoner",
    temperature=0.7
)

tools = [get_weather, write_file]

agent = create_agent(
    model=model,
    tools=tools,
    system_prompt="你是一个有用的助手，可以使用工具来回答问题。"
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "请帮我查询北京天气信息。"}]}
)

result['messages'][-1].content

result['messages']

# 调用 agent
result = agent.invoke({
    "messages": [("user", "请问北京和沈阳哪里更冷？")]
})

# 查看结果
for msg in result["messages"]:
    if hasattr(msg, 'content') and msg.content:
        print(f"AI: {msg.content}")

        # 查看推理过程
        if hasattr(msg, 'additional_kwargs') and 'reasoning_content' in msg.additional_kwargs:
            print(f"推理: {msg.additional_kwargs['reasoning_content'][:200]}...")

课程说明：​

课程完整介绍​

部分课程成果演示​

国产最强DeepSeek-V3.2 Agent开发实战

Part 1.DeepSeek-V3.2 Agent开发入门​

一、DeepSeek-V3.2模型介绍​

二、DeepSeek快速上手使用​

1.DeepSeek基础调用流程​

2.DeepSeek-V3.2 Function calling调用流程​

三、LangChain中调用DeepSeek-V3.2模型完整流程​

1. DeepSeek接入LangChain流程​

2. LangChain 1.1创建Agent基础流程​

4.搭建基于DeepSeek-V3.2 reasoner的Agent流程​