Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Anpassade funktioner (funktionsanrop)

Lektion 11 av 16 Uppdaterad 30 juli 2026 Utvecklare
På denna sida
  1. Koppla Grok till dina egna tjänster
  2. Så fungerar det
  3. Deklarera en funktion
  4. Ta emot funktionsanropet
  5. Returnera resultatet
  6. Bästa praxis för beskrivningar
  7. Felhantering
  8. Viktiga punkter

Koppla Grok till dina egna tjänster

Serververktyg (web_search, x_search, code_interpreter) är användbara men begränsade till xAI:s tjänster. Med anpassade function-verktyg kan du koppla Grok till valfritt API eller någon tjänst i din infrastruktur.

Så fungerar det

Funktionsanrop följer en cykel i tre steg:

  1. Deklaration: Du beskriver dina funktioner (namn, beskrivning, parametrar) i begäran.
  2. Anrop: Modellen genererar ett funktionsanrop med lämpliga argument och pausar genereringen.
  3. Resultat: Din kod exekverar funktionen, varefter du skickar tillbaka resultatet till modellen så att den kan formulera sitt svar.

Deklarera en funktion

{
  "model": "grok-4.20-0309-reasoning",
  "input": "Booka ett bord för 2 personer ikväll kl. 20.00.",
  "tools": [{
    "type": "function",
    "name": "book_restaurant",
    "description": "Bokar ett bord på en restaurang",
    "parameters": {
      "type": "object",
      "properties": {
        "restaurant_name": {
          "type": "string",
          "description": "Restaurangens namn"
        },
        "date": {
          "type": "string",
          "description": "Datum i formatet ÅÅÅÅ-MM-DD"
        },
        "time": {
          "type": "string",
          "description": "Tid i formatet HH:MM"
        },
        "guests": {
          "type": "integer",
          "description": "Antal gäster"
        }
      },
      "required": ["date", "time", "guests"]
    }
  }]
}

Beskrivningen av varje funktion och parameter är avgörande. Modellen använder dem för att avgöra när funktionen ska anropas och hur argumenten ska fyllas i.

Ta emot funktionsanropet

När modellen bestämmer sig för att anropa din funktion innehåller svaret ett function_call-objekt:

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

Fältet arguments är en JSON-sträng som du måste parsa. call_id identifierar detta specifika anrop.

Returnera resultatet

När du har exekverat funktionen i din kod returnerar du resultatet:

import json

# 1. Inledande begäran
response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Hur är vädret i Paris?",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Hämtar aktuellt väder",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }]
)

# 2. Kontrollera om modellen vill anropa en funktion
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)

        # 3. Exekvera din funktion
        weather_data = get_weather_from_api(args["city"])

        # 4. Returnera resultatet till modellen
        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)

Bästa praxis för beskrivningar

Modellen förlitar sig på beskrivningar för att förstå dina funktioner. Var precis:

{
  "name": "search_products",
  "description": "Söker efter produkter i e-handelskatalogen. Returnerar de 10 bästa resultaten sorterade efter relevans. Stöder sökning efter namn, kategori eller prisintervall.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Söktermer (produktnamn, varumärke, nyckelord)"
      },
      "category": {
        "type": "string",
        "enum": ["electronics", "clothing", "home", "sports"],
        "description": "Produktkategori att filtrera efter"
      },
      "max_price": {
        "type": "number",
        "description": "Maximalt pris i euro"
      }
    },
    "required": ["query"]
  }
}

Använd enum för fördefinierade värden, detaljerad description för varje parameter och markera endast nödvändiga parametrar som required.

Felhantering

Om din funktion misslyckas, returnera felet som resultat:

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 tolkar felet och kan formulera om sitt svar eller prova en annan approach.

Viktiga punkter

  • Anpassade funktioner kopplar Grok till dina egna tjänster
  • Cykeln är: deklarera, ta emot anropet, exekvera, returnera resultatet
  • Beskrivningar av funktioner och parametrar styr modellens val
  • Fältet arguments är en JSON-sträng som ska parsas på klientsidan
  • Returnera fel som resultat så att modellen kan anpassa sig