DeepSeek模型的多种调用方式

帘卷声笙寂

1890人浏览 · 2025-02-23 14:04:47

帘卷声笙寂 · 2025-02-23 14:04:47 发布

本文将讲述使用Python调用通过Ollama工具在本地部署模型、远程部署模型API调用的方法。

本地模型

1 ollama库调用

使用Ollama工具部署的模型可以使用ollama库进行调用

参考链接：https://github.com/datawhalechina/handy-ollama/tree/main

1.1 本地模型

调用本地模型不需要提供"url"信息，直接在调用函数(ollama.chat()或ollama.generate())中提供模型参数即可

1.1.1 一次性输出

一次性输出

import ollama
# ollama.chat()接口
response = ollama.chat(
    model='deepseek-r1:1.5b',
    messages=[{'role': 'user', 'content': '你好，你是谁？'}],
)

print(response.message.content)
print(response.model_dump_json())

# ollama.generate()接口
response = ollama.generate(
    model='deepseek-r1:1.5b',
    prompt='你好, 你是谁?',
)

print(response.response)
print(response.model_dump_json())

输出结果如下图所示：

ollama.chat--输出结果

{
  "model":"deepseek-r1:1.5b",
  "created_at":"2025-02-19T03:28:58.3139301Z",
  "done":true,
  "done_reason":"stop",
  "total_duration":596700000,
  "load_duration":12674700,
  "prompt_eval_count":8,
  "prompt_eval_duration":2000000,
  "eval_count":40,
  "eval_duration":581000000,
  "message":{
    "role":"assistant",
     "content":"<think>\n\n</think>\n\n您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何任何问题，我会尽我所能为您提供帮助。",
    "images":null,
    "tool_calls":null
  }
}

ollama.generate--输出结果

{
  "model":"deepseek-r1:1.5b",
  "created_at":"2025-02-19T05:17:34.7305942Z",
  "done":true,
  "done_reason":"stop",
  "total_duration":1100395200,
  "load_duration":13157300,
  "prompt_eval_count":9,
  "prompt_eval_duration":2000000,
  "eval_count":79,
  "eval_duration":1083000000,
  "response":"<think>\n我是DeepSeek-R1，一个由深度求索公司开发的智能助手，我擅长通过思考来帮您解答复杂的数学，代码和逻辑推理等理工类问题。\n</think>\n\n我是DeepSeek-R1，一个由深度求索公司开发的智能助手，我擅长通过思考来帮您解答复杂的数学，代码和逻辑推理等理工类问题。",
  "context":[151644,108386,11,220,105043,100165,30,151645,151648,198,104198,33464,39350,10911,16,3837,46944,67071,102217,30918,50984,73218,100013,9370,100168,110498,3837,35946,107618,67338,104107,36407,99663,87026,106185,106888,104552,3837,46100,33108,104913,113272,49567,103538,21515,86119,8997,151649,271,104198,33464,39350,10911,16,3837,46944,67071,102217,30918,50984,73218,100013,9370,100168,110498,3837,35946,107618,67338,104107,36407,99663,87026,106185,106888,104552,3837,46100,33108,104913,113272,49567,103538,21515,86119,1773]
}

1.1.2 流式输出

ollama.chat--流式输出

from ollama import chat

messages = [
  {
    'role': 'user',
    'content': '你好, 你是谁?',
  },
]

for part in chat(model='deepseek-r1:1.5b', messages=messages, stream=True):
  print(part['message']['content'], end='', flush=True)

ollama.generate--流式输出

from ollama import generate

for part in generate(
    model='deepseek-r1:1.5b',
    prompt='你好, 你是谁?',
    stream=True):
    
    print(part.response, end='', flush=True)

1.2 自定义客户端

通过ollama实例化Client或AsyncClient来创建自定义客户端。

1.2.1 同步客户端

使用同步客户端Client意味着当调用client.chat()方法时，程序会等待该请求完成并返回结果后才会继续执行后续代码。这种方式更直观、简单，适合于编写流程较为线性、不需要处理大量并发任务的应用。

同步客户端--一次性输出

import ollama

