Veröffentlicht: 15. Januar 2026 | Autor: HolySheep AI Technical Blog | Lesedauer: 12 Minuten

案例研究：柏林 B2B-SaaS-Startup 的 API 迁移之路

企业背景与痛点

我最近与一家总部位于柏林 的 B2B-SaaS-Startup 合作。该公司开发了一款基于大语言模型的客户服务自动化平台。在迁移到 HolySheep AI 之前，他们遇到了严重的成本和延迟问题：

迁移到 HolySheep AI 的原因

这家柏林 Startup 最终选择了 HolySheep AI，原因如下：

具体迁移步骤

我在指导这家 Startup 进行迁移时，采用了以下分阶段策略：

第一步：base_url 替换

# 旧代码 (OpenAI 兼容格式)
import openai

client = openai.OpenAI(
    api_key="YOUR_OLD_API_KEY",
    base_url="https://api.openai.com/v1"
)


新代码 (HolySheep AI)

import openai

client = openai.OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",  # 从 HolySheep 获取
    base_url="https://api.holysheep.ai/v1"  # 核心替换点
)


验证连接

response = client.chat.completions.create(
    model="gemini-2.0-flash-exp",
    messages=[{"role": "user", "content": "Hello"}]
)
print(f"响应: {response.choices[0].message.content}")
print(f"响应ID: {response.id}")
print(f"使用token: {response.usage.total_tokens}")

第二步：Key-Rotation 策略

import os
from openai import OpenAI

class HolySheepClient:
    """HolySheep AI API 客户端封装"""
    
    def __init__(self, api_key: str = None):
        self.api_key = api_key or os.environ.get("HOLYSHEEP_API_KEY")
        self.base_url = "https://api.holysheep.ai/v1"
        self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
    
    def rotate_key(self, new_key: str):
        """Key 轮换 - 支持零停机迁移"""
        self.api_key = new_key
        self.client = OpenAI(api_key=new_key, base_url=self.base_url)
        print(f"✅ API Key 已轮换: {new_key[:8]}...{new_key[-4:]}")
    
    def create_completion(self, model: str, messages: list, **kwargs):
        """创建对话完成"""
        return self.client.chat.completions.create(
            model=model,
            messages=messages,
            **kwargs
        )


使用示例

client = HolySheepClient(api_key="YOUR_HOLYSHEEP_API_KEY")


验证新 key

try:
    response = client.create_completion(
        model="gemini-2.0-flash-exp",
        messages=[{"role": "user", "content": "Test connection"}]
    )
    print(f"连接成功! 响应时间: {response.model_dump()}")
except Exception as e:
    print(f"连接失败: {e}")

第三步：Canary Deployment 部署

import random
import time
from typing import Callable, Any

class CanaryDeployment:
    """
    金丝雀部署管理器
    逐步将流量从旧 API 迁移到 HolySheep AI
    """
    
    def __init__(self, old_client, new_client, initial_ratio: float = 0.1):
        self.old_client = old_client
        self.new_client = new_client
        self.canary_ratio = initial_ratio
        self.metrics = {"old": [], "new": []}
    
    def route_request(self, request_func: Callable, model: str, messages: list) -> Any:
        """根据 canary ratio 路由请求"""
        if random.random() < self.canary_ratio:
            # 路由到 HolySheep AI (新)
            start = time.time()
            try:
                response = self.new_client.create_completion(model, messages)
                latency = (time.time() - start) * 1000
                self.metrics["new"].append({"latency": latency, "success": True})
                print(f"🟢 HolySheep AI 路由 | 延迟: {latency:.1f}ms")
                return response
            except Exception as e:
                self.metrics["new"].append({"latency": 0, "success": False, "error": str(e)})
                print(f"🔴 HolySheep 失败，回退到旧 API: {e}")
                return self.old_client.create_completion(model, messages)
        else:
            # 路由到旧 API
            start = time.time()
            response = self.old_client.create_completion(model, messages)
            latency = (time.time() - start) * 1000
            self.metrics["old"].append({"latency": latency, "success": True})
            print(f"⚪ 旧 API 路由 | 延迟: {latency:.1f}ms")
            return response
    
    def increase_traffic(self, step: float = 0.1):
        """逐步增加 HolySheep 流量比例"""
        self.canary_ratio = min(1.0, self.canary_ratio + step)
        print(f"📈 流量比例更新: {self.canary_ratio * 100:.0f}% → HolySheep AI")
    
    def get_metrics_report(self) -> dict:
        """生成迁移指标报告"""
        new_latencies = [m["latency"] for m in self.metrics["new"] if m["success"]]
        old_latencies = [m["latency"] for m in self.metrics["old"] if m["success"]]
        
        return {
            "canary_ratio": f"{self.canary_ratio * 100:.1f}%",
            "holy_new_avg_latency": f"{sum(new_latencies)/len(new_latencies):.1f}ms" if new_latencies else "N/A",
            "old_avg_latency": f"{sum(old_latencies)/len(old_latencies):.1f}ms" if old_latencies else "N/A",
            "holy_success_rate": f"{len([m for m in self.metrics['new'] if m['success']])/max(1, len(self.metrics['new']))*100:.1f}%"
        }


