Werkzeug

Erfahren Sie, wie Sie LLMs mit externen Tools verbinden.

Hallo! Wie kann ich Ihnen helfen? Bitte stellen Sie Ihre Frage.

Mit der tools-Funktion können Sie Ihr Modell externe Werkzeuge nutzen lassen.

Wie die OpenAI Function Calling API können Sie Funktionen mit Parametern definieren und das Modell dynamisch entscheiden lassen, welche Funktion aufgerufen werden soll und welche Parameter an diese übergeben werden.

Dies ist der allgemeine Ablauf zum Aufrufen einer Funktion:

1. Sie reichen eine Abfrage ein, die die Funktionen, deren Parameter und Beschreibungen detailliert darlegt.

2. Das LLM entscheidet, ob eine Funktion gestartet wird. Wenn es sich dagegen entscheidet, antwortet es in alltäglicher Sprache und bietet entweder auf Basis seines internen Verständnisses eine Lösung an oder fragt nach weiteren Details zur Abfrage und zur Nutzung der Werkzeuge. Wenn es sich für die Nutzung eines Werkzeugs entscheidet, empfiehlt es geeignete APIs und Anweisungen zur Verwendung im JSON-Format.

3. Als Nächstes implementieren Sie in der Anwendung den API-Aufruf und senden die zurückgegebene Antwort zur Ergebnisanalyse an das LLM, um mit dem nächsten Schritt fortzufahren.

Derzeit gibt es keinen dedizierten API-Endpunkt für die tools-Funktionalität. Sie muss in Verbindung mit der Chat-API verwendet werden.

Unterstützte Modellliste

Xinference unterstützt die folgenden Modelle mit der tools-Funktion:

• 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

Schnellstart

Der optionale Parameter tools in der Chat-API kann zur Bereitstellung von Funktionsspezifikationen verwendet werden. Sein Zweck ist es, dem Modell zu ermöglichen, Funktionsparameter zu generieren, die den bereitgestellten Spezifikationen entsprechen.

Beispiel zur Verwendung des OpenAI-Clients

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)

Das Ausgabeergebnis lautet:

{
    "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}"
        }
    ],
}

Beispiel mit dem Anthropic-Client

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"}
)

Das Ausgabeergebnis lautet:

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

Bemerkung

Wenn das LLM Tool Calls verwendet, wird der Abschlussgrund tool_calls sein. Andernfalls ist es der Standard-Abschlussgrund.

Bemerkung

Die API selbst führt keine Funktionsaufrufe aus. Entwickler müssen die Modellausgabe verwenden, um Funktionsaufrufe durchzuführen.

Sie können weitere Beispiele für die Fähigkeiten von tools im Tutorial-Notebook finden.

Funktionsaufruf

Lernen Sie ein vollständiges Beispiel, das den Prozess des Funktionsaufrufs demonstriert.

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