url = "http://localhost:11434"
client = ollama.Client(host=url)
response = client.chat(
    model='deepseek-r1:32b',
    messages=[{'role': 'user', 'content': '你好, 你是谁?'}],
)

print(response.message.content)

同步客户端--流式输出

import ollama

url = "http://localhost:11434"
client = ollama.Client(host=url)
messages = [
  {
    'role': 'user',
    'content': '请提供一份实现调用ollama在局域网服务器部署的模型，并实现流式输出的python代码。',
  },
]
for part in client.chat(model='deepseek-r1:32b', messages=messages, stream=True):
  print(part['message']['content'], end='', flush=True)

1.2.2 异步客户端

使用异步客户端AsyncClient，并且定义了一个异步函数chat()。通过await关键字，可以暂停该函数的执行直到AsyncClient().chat()请求完成，但在此期间不会阻塞其他操作。

这对于需要高效率处理I/O操作（如网络请求）或希望同时执行多个任务的应用来说非常有用。

此外，使用asyncio.run(chat())来运行这个异步函数。

异步客户端--一次性输出

import ollama
import asyncio
import nest_asyncio

nest_asyncio.apply()

async def chat():
    url = "http://localhost:11434"
    client = ollama.AsyncClient(host=url)
    message = {'role': 'user', 'content': '请问3.11和3.9哪个大？'}
    response = await client.chat(
        model='deepseek-r1:32b',
        messages=[message]
    )
    print(response.message.content)

asyncio.run(chat())

异步客户端--流式输出

import ollama
import asyncio
import nest_asyncio

nest_asyncio.apply()

async def chat():
    url = "http://localhost:11434"
    client = ollama.AsyncClient(host=url)
    message = {'role': 'user', 'content': '请问3.11和3.9哪个大？'}

    async for part in await client.chat(
        model='deepseek-r1:32b',
        messages=[message],
        stream=True,
    ):
        print(part.message.content, end='', flush=True)

asyncio.run(chat())

1.3 输出结果解释

# 模型相关信息
model='deepseek-r1:32b' 

# 时间相关信息
created_at='2025-02-18T07:37:50.878135469Z'  #响应创建的时间，采用ISO 8601格式，Z 表示UTC时间
total_duration=1026982791      #整个请求处理的总时长，单位是纳秒
load_duration=8747120          #加载模型所需的时长，单位是纳秒
prompt_eval_duration=14000000  #评估用户输入提示（prompt）所花费的时长，单位是纳秒
eval_duration=1003000000       #模型生成回复内容的评估时长，单位是纳秒

# 评估计数信息
prompt_eval_count=9            #评估用户输入提示时的评估步骤数
eval_count=40                  #模型生成回复内容时的评估步骤数

# 完成状态信息
done=True  #表示请求已完成
done_reason='stop'  #表示请求完成的原因是模型生成回复时遇到了停止条件

# 消息内容信息
message=Message(
    role='assistant', #表示消息的发送者角色是助手
    content='<think>\n\n</think>\n\n您好！我是由中国的深度求索（DeepSeek）公司开发的智能助手DeepSeek-R1。如您有任何任何问题，我会尽我所能为您提供帮助。', 
    images=None,      #表示回复中不包含图片
    tool_calls=None)  #表示回复中没有调用外部工具

在大语言模型的运行机制里，“评估步骤数”指的是模型在处理输入和生成输出的过程中，所经历的计算步骤的数量

prompt_eval_count

含义：prompt_eval_count = 9 意味着模型在评估用户输入的提示（也就是用户发送的消息）时，总共执行了 9 个评估步骤。

评估过程：当用户输入提示信息后，模型需要对提示进行解析、编码等操作，将其转化为模型能够理解的内部表示形式。这个过程可能包含对每个词的词法分析、句法分析，以及将文本转换为向量表示等步骤。每一次这样的操作或者计算就可以看作是一个评估步骤。例如，模型可能会对输入提示中的每个词进行单独的词嵌入计算，同时考虑上下文信息来调整词向量的表示，这些操作的次数就会累加到 prompt_eval_count 中。

eval_count

含义：eval_count = 40 表示模型在生成回复内容时，一共执行了 40 个评估步骤。