使用示例

canary = CanaryDeployment(
    old_client=old_client,
    new_client=holy_client,
    initial_ratio=0.1
)


渐进式迁移

for day in range(1, 8):
    canary.increase_traffic(0.1)
    print(f"\n📅 Day {day} 报告: {canary.get_metrics_report()}")

30天迁移成果指标

指标迁移前迁移后提升
平均延迟 (P50)420ms180ms📉 -57%
P99 延迟850ms290ms📉 -66%
Function Calling 成功率78%99.2%📈 +27%
月账单$4.200$680📉 -84%
Token 成本/1M$8.00$2.50📉 -69%

这家柏林的 Startup CTO 在一次技术评审中表示："迁移到 HolySheep AI 后，我们的单位经济模型从亏损转为盈利，月度云成本削减了 84%，而响应速度反而提升了一倍以上。"

作者实战经验：Function Calling 的技术细节

作为一名在 AI API 集成领域有 5 年实战经验的技术架构师，我在过去三个月里深度使用 HolySheep AI 的 Gemini 2.5 Flash 模型进行 Function Calling 开发。以下是我总结的核心经验和最佳实践：

为什么选择 Gemini 2.5 Flash 进行 Function Calling？

在我的实际项目中，Gemini 2.5 Flash 展现了卓越的性价比：

根据我的测试，DeepSeek V3.2 ($0.42/MTok) 虽然价格更低，但在复杂 Function Calling 场景下的准确率仅为 89%，对于生产级应用仍需谨慎。

计算器工具实战：完整代码实现

项目概述

本教程将构建一个智能计算器工具，支持：

完整代码实现

import json
import math
from typing import Optional, Union
from openai import OpenAI


============================================


HolySheep AI 客户端初始化


============================================

client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)


============================================


Function Calling 函数定义


============================================


def calculate_basic(
    operation: str,
    num1: float,
    num2: float
) -> dict:
    """
    基础算术计算器
    
    Args:
        operation: 运算类型 - add, subtract, multiply, divide
        num1: 第一个数字
        num2: 第二个数字
    
    Returns:
        dict: 包含结果的字典
    """
    operations = {
        "add": lambda a, b: a + b,
        "subtract": lambda a, b: a - b,
        "multiply": lambda a, b: a * b,
        "divide": lambda a, b: a / b if b != 0 else "Error: Division by zero"
    }
    
    result = operations.get(operation, lambda a, b: "Unknown operation")(num1, num2)
    
    return {
        "operation": operation,
        "num1": num1,
        "num2": num2,
        "result": result,
        "formula": f"{num1} {get_symbol(operation)} {num2} = {result}"
    }

def get_symbol(operation: str) -> str:
    """获取运算符号"""
    symbols = {
        "add": "+",
        "subtract": "-",
        "multiply": "×",
        "divide": "÷"
    }
    return symbols.get(operation, "?")

