Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Definér værktøjer i JSON

Lektion 4 af 14 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Fra teori til praksis
  2. Anmodningsstruktur med værktøjer
  3. Nøgletal for implementeringen
  4. Håndtering af tool_call-svaret
  5. Udfør og returnér resultatet
  6. Definér flere værktøjer
  7. Tjek finish_reason
  8. Vigtige pointer

Fra teori til praksis

Du har nu forstået konceptet bag funktionskald og strukturen i JSON-skemaer. Det er tid til at gå over til den konkrete implementering. I denne lektion lærer du, hvordan du bygger en komplet anmodning med værktøjsdefinitioner og håndterer modellens svar.

Anmodningsstruktur med værktøjer

Her er en komplet anmodning til Grok API med et defineret værktøj:

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.x.ai/v1"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "default": "celsius"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="grok-4.5",
    messages=[
        {"role": "user", "content": "What's the weather like in Paris?"}
    ],
    tools=tools
)

Bemærk den nestede struktur: tools-objektet indeholder et array, hvor hvert element har en type og et function-objekt med detaljerne.

Nøgletal for implementeringen

200
Maks. værktøjer pr. anmodning
6
Understøttede JSON-typer
3
Kompatible SDK'er
1
Anmodning = hele flowet

Håndtering af tool_call-svaret

Når modellen beslutter at kalde en funktion, indeholder svaret et tool_calls-array:

message = response.choices[0].message

if message.tool_calls:
    for tool_call in message.tool_calls:
        print(f"Function: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")
        print(f"ID: {tool_call.id}")

Feltet tool_call.function.arguments er en JSON-streng (ikke et Python-objekt). Du skal parsere den:

import json

args = json.loads(tool_call.function.arguments)
city = args["city"]
unit = args.get("unit", "celsius")

Udfør og returnér resultatet

Når funktionen er udført, sender du resultatet tilbage til modellen i et andet kald:

import json

# 1. Udfør funktionen
weather_data = get_weather(city="Paris", unit="celsius")

# 2. Byg beskederne med resultatet
messages = [
    {"role": "user", "content": "What's the weather like in Paris?"},
    message,  # Modellens svar med tool_calls
    {
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(weather_data)
    }
]

# 3. Kald modellen igen med resultatet
final_response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)

Beskeden med rollen tool skal indeholde:

  • tool_call_id: den unikke identifikator for tool_call (for at linke den til anmodningen)
  • content: resultatet som en JSON-streng

Definér flere værktøjer

Du kan deklarere så mange værktøjer, som du har brug for, i tools-arrayet:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": { ... }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_restaurants",
            "description": "Search for restaurants by city and cuisine type",
            "parameters": { ... }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "book_table",
            "description": "Book a table at a restaurant",
            "parameters": { ... }
        }
    }
]

Modellen vælger automatisk det eller de relevante værktøjer baseret på brugerens anmodning.

Tjek finish_reason

Feltet finish_reason i svaret indikerer, om modellen har afsluttet sit svar, eller om den venter på et værktøjsresultat:

finish_reason = response.choices[0].finish_reason

if finish_reason == "tool_calls":
    # Modellen venter på resultatet af et eller flere værktøjer
    handle_tool_calls(response)
elif finish_reason == "stop":
    # Modellen har afsluttet sit svar
    print(response.choices[0].message.content)

Vigtige pointer

  • Anmodningen indeholder messages og tools (definitioner)
  • Argumenter i tool_call er en JSON-streng, der skal parses
  • Send resultatet i en besked med rollen tool, inklusive tool_call_id
  • Tjek finish_reason for at vide, om modellen venter på et resultat
  • Du kan deklarere flere værktøjer – modellen vælger automatisk