生成过程：模型在根据提示生成回复时，会逐步预测下一个要生成的词。每一次预测就是一个评估步骤，在这个过程中，模型会基于当前已经生成的内容和之前对提示的理解，从词汇表中选择最可能的下一个词。随着回复内容的逐步生成，评估步骤数会不断累加。例如，模型可能会根据当前的上下文和概率分布，对词汇表中的每个词进行打分，选择得分最高的词作为下一个生成的词，这样的操作就会被计入 eval_count。

prompt_eval_count 反映了模型处理用户输入提示的复杂度，而 eval_count 则体现了生成回复内容的复杂度。通常情况下，输入提示越长、越复杂，prompt_eval_count 就可能越大；回复内容越长、生成难度越高，eval_count 也就会越大。这两个参数可以帮助开发者了解模型在处理不同任务时的计算开销和复杂度。

2 requests库调用

可以采用三种不同的url形式：

url = "http://172.20.31.6:11434/api/chat"
url = "http://172.20.31.6:11434/api/generate"
url = "http://172.20.31.6:11434/v1/chat/completions"

2.1 api/chat接口

2.1.1 一次性输出

api/chat -- 一次性输出

"requests调用-一次性输出"
import requests

url = "http://172.20.31.6:11434/api/chat"
data = {
  "model": "deepseek-r1:32b",
  "messages": [
    {
      "role": "user",
      "content": "请提供一份实现调用ollama在局域网服务器部署的模型，并实现流式输出的python代码。"
    }
  ],
  "stream": False
}
response = requests.post(url, json=data)
if response.status_code == 200:
  result = response.json()
  print(result["message"]["content"])
else:
  print(f"请求失败，状态码: {response.status_code}")

2.1.2 流式输出

api/chat -- 流式输出

"requests调用-流式输出"
import requests
import json

url = "http://172.20.31.6:11434/api/chat"
data = {
  "model": "deepseek-r1:32b",
  "messages": [
    {
      "role": "user",
      "content": "请提供一份实现调用ollama在局域网服务器部署的模型，并实现流式输出的python代码。"
    }
  ],
  "stream": True
}

response = requests.post(url, json=data, stream=True)
if response.status_code == 200:
  for line in response.iter_lines():
    if line:
      result = line.decode('utf-8')
      # 处理流式响应，这里假设响应是 JSON 格式
      try:
        result_json = json.loads(result)
        if 'message' in result_json and 'content' in result_json['message']:
          print(result_json['message']['content'], end='', flush=True)
      except json.JSONDecodeError:
        print(f"解析JSON失败: {result}")
else:
  print(f"请求失败，状态码: {response.status_code}")

2.2 api/generate接口

2.2.1 一次性输出

api/generate -- 一次性输出

import requests

url = "http://localhost:11434/api/generate"
data = {
    "model" : "deepseek-r1:32b",
    "prompt" : "你好，你是谁？",
    "stream" : False,
}
response = requests.post(url, json=data)
if response.status_code == 200:
    result = response.json()
    print(result['response'])
else:
    print(f"请求失败，状态码: {response.status_code}")

2.2.2 流式输出

api/generate -- 流式输出

import json
import requests

url = "http://localhost:11434/api/generate"
data = {
  "model" : "deepseek-r1:1.5b",
  "prompt" : "你好，你是谁？",
  "stream" : True,
}
response = requests.post(url, json=data, stream=True)
if response.status_code == 200:
  for line in response.iter_lines():
    if line:
      result = line.decode('utf-8')
      try:
        result_json = json.loads(result)
        if result_json.get("response"):
          print(result_json["response"], end='', flush=True)
      except json.JSONDecodeError:
        print(f"解析JSON失败: {result}")

else:
  print(f"请求失败，状态码: {response.status_code}")

2.3 chat/completions接口

2.3.1 一次性输出

chat/completions -- 一次性输出

import requests

url = "http://localhost:11434/v1/chat/completions"
data = {
  "model": "deepseek-r1:1.5b",
  "messages": [
    {
      "role": "user",
      "content": "请提供一份实现调用ollama在局域网服务器部署的模型，并实现流式输出的python代码。"
    }
  ],
  # "stream": False
}
response = requests.post(url, json=data)
if response.status_code == 200:
  result = response.json()
  print(result['choices'][0]['message']['content'])
