Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Brugerdefinerede funktioner (funktionkald)

Lektion 11 af 16 Opdateret 30. juli 2026 Udvikler
På denne side
  1. Forbind Grok til dine egne tjenester
  2. Sådan fungerer det
  3. Deklarér en funktion
  4. Modtag funktionkaldet
  5. Returnér resultatet
  6. Bedste praksis for beskrivelser
  7. Håndtering af fejl
  8. Vigtige pointer

Forbind Grok til dine egne tjenester

Serverværktøjer (web_search, x_search, code_interpreter) er nyttige, men begrænset til xAI-tjenester. Med brugerdefinerede function-værktøjer kan du forbinde Grok til ethvert API eller enhver tjeneste i din infrastruktur.

Sådan fungerer det

Funktionkald følger en cyklus på tre trin:

  1. Deklaration: Du beskriver dine funktioner (navn, beskrivelse, parametre) i anmodningen.
  2. Kald: Modellen genererer et funktionkald med de passende argumenter og pauser genereringen.
  3. Resultat: Din kode udfører funktionen, hvorefter du sender resultatet tilbage til modellen, så den kan formulere sit svar.

Deklarér en funktion

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

Beskrivelsen af hver funktion og hvert parameter er afgørende. Modellen bruger dem til at beslutte, hvornår funktionen skal kaldes, og hvordan argumenterne skal udfyldes.

Modtag funktionkaldet

Når modellen beslutter at kalde din funktion, indeholder svaret et function_call-element:

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

Feltet arguments er en JSON-streng, som du skal parse. call_id identificerer dette specifikke kald.

Returnér resultatet

Efter at have udført funktionen i din kode, returnerer du resultatet:

import json

# 1. Initial request
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. Check if the model wants to call a function
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)

        # 3. Execute your function
        weather_data = get_weather_from_api(args["city"])

        # 4. Return the result to the model
        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)

Bedste praksis for beskrivelser

Modellen er afhængig af beskrivelser for at forstå dine funktioner. Vær præcis:

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

Brug enum til foruddefinerede værdier, en detaljeret description for hvert parameter, og markér kun essentielle parametre som required.

Håndtering af fejl

Hvis din funktion fejler, skal du returnere fejlen som resultatet:

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
)

Modellen fortolker fejlen og kan enten omformulere sit svar eller prøve en anden tilgang.

Vigtige pointer

  • Brugerdefinerede funktioner forbinder Grok til dine egne tjenester.
  • Cyklussen er: deklarér, modtag kaldet, udfør, returnér resultatet.
  • Beskrivelser af funktioner og parametre styrer modellens valg.
  • Feltet arguments er en JSON-streng, der skal parses på klientsiden.
  • Returnér fejl som resultater, så modellen kan tilpasse sig.