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

Funkcje niestandardowe (wywoływanie funkcji)

Lekcja 11 z 16 Zaktualizowano 30 lipca 2026 Programista
Na tej stronie
  1. Podłącz Groka do własnych usług
  2. Jak to działa
  3. Deklaracja funkcji
  4. Odbiór wywołania funkcji
  5. Zwracanie wyniku
  6. Najlepsze praktyki dotyczące opisów
  7. Obsługa błędów
  8. Kluczowe wnioski

Podłącz Groka do własnych usług

Narzędzia serwerowe (web_search, x_search, code_interpreter) są przydatne, ale ograniczają się do usług xAI. Dzięki niestandardowym narzędziom typu function możesz podłączyć Groka do dowolnego API lub usługi w swojej infrastrukturze.

Jak to działa

Wywoływanie funkcji przebiega w trzech krokach:

  1. Deklaracja: Opisujesz swoje funkcje (nazwa, opis, parametry) w żądaniu.
  2. Wywołanie: Model generuje wywołanie funkcji z odpowiednimi argumentami i wstrzymuje generowanie odpowiedzi.
  3. Wynik: Twój kod wykonuje funkcję, a następnie wysyłasz wynik z powrotem do modelu, aby mógł sformułować odpowiedź.

Deklaracja funkcji

{
  "model": "grok-4.20-0309-reasoning",
  "input": "Book me a table for 2 people tonight at 8 PM.",
  "tools": [{
    "type": "function",
    "name": "book_restaurant",
    "description": "Books a table at a restaurant",
    "parameters": {
      "type": "object",
      "properties": {
        "restaurant_name": {
          "type": "string",
          "description": "Restaurant name"
        },
        "date": {
          "type": "string",
          "description": "Date in YYYY-MM-DD format"
        },
        "time": {
          "type": "string",
          "description": "Time in HH:MM format"
        },
        "guests": {
          "type": "integer",
          "description": "Number of guests"
        }
      },
      "required": ["date", "time", "guests"]
    }
  }]
}

Opis każdej funkcji i parametru ma kluczowe znaczenie. Model wykorzystuje je do podjęcia decyzji, kiedy wywołać funkcję i jak wypełnić argumenty.

Odbiór wywołania funkcji

Gdy model zdecyduje się wywołać Twoją funkcję, odpowiedź zawiera element function_call:

{
  "id": "resp-xyz789",
  "status": "completed",
  "output": [{
    "type": "function_call",
    "name": "book_restaurant",
    "arguments": "{\"date\": \"2026-04-03\", \"time\": \"20:00\", \"guests\": 2}",
    "call_id": "call-abc123"
  }]
}

Pole arguments to ciąg JSON, który musisz przetworzyć (parse). Pole call_id identyfikuje to konkretne wywołanie.

Zwracanie wyniku

Po wykonaniu funkcji w swoim kodzie zwróć wynik:

import json

# 1. Początkowe żądanie
response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="What's the weather like in Paris?",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Retrieves current weather",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }]
)

# 2. Sprawdź, czy model chce wywołać funkcję
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)

        # 3. Wykonaj swoją funkcję
        weather_data = get_weather_from_api(args["city"])

        # 4. Zwróć wynik do modelu
        final = client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(weather_data)
            }],
            previous_response_id=response.id
        )
        print(final.output[0].content[0].text)

Najlepsze praktyki dotyczące opisów

Model polega na opisach, aby zrozumieć Twoje funkcje. Bądź precyzyjny:

{
  "name": "search_products",
  "description": "Searches for products in the e-commerce catalog. Returns the top 10 results sorted by relevance. Supports search by name, category, or price range.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Search terms (product name, brand, keyword)"
      },
      "category": {
        "type": "string",
        "enum": ["electronics", "clothing", "home", "sports"],
        "description": "Product category to filter"
      },
      "max_price": {
        "type": "number",
        "description": "Maximum price in euros"
      }
    },
    "required": ["query"]
  }
}

Używaj enum dla wartości zdefiniowanych z góry, szczegółowego description dla każdego parametru i oznaczaj jako required tylko parametry niezbędne.

Obsługa błędów

Jeśli Twoja funkcja zakończy się niepowodzeniem, zwróć błąd jako wynik:

try:
    result = call_external_api(args)
    output = json.dumps(result)
except Exception as e:
    output = json.dumps({"error": str(e)})

final = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input=[{
        "type": "function_call_output",
        "call_id": call_id,
        "output": output
    }],
    previous_response_id=response.id
)

Model zinterpretuje błąd i może przeformułować swoją odpowiedź lub spróbować innego podejścia.

Kluczowe wnioski

  • Funkcje niestandardowe łączą Groka z Twoimi własnymi usługami.
  • Cykl wygląda następująco: zadeklaruj, odbierz wywołanie, wykonaj, zwróć wynik.
  • Opisy funkcji i parametrów kierują wyborem modelu.
  • Pole arguments to ciąg JSON do przetworzenia po stronie klienta.
  • Zwracaj błędy jako wyniki, aby model mógł się dostosować.