else:
  print(f"请求失败，状态码: {response.status_code}")

2.3.2 流式输出

chat/completions -- 流式输出

import json
import requests

url = "http://172.20.31.6:11434/v1/chat/completions"
data = {
  "model": "deepseek-r1:32b",
  "messages": [
    {
      "role": "user",
      "content": "请提供一份实现调用ollama在局域网服务器部署的模型，并实现流式输出的python代码。"
    }
  ],
  # "stream": False
}
response = requests.post(url, json=data, stream=True)
if response.status_code == 200:
  for line in response.iter_lines():
    if line:
      result = line.decode('utf-8')
      try:
        result_json = json.loads(result)
        if 'choices' in result_json and 'content' in result_json['choices'][0]['message']:
          print(result_json['choices'][0]['message']['content'], end='', flush=True)

      except json.JSONDecodeError:
        print(f"解析JSON失败: {result}")
else:
  print(f"请求失败，状态码: {response.status_code}")

3 openai库调用

3.1 一次性输出

3.1.1 单轮对话

一次性输出--单轮对话

from openai import OpenAI

url = "http://172.20.31.6:11434/v1"
key = "sk-1234567890"   #可设为任意值，Ollama不依赖此验证
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(
    api_key=key,   #此处的api_key为必填项，但在Ollama中会被忽略
    base_url=url
)
try:
    response = client.chat.completions.create(
        model="deepseek-r1:32b",
        messages=messages
    )
    content = response.choices[0].message.content
    print(content)
except Exception as e:
    print(f"请求出错:{e}")

3.1.2 多轮对话

一次性输出--多轮对话

from openai import OpenAI

url = "http://172.20.31.6:11434/v1"
key = "sk-1234567890"
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(api_key=key, base_url=url)
try:
    # Round 1
    response = client.chat.completions.create(
        model="deepseek-r1:32b",
        messages=messages
    )
    messages.append(response.choices[0].message)
    print(f"Messages Round 1: {messages}")

    # Round 2
    messages.append({
        'role': 'user',
        'content': '你可以做什么?',
    })
    response = client.chat.completions.create(
        model="deepseek-r1:32b",
        messages=messages
    )
    messages.append(response.choices[0].message)
    print(f"Messages Round 2: {messages}")
except Exception as e:
    print(f"请求出错:{e}")

3.2 流式输出

3.2.1 单轮对话

流式输出-单轮对话

from openai import OpenAI

url = "http://172.20.31.6:11434/v1"
key = "sk-1234567890"
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(api_key=key, base_url=url)
try:
    response = client.chat.completions.create(
        model="deepseek-r1:32b",
        messages=messages,
        stream=True
    )
    for part in response:
        if part.choices[0].delta.content is not None:
            content = part.choices[0].delta.content
            print(content, end='', flush=True)
        else:
            break

except Exception as e:
    print(f"请求出错:{e}")

3.2.2 多轮对话

流式输出-多轮对话

from openai import OpenAI

url = "http://172.20.31.6:11434/v1"
key = "sk-1234567890"
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(api_key=key, base_url=url)
try:
    # Round 1
    response = client.chat.completions.create(
        model="deepseek-r1:32b",
        messages=messages,
        stream=True
    )
    full_content = ""
    for part in response:
        if part.choices[0].delta.content is not None:
            content = part.choices[0].delta.content
            # print(content, end='', flush=True)
            full_content += content
        else:
            break
    messages.append({'role': 'assistant', 'content': full_content})
    print(f"Messages Round 1: {messages}")

    # Round 2
    messages.append({
        'role': 'user',
        'content': '你可以做什么?',
    })
    response = client.chat.completions.create(
        model="deepseek-r1:32b",
        messages=messages,
        stream=True
    )
    full_content = ""
    for part in response:
        if part.choices[0].delta.content is not None:
            content = part.choices[0].delta.content
            # print(content, end='', flush=True)
            full_content += content
        else:
            break
    messages.append({'role': 'assistant', 'content': full_content})
    print(f"Messages Round 2: {messages}")
except Exception as e:
    print(f"请求出错:{e}")

多轮对话输出结果

