Przejdź do głównej treści
Polski— Wybierz język
Menu

Definiowanie narzędzi w formacie JSON

Lekcja 4 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Od teorii do praktyki
  2. Struktura żądania z narzędziami
  3. Kluczowe liczby dotyczące implementacji
  4. Obsługa odpowiedzi tool_call
  5. Wykonanie i zwrócenie wyniku
  6. Definiowanie wielu narzędzi
  7. Sprawdzenie finish_reason
  8. Kluczowe wnioski

Od teorii do praktyki

Rozumiesz już koncepcję wywoływania funkcji oraz strukturę schematów JSON. Czas przejść do konkretnej implementacji. W tej lekcji nauczysz się budować kompletne żądanie z definicjami narzędzi i obsługiwać odpowiedź modelu.

Struktura żądania z narzędziami

Oto kompletne żądanie do API Grok z zdefiniowanym narzędziem:

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
)

Zwróć uwagę na zagnieżdżoną strukturę: obiekt tools zawiera tablicę, gdzie każdy element posiada pole type oraz obiekt function ze szczegółami.

Kluczowe liczby dotyczące implementacji

200
Maksymalna liczba narzędzi na żądanie
6
Obsługiwane typy JSON
3
Kompatybilne SDK
1
Żądanie = cały przepływ

Obsługa odpowiedzi tool_call

Gdy model zdecyduje się wywołać funkcję, odpowiedź zawiera tablicę tool_calls:

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

Pole tool_call.function.arguments to ciąg znaków JSON (a nie obiekt Pythona). Musisz go przeanalizować:

import json

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

Wykonanie i zwrócenie wyniku

Po wykonaniu funkcji wysyłasz wynik z powrotem do modelu w drugim wywołaniu:

import json

# 1. Wykonaj funkcję
weather_data = get_weather(city="Paris", unit="celsius")

# 2. Zbuduj wiadomości z wynikiem
messages = [
    {"role": "user", "content": "What's the weather like in Paris?"},
    message,  # Odpowiedź modelu z tool_calls
    {
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(weather_data)
    }
]

# 3. Wywołaj model ponownie z wynikiem
final_response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools
)

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

Wiadomość z rolą tool musi zawierać:

  • tool_call_id: unikalny identyfikator tool_call (aby powiązać go z żądaniem)
  • content: wynik jako ciąg znaków JSON

Definiowanie wielu narzędzi

Możesz zadeklarować dowolną liczbę narzędzi w tablicy tools:

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

Model automatycznie wybierze odpowiednie narzędzie (lub narzędzia) na podstawie żądania użytkownika.

Sprawdzenie finish_reason

Pole finish_reason w odpowiedzi wskazuje, czy model zakończył generowanie odpowiedzi, czy też oczekuje na wynik działania narzędzia:

finish_reason = response.choices[0].finish_reason

if finish_reason == "tool_calls":
    # Model oczekuje na wynik jednego lub więcej narzędzi
    handle_tool_calls(response)
elif finish_reason == "stop":
    # Model zakończył generowanie odpowiedzi
    print(response.choices[0].message.content)

Kluczowe wnioski

  • Żądanie zawiera pola messages oraz tools (definicje)
  • Argumenty tool_call to ciąg JSON wymagający parsowania
  • Wyślij wynik w wiadomości z rolą tool, dołączając tool_call_id
  • Sprawdź finish_reason, aby wiedzieć, czy model oczekuje na wynik
  • Możesz zadeklarować wiele narzędzi – model wybiera automatycznie