def calculate_scientific(
    operation: str,
    num: float,
    num2: Optional[float] = None
) -> dict:
    """
    科学计算器
    
    Args:
        operation: 运算类型 - square, sqrt, power, log, sin, cos, tan
        num: 主数字
        num2: 可选的第二个数字（用于幂运算）
    
    Returns:
        dict: 包含结果的字典
    """
    try:
        if operation == "square":
            result = num ** 2
            formula = f"{num}² = {result}"
        elif operation == "sqrt":
            result = math.sqrt(num)
            formula = f"√{num} = {result}"
        elif operation == "power":
            result = num ** num2
            formula = f"{num}^{num2} = {result}"
        elif operation == "log":
            result = math.log10(num)
            formula = f"log₁₀({num}) = {result}"
        elif operation == "sin":
            result = math.sin(math.radians(num))
            formula = f"sin({num}°) = {result}"
        elif operation == "cos":
            result = math.cos(math.radians(num))
            formula = f"cos({num}°) = {result}"
        elif operation == "tan":
            result = math.tan(math.radians(num))
            formula = f"tan({num}°) = {result}"
        else:
            return {"error": f"Unknown scientific operation: {operation}"}
        
        return {
            "operation": operation,
            "input": num if num2 is None else f"{num}, {num2}",
            "result": result,
            "formula": formula
        }
    except Exception as e:
        return {"error": str(e)}

def convert_currency(
    amount: float,
    from_currency: str,
    to_currency: str,
    rate: float = 1.0
) -> dict:
    """
    货币转换器（默认汇率 ¥1=$1）
    
    Args:
        amount: 金额
        from_currency: 源货币 (CNY, USD, EUR, JPY)
        to_currency: 目标货币
        rate: 自定义汇率（默认为 1，即 ¥1=$1）
    
    Returns:
        dict: 转换结果
    """
    currencies = {"CNY": "¥", "USD": "$", "EUR": "€", "JPY": "¥"}
    
    result = amount * rate
    from_symbol = currencies.get(from_currency, from_currency)
    to_symbol = currencies.get(to_currency, to_currency)
    
    return {
        "original": f"{from_symbol}{amount}",
                "converted": f"{to_symbol}{result:.2f}",
                "rate": rate,
                "formula": f"{amount} {from_currency} = {result:.2f} {to_currency}"
    }

def calculate_percentage(
    operation: str,
    value: float,
    percentage: float
) -> dict:
    """
    百分比计算器
    
    Args:
        operation: 运算类型 - percent_of, percent_increase, percent_decrease
        value: 基础值
        percentage: 百分比值
    
    Returns:
        dict: 计算结果
    """
    if operation == "percent_of":
        result = value * (percentage / 100)
        formula = f"{percentage}% × {value} = {result}"
    elif operation == "percent_increase":
        result = value * (1 + percentage / 100)
        formula = f"{value} + {percentage}% = {result}"
    elif operation == "percent_decrease":
        result = value * (1 - percentage / 100)
        formula = f"{value} - {percentage}% = {result}"
    else:
        return {"error": f"Unknown percentage operation: {operation}"}
    
    return {
        "operation": operation,
        "value": value,
        "percentage": percentage,
        "result": result,
        "formula": formula
    }


============================================


可用函数列表（用于 Function Calling）


============================================