Messages Round 1: 
    [
      {'role': 'user', 'content': '你好, 你是谁?'}, 
      {'role': 'assistant', 'content': '<think>\n\n</think>\n\n你好！我是一个由DeepSeek开发的智能助手，随时为你提供帮助。无论是学习、工作还是生活中的问题，都可以告诉我哦！'}
    ]
Messages Round 2: 
    [
      {'role': 'user', 'content': '你好, 你是谁?'}, 
      {'role': 'assistant', 'content': '<think>\n\n</think>\n\n你好！我是一个由DeepSeek开发的智能助手，随时为你提供帮助。无论是学习、工作还是生活中的问题，都可以告诉我哦！'}, 
      {'role': 'user', 'content': '你可以做什么?'}, 
      {'role': 'assistant', 'content': '<think>\n嗯，用户刚刚问了“你可以做什么?”，看起来他们想知道我的功能和能力范围。\n\n我需要解释我可以做些什么，包括写文件、回答问题、提供建议等等。\n\n最好分点列出，这样更清晰明了。同时，要让用户觉得我能覆盖很多方面的需求。\n\n还要保持语气友好，并邀请他们提出具体需求。\n\n这样用户会觉得我很有用且乐于助人。\n</think>\n\n我目前的功能主要集中在文本交互上，包括回答问题、提供信息、进行对话等。如果你有任何想了解的知识或需要帮助的地方，都可以告诉我！以下是一些我可以帮忙的领域：\n\n- **学习和学术**：解答复杂的问题，总结知识点，协助写论文或报告  \n- **工作和效率**：提供建议、策略，帮助解决问题  \n- **生活建议**：提供日常生活的建议，比如旅行计划、健康管理等  \n- **编程和开发**：辅助编写代码、解决技术问题  \n- **创意写作**：帮助写小说、故事、诗歌等  \n- **对话交流**：陪你聊天、讨论兴趣爱好  \n\n如果你有任何具体需求或问题，随时告诉我，我会尽力帮助你！'}
    ]

远程API

1 阿里百炼

参考链接：

https://bailian.console.aliyun.com/?accounttraceid=60e9210917054deca97f39d673cfe738djzc#/model-market/detail/deepseek-r1

https://api-docs.deepseek.com/zh-cn/guides/reasoning_model

注意：本文中使用openai库调用平台部署模型api时，返回结果中关于思考过程字段的索引位置与平台示例的不同。

思考过程是索引方式为：response.choices[0].message.model_extra['reasoning_content']

出现这种差异的原因可能是openai库的版本不一样，本文代码使用的版本为：openai==1.61.1

1.1 一次性输出

1.1.1 单轮对话

from openai import OpenAI

url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
key = "YOUR_API_KEY"
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(api_key=key, base_url=url)
try:
    response = client.chat.completions.create(
        model="deepseek-r1",
        messages=messages,
    )
    # 本代码的返回结果response中reasoning_content字段的索引位置，与平台提供的API示例不符
    reasoning_content = response.choices[0].message.model_extra['reasoning_content']
    print(reasoning_content)
    content = response.choices[0].message.content
    print(content)

except Exception as e:
    print(f"请求出错:{e}")

1.1.2 多轮对话

from openai import OpenAI

url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
key = "YOUR_API_KEY"
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(api_key=key, base_url=url)
try:
    print("=" * 20 + "第一轮对话" + "=" * 20)
    response = client.chat.completions.create(
        model="deepseek-r1",
        messages=messages,
    )
    # 通过reasoning_content字段打印思考过程
    print("=" * 20 + "思考过程" + "=" * 20)
    resoning_content = response.choices[0].message.model_extra['reasoning_content']
    print(resoning_content)
    # 通过content字段打印最终答案
    print("=" * 20 + "最终答案" + "=" * 20)
    content = response.choices[0].message.content
    print(content)

    messages.append({'role': 'assistant', 'content': content})
    messages.append({'role': 'user', 'content': '你可以做什么?'})

    print("=" * 20 + "第二轮对话" + "=" * 20)
    response = client.chat.completions.create(
        model="deepseek-r1",
        messages=messages,
    )
    # 通过reasoning_content字段打印思考过程
    print("=" * 20 + "思考过程" + "=" * 20)
    resoning_content = response.choices[0].message.model_extra['reasoning_content']
    print(resoning_content)
    # 通过content字段打印最终答案
    print("=" * 20 + "最终答案" + "=" * 20)
    content = response.choices[0].message.content
    print(content)

