outil

Apprenez à connecter les LLM avec des outils externes.

Introduction

Avec la fonctionnalité tools, vous pouvez permettre à votre modèle d’utiliser des outils externes.

Comme l”API d’appel de fonction d’OpenAI, vous pouvez définir des fonctions avec des paramètres et laisser le modèle choisir dynamiquement quelle fonction appeler et quels paramètres lui transmettre.

Voici le processus général d’appel de fonction :

1. Soumettez une requête, en détaillant les fonctions, leurs paramètres et descriptions.

2. Le LLM décide s’il doit activer une fonctionnalité. S’il choisit de ne pas l’activer, il répond dans un langage courant, soit en proposant une solution basée sur sa compréhension intrinsèque, soit en demandant des détails supplémentaires sur la requête et l’utilisation des outils. Lorsqu’il décide d’utiliser un outil, il recommande une API adaptée et les instructions d’utilisation au format JSON.

3. Ensuite, vous implémentez l’appel API dans l’application, envoyez la réponse renvoyée au LLM pour analyse des résultats, et poursuivez avec l’étape suivante.

Actuellement, il n’existe pas de point de terminaison API dédié pour la fonctionnalité tools. Celle-ci doit être utilisée conjointement avec l’API Chat.

Liste des modèles pris en charge

Xinference prend en charge la fonctionnalité tools pour les modèles suivants :

• glm4-chat

• glm4-chat-1m

• llama-3.1-instruct

• llama-3.3-instruct

• qwen1.5-chat

• qwen1.5-moe-chat

• qwen2-instruct

• qwen2-moe-instruct

• qwen2.5-instruct

• qwen2.5-coder-instruct

• QwQ-32B

• qwen3

• Qwen3-Instruct

• Qwen3-Coder

• deepseek-v3

• deepseek-r1-0528

Démarrage rapide

Le paramètre optionnel tools dans l’API Chat peut être utilisé pour fournir des spécifications de fonctions. Son objectif est de permettre au modèle de générer des paramètres de fonction conformes aux spécifications fournies.

Exemple d’utilisation du client OpenAI

import openai

client = openai.Client(
    api_key="cannot be empty",
    base_url="http://<XINFERENCE_HOST>:<XINFERENCE_PORT>/v1"
)
response = client.chat.completions.create(
    model="<MODEL_UID>",
    messages=[{
        "role": "user",
        "content": "Call me an Uber ride type 'Plus' in Berkeley at zipcode 94704 in 10 minutes"
    }],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "uber_ride",
                "description": "Find suitable ride for customers given the location, "
                "type of ride, and the amount of time the customer is "
                "willing to wait as parameters",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "loc": {
                            "type": "int",
                            "description": "Location of the starting place of the Uber ride",
                        },
                        "type": {
                            "type": "string",
                            "enum": ["plus", "comfort", "black"],
                            "description": "Types of Uber ride user is ordering",
                        },
                        "time": {
                            "type": "int",
                            "description": "The amount of time in minutes the customer is willing to wait",
                        },
                    },
                },
            },
        }
    ],
)
print(response.choices[0].message)

Le résultat de sortie est :

{
    "role": "assistant",
    "content": null,
    "tool_calls": [
        "id": "call_ad2f383f-31c7-47d9-87b7-3abe928e629c",
        "type": "function",
        "function": {
            "name": "uber_ride",
            "arguments": "{\"loc\": 94704, \"type\": \"plus\", \"time\": 10}"
        }
    ],
}

Exemple d’utilisation du client Anthropic

import anthropic
import json
import uuid

client = anthropic.Anthropic(
    api_key="cannot be empty",
    base_url="http://localhost:9997"
)

response = client.messages.create(
    model="qwen3",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "What's the weather like in Beijing?"
        }
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Get weather information for a city",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "The city name",
                        },
                    },
                    "required": ["city"]
                },
            },
        }
    ],
    tool_choice={"type": "auto"}
)

Le résultat de sortie est :

{
    "role": "assistant",
    "content": null,
    "tool_calls": [
        "id": "call_26884d11-ff6b-48fb-ada7-734f3fd0dfcc",
        "type": "function",
        "function": {
            "name": "get_weather",
            "arguments": "{\"city\": \"Beijing\"}"
        }
    ],
}

Note

Si le LLM utilise des appels d’outils, la raison d’achèvement sera tool_calls . Sinon, ce sera la raison d’achèvement par défaut.

Note

L’API elle-même n’exécute aucun appel de fonction. Les développeurs doivent utiliser la sortie du modèle pour effectuer les appels de fonction.

Vous pouvez trouver plus d’exemples des capacités des tools dans le cahier de tutoriel.

Appel de fonction

Apprenez un exemple complet qui illustre le processus d’appel de fonction.

https://github.com/xorbitsai/inference/blob/main/examples/FunctionCall.ipynb