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

Łączenie narzędzi serwerowych i klienckich

Lekcja 12 z 16 Zaktualizowano 30 lipca 2026 Programista
Na tej stronie
  1. Przepływy pracy hybrydowe
  2. Łączenie narzędzi serwerowych i funkcji
  3. Hybrydowy przepływ wykonania
  4. Typowe wzorce łączenia
  5. max_turns a narzędzia hybrydowe
  6. Kontekst wieloturkowy z pamięcią masową
  7. Kluczowe wnioski

Przepływy pracy hybrydowe

Prawdziwa moc interfejsu API Responses ujawnia się, gdy połączysz narzędzia serwerowe (wykonywane automatycznie przez xAI) i narzędzia klienckie (twoje własne funkcje) w ramach jednego żądania. Model autonomicznie koordynuje te narzędzia, tworząc złożone przepływy pracy w zaledwie kilku liniach kodu.

Łączenie narzędzi serwerowych i funkcji

response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Search for the latest Ligue 1 soccer results and send a summary to my team.",
    tools=[
        {"type": "web_search"},
        {
            "type": "function",
            "name": "send_team_message",
            "description": "Sends a message to the team via Slack",
            "parameters": {
                "type": "object",
                "properties": {
                    "channel": {"type": "string"},
                    "message": {"type": "string"}
                },
                "required": ["channel", "message"]
            }
        }
    ]
)

W tym scenariuszu model:

  1. Automatycznie uruchamia web_search (po stronie serwera), aby znaleźć wyniki,
  2. Włącza dane do podsumowania,
  3. Wywołuje send_team_message (po stronie klienta), dzięki czemu twój kod wysyła wiadomość na Slacka.

Hybrydowy przepływ wykonania

Przepływ różni się w zależności od typu narzędzia:

Tylko narzędzia serwerowe

Request → [model → web_search → result → model] → Final response

Wszystko dzieje się po stronie xAI. Otrzymujesz finalną odpowiedź bezpośrednio z zintegrowanymi wynikami.

Tylko narzędzia klienckie

Request → [model → function_call] → PAUSE
Your code executes the function
Result → [model] → Final response

Model wstrzymuje działanie, twój kod wykonuje funkcję, a następnie odsyłasz wynik z powrotem.

Przepływ hybrydowy

Request → [model → web_search → result → model → function_call] → PAUSE
Your code executes the function
Result → [model] → Final response

Model najpierw używa narzędzi serwerowych (automatycznie), a następnie wywołuje twoją funkcję, gdy potrzebuje twojej infrastruktury.

Typowe wzorce łączenia

Wyszukiwanie + Działanie

Połącz web_search lub x_search z funkcją wykonującą działanie:

tools = [
    {"type": "web_search"},
    {"type": "x_search"},
    {
        "type": "function",
        "name": "create_report",
        "description": "Creates a report in the CRM",
        "parameters": {
            "type": "object",
            "properties": {
                "title": {"type": "string"},
                "content": {"type": "string"},
                "tags": {"type": "array", "items": {"type": "string"}}
            },
            "required": ["title", "content"]
        }
    }
]

Obliczenia + Powiadomienie

Połącz code_interpreter z funkcją powiadamiającą:

tools = [
    {"type": "code_interpreter"},
    {
        "type": "function",
        "name": "send_alert",
        "description": "Sends an alert if a threshold is exceeded",
        "parameters": {
            "type": "object",
            "properties": {
                "metric": {"type": "string"},
                "value": {"type": "number"},
                "threshold": {"type": "number"}
            },
            "required": ["metric", "value"]
        }
    }
]

max_turns a narzędzia hybrydowe

Zachowanie parametru max_turns jest kluczowe w kontekście hybrydowym:

  • max_turns ogranicza liczbę tur po stronie serwera w ramach pojedynczego żądania,
  • Gdy model wywołuje funkcję kliencką, a twój kod zwraca wynik, następuje nowa alokacja limitu max_turns.

W praktyce oznacza to, że wywołania klienckie nie wyczerpują twojego budżetu tur serwerowych. Model może przeprowadzić 3 wyszukiwania w sieci, wywołać twoją funkcję, a następnie wykonać kolejne 3 wyszukiwania po otrzymaniu wyniku.

Kontekst wieloturkowy z pamięcią masową

W przypadku złożonych przepływów pracy obejmujących wiele interakcji połącz mechanizmy przechowywania i łańcuchowania:

# Tura 1: wstępne wyszukiwanie
r1 = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Analyze AI market trends.",
    tools=[{"type": "web_search"}, {"type": "code_interpreter"}],
    store=True,
    max_turns=5
)

# Tura 2: pogłębienie o dane wewnętrzne
r2 = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Compare with our internal data.",
    tools=[{
        "type": "function",
        "name": "query_internal_db",
        "description": "Queries the internal database",
        "parameters": {"type": "object", "properties": {"query": {"type": "string"}}}
    }],
    previous_response_id=r1.id,
    store=True
)

Kluczowe wnioski

  • Łącz narzędzia serwerowe i funkcje klienckie w jednym żądaniu, aby tworzyć przepływy hybrydowe,
  • Narzędzia serwerowe wykonują się automatycznie; funkcje klienckie wstrzymują generowanie,
  • Limit max_turns resetuje się po każdej wymianie z klientem,
  • Typowe wzorce: wyszukiwanie + działanie, obliczenia + powiadomienie, agregacja z wielu źródeł,
  • Używaj store: true oraz previous_response_id do obsługi przepływów wieloturkowych.