except Exception as e:
    print(f"请求出错:{e}")

1.2 流式输出

1.2.1 单轮对话

from openai import OpenAI

url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
key = "YOUR_API_KEY"
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(api_key=key, base_url=url)

# reasoning_content = ""  # 定义完整思考过程
# answer_content = ""     # 定义完整回复
is_answering = False   # 判断是否结束思考过程并开始回复

try:
    response = client.chat.completions.create(
        model="deepseek-r1",
        messages=messages,
        stream=True
    )
    print("\n" + "=" * 20 + "思考过程" + "=" * 20 + "\n")
    for chunk in response:
        if not chunk.choices: #如果当前块没有'choices'项，打印Token使用量。
            print("\nUsage:")
            print(chunk.usage)
        else:
            delta = chunk.choices[0].delta
            if hasattr(delta,'model_extra') and delta.model_extra['reasoning_content'] != None:
                print(delta.model_extra['reasoning_content'], end='', flush=True)
                # reasoning_content += delta.model_extra['reasoning_content']
            else:
                if delta.content!= "" and is_answering == False:
                    is_answering = True
                    print("\n" + "=" * 20 + "最终答案" + "=" * 20 + "\n")
                print(delta.content, end='', flush=True)
                # answer_content += delta.content

except Exception as e:
    print(f"请求出错:{e}")

1.2.2 多轮对话

from openai import OpenAI

url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
key = "YOUR_API_KEY"
messages = [
    {
        'role': 'user',
        'content': '你好, 你是谁?',
    },
]
client = OpenAI(api_key=key, base_url=url)

try:
    # Round 1
    print("=" * 20 + "第一轮对话" + "=" * 20)
    response = client.chat.completions.create(
        model="deepseek-r1",
        messages=messages,
        stream=True
    )
    print("\n" + "=" * 20 + "思考过程" + "=" * 20 + "\n")
    is_answering = False  # 判断是否结束思考过程并开始回复
    full_content = ""
    for chunk in response:
        if not chunk.choices: #如果当前块没有'choices'项，打印Token使用量。
            print("\nUsage:")
            print(chunk.usage)
        else:
            delta = chunk.choices[0].delta
            if hasattr(delta,'model_extra') and delta.model_extra['reasoning_content'] != None:
                print(delta.model_extra['reasoning_content'], end='', flush=True)
            else:
                if delta.content!= "" and is_answering == False:
                    is_answering = True
                    print("\n" + "=" * 20 + "最终答案" + "=" * 20 + "\n")
                print(delta.content, end='', flush=True)
                full_content += delta.content

    messages.append({'role': 'assistant', 'content': full_content})
    messages.append({'role': 'user', 'content': '9.9和9.11谁大?'})

    # Round 2
    print("\n" + "=" * 20 + "第二轮对话" + "=" * 20)
    response = client.chat.completions.create(
        model="deepseek-r1",
        messages=messages,
        stream=True
    )
    print("\n" + "=" * 20 + "思考过程" + "=" * 20 + "\n")
    is_answering = False  # 判断是否结束思考过程并开始回复
    full_content = ""
    for chunk in response:
        if not chunk.choices: #如果当前块没有'choices'项，打印Token使用量。
            print("\nUsage:")
            print(chunk.usage)
        else:
            delta = chunk.choices[0].delta
            if hasattr(delta,'model_extra') and delta.model_extra['reasoning_content']!= None:
                print(delta.model_extra['reasoning_content'], end='', flush=True)
            else:
                if delta.content!= "" and is_answering == False:
                    is_answering = True
                    print("\n" + "=" * 20 + "最终答案" + "=" * 20 + "\n")
                print(delta.content, end='', flush=True)
                full_content += delta.content
    messages.append({'role': 'assistant', 'content': full_content})
    print("\n" + "=" * 20 + "所有对话" + "=" * 20)
    print(messages)
except Exception as e:
    print(f"请求出错:{e}")