Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Kombination af server- og klientværktøjer

Lektion 12 af 16 Opdateret 30. juli 2026 Udvikler
På denne side
  1. Hybride arbejdsgange
  2. Kombination af serverværktøjer og funktioner
  3. Den hybride eksekveringsflow
  4. Almindelige kombinationsmønstre
  5. max_turns og hybride værktøjer
  6. Flertrins kontekst med lagring
  7. Vigtige pointer

Hybride arbejdsgange

Den virkelige styrke ved Responses API kommer til sin ret, når du kombinerer serverværktøjer (som udføres automatisk af xAI) og klientværktøjer (dine egne funktioner) i en enkelt anmodning. Modellen orchestrerer disse værktøjer autonomt og skaber komplekse arbejdsgange med blot få linjer kode.

Kombination af serverværktøjer og funktioner

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

I dette scenarie gør modellen følgende:

  1. Udløser automatisk web_search (på serversiden) for at finde resultaterne
  2. Indarbejder dataene i et resumé
  3. Kalder send_team_message (på klientsiden), så din kode sender Slack-beskeden

Den hybride eksekveringsflow

Flowet varierer afhængigt af værktøjstypen:

Kun serverværktøjer

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

Alt sker på xAIs side. Du modtager det endelige svar direkte med resultaterne integreret.

Kun klientværktøjer

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

Modellen pause, din kode udfører funktionen, og derefter sender du resultatet tilbage.

Hybride flow

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

Modellen bruger først serverværktøjer (automatisk) og kalder derefter din funktion, når den har brug for din infrastruktur.

Almindelige kombinationsmønstre

Søgning + handling

Kombinér web_search eller x_search med en handlingsfunktion:

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

Beregning + notifikation

Kombinér code_interpreter med en notifikationsfunktion:

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 og hybride værktøjer

Adfærden for max_turns er vigtig i en hybrid kontekst:

  • max_turns begrænser antallet af server-side ture inden for en enkelt anmodning
  • Når modellen kalder en klientfunktion, og din kode returnerer resultatet, starter en ny tildeling af max_turns

I praksis betyder det, at klientkald ikke udtømmer dit budget for server-ture. Modellen kan udføre 3 websøgninger, kalde din funktion og derefter udføre 3 yderligere søgninger, efter at have modtaget resultatet.

Flertrins kontekst med lagring

Til komplekse arbejdsgange, der strækker sig over flere interaktioner, kan du kombinere lagring og kædning:

# Turn 1: initial search
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
)

# Turn 2: deepen with your internal data
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
)

Vigtige pointer

  • Kombinér serverværktøjer og klientfunktioner i en enkelt anmodning for at skabe hybride arbejdsgange
  • Serverværktøjer udføres automatisk; klientfunktioner pauser genereringen
  • max_turns nulstilles efter hver klient-round-trip
  • Almindelige mønstre: søgning + handling, beregning + notifikation, aggregering fra flere kilder
  • Brug store: true og previous_response_id til flertrins arbejdsgange