functions = [
    {
        "type": "function",
        "function": {
            "name": "calculate_basic",
            "description": "执行基础算术运算（加、减、乘、除）。适用于简单的数学计算。",
            "parameters": {
                "type": "object",
                "properties": {
                    "operation": {
                        "type": "string",
                        "enum": ["add", "subtract", "multiply", "divide"],
                        "description": "运算类型：add（加）、subtract（减）、multiply（乘）、divide（除）"
                    },
                    "num1": {
                        "type": "number",
                        "description": "第一个数字"
                    },
                    "num2": {
                        "type": "number",
                        "description": "第二个数字"
                    }
                },
                "required": ["operation", "num1", "num2"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_scientific",
            "description": "执行科学计算（平方、开方、幂、对数、三角函数）。",
            "parameters": {
                "type": "object",
                "properties": {
                    "operation": {
                        "type": "string",
                        "enum": ["square", "sqrt", "power", "log", "sin", "cos", "tan"],
                        "description": "运算类型：square（平方）、sqrt（平方根）、power（幂）、log（对数）、sin/cos/tan（三角函数）"
                    },
                    "num": {
                        "type": "number",
                        "description": "主数字"
                    },
                    "num2": {
                        "type": "number",
                        "description": "可选的第二个数字（用于幂运算）"
                    }
                },
                "required": ["operation", "num"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "convert_currency",
            "description": "在不同货币之间转换。使用默认汇率 ¥1=$1，可自定义其他汇率。",
            "parameters": {
                "type": "object",
                "properties": {
                    "amount": {
                        "type": "number",
                        "description": "要转换的金额"
                    },
                    "from_currency": {
                        "type": "string",
                        "enum": ["CNY", "USD", "EUR", "JPY"],
                        "description": "源货币代码"
                    },
                    "to_currency": {
                        "type": "string",
                        "enum": ["CNY", "USD", "EUR", "JPY"],
                        "description": "目标货币代码"
                    },
                    "rate": {
                        "type": "number",
                        "description": "汇率（默认为 1.0，即 ¥1=$1）"
                    }
                },
                "required": ["amount", "from_currency", "to_currency"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_percentage",
            "description": "执行百分比相关计算。",
            "parameters": {
                "type": "object",
                "properties": {
                    "operation": {
                        "type": "string",
                        "enum": ["percent_of", "percent_increase", "percent_decrease"],
                        "description": "运算类型：percent_of（百分比值）、percent_increase（增长）、percent_decrease（减少）"
                    },
                    "value": {
                        "type": "number",
                        "description": "基础值"
                    },
                    "percentage": {
                        "type": "number",
                        "description": "百分比值"
                    }
                },
                "required": ["operation", "value", "percentage"]
            }
        }
    }
]


============================================


主交互循环


============================================


def process_message(user_message: str) -> str:
    """处理用户消息并返回响应"""
    
    response = client.chat.completions.create(
        model="gemini-2.0-flash-exp",
        messages=[
            {
                "role": "system",
                "content": """你是一个智能计算器助手。仔细分析用户的计算请求，选择最合适的函数。
                
支持的计算类型：
1. calculate_basic: 基础算术（加减乘除）
   - operation: "add", "subtract", "multiply", "divide"
   
2. calculate_scientific: 科学计算
   - operation: "square"(平方), "sqrt"(平方根), "power"(幂), "log"(对数), "sin/cos/tan"(三角函数)
   
3. convert_currency: 货币转换（默认 ¥1=$1）
   - 支持: CNY, USD, EUR, JPY
   
4. calculate_percentage: 百分比计算
   - operation: "percent_of", "percent_increase", "percent_decrease"

对于每个计算请求，调用相应的函数并展示结果。"""
            },
            {
                "role": "user",
                "content": user_message
            }
        ],
        tools=functions,
        tool_choice="auto",
        temperature=0.3
    )
    
    assistant_message = response.choices[0].message
    
    # 检查是否有函数调用
    if assistant_message.tool_calls:
        results = []
        for tool_call in assistant_message.tool_calls:
            function_name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)
            
            print(f"\n🔧 调用函数: {function_name}")
            print(f"📥 参数: {json.dumps(arguments, indent=2, ensure_ascii=False)}")
            
            # 执行函数
            if function_name == "calculate_basic":
                result = calculate_basic(**arguments)
            elif function_name == "calculate_scientific":
                result = calculate_scientific(**arguments)
            elif function_name == "convert_currency":
                result = convert_currency(**arguments)
            elif function_name == "calculate_percentage":
                result = calculate_percentage(**arguments)
            else:
                result = {"error": f"Unknown function: {function_name}"}
            
            print(f"📤 结果: {json.dumps(result, indent=2, ensure_ascii=False)}")
            results.append(result)
        
        # 返回结果摘要
        return f"计算完成！\n" + "\n".join([r.get("formula", str(r)) for r in results])
    
    return assistant_message.content


============================================


测试示例


============================================


if __name__ == "__main__":
    print("=" * 60)
    print("🧮 HolySheep AI 智能计算器")
    print("=" * 60)
    
    test_queries = [
        "计算 125 + 347 等于多少？",
        "求 144 的平方根",
        "把 1000 元人民币转换成美元（使用 ¥1=$1 汇率）",
        "500 增长 15% 后是多少？"
    ]
    
    for i, query in enumerate(test_queries, 1):
        print(f"\n{'='*60}")
        print(f"📝 测试 {i}: {query}")
        print("-" * 60)
        result = process_message(query)
        print(f"✅ {result}")

执行结果示例

============================================================
🧮 HolySheep AI 智能计算器
============================================================

============================================================
📝 测试 1: 计算 125 + 347 等于多少？
------------------------------------------------------------
🔧 调用函数: calculate_basic
📥 参数: {
  "operation": "add",
  "num1": 125,
  "num2": 347
}
📤 结果: {
  "operation": "add",
  "num1": 125,
  "num2": 347,
  "result": 472,
  "formula": "125 + 347 = 472"
}
✅ 计算完成！
125 + 347 = 472

============================================================
📝 测试 2: 求 144 的平方根
------------------------------------------------------------
🔧 调用函数: calculate_scientific
📥 参数: {
  "operation": "sqrt",
  "num": 144
}
📤 结果: {
  "operation": "sqrt",
  "input": 144,
  "result": 12.0,
  "formula": "√144 = 12.0"
}
✅ 计算完成！
√144 = 12.0

============================================================
📝 测试 3: 把 1000 元人民币转换成美元（使用 ¥1=$1 汇率）
------------------------------------------------------------
🔧 调用函数: convert_currency
📥 参数: {
  "amount": 1000,
  "from_currency": "CNY",
  "to_currency": "USD",
  "rate": 1.0
}
📤 结果: {
  "original": "¥1000",
  "converted": "$1000.00",
  "rate": 1.0,
  "formula": "1000 CNY = 1000.00 USD"
}
✅ 计算完成！
1000 CNY = 1000.00 USD

============================================================
📝 测试 4: 500 增长 15% 后是多少？
------------------------------------------------------------
🔧 调用函数: calculate_percentage
📥 参数: {
  "operation": "percent_increase",
  "value": 500,
  "percentage": 15
}
📤 结果: {
  "operation": "percent_increase",
  "value": 500,
  "percentage": 15,
  "result": 575.0,
  "formula": "500 + 15% = 575.0"
}
✅ 计算完成！
500 + 15% = 575.0

Häufige Fehler und Lösungen

在我指导多个客户进行 HolySheep AI 迁移的过程中，总结了以下常见错误及解决方案：

错误 1：API Key 未正确设置导致 401 错误

# ❌ 错误示例
client = OpenAI(
    api_key="sk-xxx...",  # 直接硬编码
    base_url="https://api.holysheep.ai/v1"
)


✅ 正确做法

import os
from dotenv import load_dotenv

load_dotenv()  # 从 .env 文件加载

client = OpenAI(
    api_key=os.environ.get("HOLYSHEEP_API_KEY"),  # 环境变量
    base_url="https://api.holysheep.ai/v1"
)


验证 key 是否正确

def validate_api_key():
    """验证 API Key 是否有效"""
    try:
        response = client.chat.completions.create(
            model="gemini-2.0-flash-exp",
            messages=[{"role": "user", "content": "test"}]
        )
        print(f"✅ API Key 有效 | 使用 token: {response.usage.total_tokens}")
        return True
    except Exception as e:
        error_msg = str(e)
        if "401" in error_msg:
            print("🔴 401 错误：API Key 无效或已过期")
            print("   解决：前往 https://www.holysheep.ai/register 获取新 key")
        elif "403" in error_msg:
            print("🔴 403 错误：权限不足")
        return False

错误 2：Function Calling 参数类型不匹配

# ❌ 错误示例

模型返回字符串类型的数字，但函数期望 float

tool_call.function.arguments = '{"num1": "125", "num2": "347"}'

直接传入会导致类型错误



✅ 正确做法：显式类型转换

import json
from typing import Any

def safe_parse_arguments(arguments: str, schema: dict) -> dict:
    """安全解析 Function Calling 参数并进行类型转换"""
    try:
        args = json.loads(arguments)
    except json.JSONDecodeError:
        raise ValueError("Invalid JSON arguments")
    
    converted = {}
    properties = schema.get("parameters", {}).get("properties", {})
    
    for key, value in args.items():
        if key not in properties:
            continue
            
        expected_type = properties[key].get("type")
        
        if expected_type == "number":
            converted[key] = float(value)
        elif expected_type == "integer":
            converted[key] = int(float(value))  # 先转 float 再转 int
        elif expected_type == "string":
            converted[key] = str(value)
        elif expected_type == "boolean":
            converted[key] = bool(value)
        else:
            converted[key] = value
    
    return converted


使用示例

arguments = '{"num1": "125", "num2": "347"}'
schema = functions[0]["function"]  # calculate_basic 的 schema

try:
    safe_args = safe_parse_arguments(arguments, schema)
    result = calculate_basic(**safe_args)
    print(f"✅ 计算结果: {result['formula']}")
except Exception as e:
    print(f"🔴 错误: {e}")

错误 3：忽略 rate limit 导致 429 错误

# ❌ 错误示例：高频调用导致限流
for i in range(1000):
    response = client.chat.completions.create(...)  # 会被限流


✅ 正确做法：实现指数退避重试

import time
import asyncio
from functools import wraps

def retry_with_exponential_backoff(
    max_retries: int = 5,
    initial_delay: float = 1.0,
    max_delay: float = 60.0,
    backoff_factor: float = 2.0
):
    """指数退避装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            delay = initial_delay
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if "429" in str(e) or "rate limit" in str(e).lower():
                        if attempt == max_retries - 1:
                            raise
                        wait_time = min(delay, max_delay)
                        print(f"⚠️ Rate limit reached. Waiting {wait_time}s... (Attempt {attempt + 1}/{max_retries})")
                        time.sleep(wait_time)
                        delay *= backoff_factor
                    else:
                        raise
        return wrapper
    return decorator

@retry_with_exponential_backoff(max_retries=3, initial_delay=1.0)
def call_with_retry(messages: list) -> dict:
    """带重试的 API 调用"""
    response = client.chat.completions.create(
        model="gemini-2.0-flash-exp",
        messages=messages,
        tools=functions,
        tool_choice="auto"
    )
    return response


异步版本

async def async_call_with_retry(messages: list, max_retries: int = 3) -> dict:
    """异步版本带重试"""
    for attempt in range(max_retries):
        try:
            response = await asyncio.to_thread(
                client.chat.completions.create,
                model="gemini-2.0-flash-exp",
                messages=messages,
                tools=functions,
                tool_choice="auto"
            )
            return response
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            wait = min(2 ** attempt, 30)
            print(f"⚠️ 尝试 {attempt + 1} 失败，{wait}s 后重试...")
            await asyncio.sleep(wait)


使用示例

async def main():
    messages = [{"role": "user", "content": "计算 10 + 20"}]
    result = await async_call_with_retry(messages)
    print(f"✅ 响应: {result.choices[0].message.content}")

asyncio.run(main())

错误 4：tool_choice 设置不当导致意外行为

# ❌ 错误示例
response = client.chat.completions.create(
    model="gemini-2.0-flash-exp",
    messages=messages,
    tools=functions,
    tool_choice="required"  # 强制要求函数调用，但可能不需要
)


✅ 正确做法：根据场景选择合适的 tool_choice

def create_completion_with_tools(
    messages: list,
    force_tool: bool = False,
    specific_function: str = None
) -> dict:
    """
    创建带 Function Calling 的请求
    
    Args:
        messages: 对话消息
        force_tool: 是否强制使用工具
        specific_function: 指定特定函数名（如果需要）
    """
    if specific_function:
        # 指定特定函数
        tool_choice = {
            "type": "function",
            "function": {"name": specific_function}
        }
    elif force_tool:
        # 强制使用工具（不指定具体函数）
        tool_choice = "required"
    else:
        # 自动选择（推荐）
        tool_choice = "auto"
    
    return client.chat.completions.create(
        model="gemini-2.0-flash-exp",
        messages=messages,
        tools=functions,
        tool_choice=tool_choice,
        temperature=0.3
    )


使用场景示例


场景1：计算器（自动判断是否需要调用函数）

response1 = create_completion_with_tools(
    messages=[{"role": "user", "content": "今天天气如何？"}],
    force_tool=False  # 可能不需要调用任何函数
)


场景2：强制使用计算器

response2 = create_completion_with_tools(
    messages=[{"role": "user", "content": "计算 100+200"}

Verwandte Ressourcen
Verwandte Artikel