Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Begrænsninger og bedste praksis

Lektion 3 af 14 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Tekniske begrænsninger ved funktionskald
  2. Maksimum 200 værktøjer pr. anmodning
  3. Modellen garanterer ikke gyldigheden af argumenter
  4. Håndtering af fejl
  5. Unikke og eksplicitte navne
  6. Beskrivelser: den vigtigste kvalitetsfaktor
  7. Optimering af antallet af værktøjer
  8. Sikkerhed: stol aldrig på modellen
  9. Vigtige pointer

Tekniske begrænsninger ved funktionskald

Før du går i gang med implementeringen, skal du forstå systemets grænser. Groks funktionskald er kraftfuldt, men det opererer inden for specifikke rammer, som du skal mestre for at bygge robuste applikationer.

Maksimum 200 værktøjer pr. anmodning

Grok API’et accepterer op til 200 værktøjsdefinitioner i en enkelt anmodning. Denne grænse er generøs – de fleste applikationer bruger kun 5 til 20. Men hvis du bygger et skalerbart system (plugins, værktøjsmarkedsplads), skal du tage højde for dette.

Hver værktøjsdefinition optager plads i kontekstvinduet. Mere specifikt:

  • Et simpelt værktøj (2-3 parametre) bruger omkring 50-100 tokens
  • Et komplekst værktøj (10+ parametre, detaljerede beskrivelser) kan overstige 300 tokens
  • 200 komplekse værktøjer = 60.000 tokens alene til definitioner

Derfor skal du være strategisk: erklær kun de værktøjer, der er relevante for den aktuelle anmodning.

Modellen garanterer ikke gyldigheden af argumenter

Grok gør sit bedste for at generere argumenter, der matcher skemaet, men det er ikke upåklageligt. Modellen kan:

  • Generere et forkert datoformat
  • Sende en string, hvor der forventes et integer
  • Udelade et påkrævet felt i sjældne tilfælde
  • Hallucinere enum-værdier, der ikke eksisterer

Din klient-side kode skal altid validere modtagne argumenter, før funktionen eksekveres.

import json

def handle_tool_call(tool_call):
    args = json.loads(tool_call.function.arguments)

    # Valider før eksekvering
    if "city" not in args:
        return {"error": "The city parameter is required"}

    if not isinstance(args["city"], str):
        return {"error": "city must be a string"}

    return get_weather(args["city"], args.get("unit", "celsius"))

Håndtering af fejl

Når en funktion fejler, skal du returnere fejlen til modellen i stedet for at crashe stille. Modellen kan derefter:

  • Omformulere sin anmodning med korrigerede parametre
  • Informere brugeren om problemet
  • Prøve et alternativt værktøj
try:
    result = search_database(query=args["query"])
    return json.dumps(result)
except ConnectionError:
    return json.dumps({
        "error": "Database unavailable",
        "suggestion": "Retry in a few seconds"
    })

Returner altid struktureret JSON, selv ved fejl. Modellen forstår fejlmeddelelser og tilpasser sit svar derefter.

Unikke og eksplicitte navne

Funktionsnavne skal være unikke i værktøjslisten. Hvis to værktøjer deler samme navn, er adfærden udefineret – API’et kan afvise anmodningen eller ignorere det ene af dem.

Indfør en konsistent navngivningskonvention:

✅ Bedste praksis:
   get_weather          → datahentning
   search_products      → søgning
   create_ticket        → oprettelse
   update_order_status  → opdatering
   delete_draft         → sletning

❌ Undgå:
   fn1, fn2             → uforståeligt
   doStuff              → for vagt
   getWeatherData       → camelCase (foretræk snake_case)

Beskrivelser: den vigtigste kvalitetsfaktor

Kvaliteten af beskrivelserne bestemmer direkte pålideligheden af funktionskald. Her er en sammenligningstabel:

Svag beskrivelse Effektiv beskrivelse
"Search" "Search for products by name, category, or price range in the e-commerce catalog"
"Send message" "Send an email to a recipient. Requires a subject and message body. Does not support attachments."
"Calculate" "Calculate the total price including tax from a pre-tax price and a VAT rate. Returns the amount in euros with 2 decimal places."

Optimering af antallet af værktøjer

I stedet for at erklære 200 værktøjer ved hver anmodning, skal du dynamisk vælge dem, der faktisk betyder noget. Det første filter er kontekst: hvis brugeren taler om vejr, tilføjer det kun støj at indlæse faktureringsværktøjer – en let upstream-routing (via nøgleord eller et første klassificeringskald) er nok til kun at præsentere den relevante familie. Det andet filter er rollen: en supportagent har ikke brug for admin-værktøjer, og at fjerne dem handler lige så meget om præcision som om sikkerhed. Det tredje er trinnet: i et flertrins-workflow har hver fase sine egne værktøjer – at indlæse dem efterhånden som du skrider frem, holder modellen fokuseret på det, den skal gøre nu.

Fordelen er dobbelt og øjeblikkelig: færre input-tokens pr. anmodning (værktøjsdefinitioner koster dig ved hvert kald), og bedre udvælgelsesnøjagtighed – en model, der vælger mellem seks velbeskrevne værktøjer, laver sjældent fejl, hvorimod den samme model, der står over for to hundrede definitioner, ender med at forveksle tæt beslægtede varianter.

Sikkerhed: stol aldrig på modellen

Funktionskald er en potentiel injektionsvektor. En ondsindet bruger kunne formulere sin anmodning for at manipulere argumenterne, der sendes til funktionerne. Sikkerhedsregler:

  • Valider alle argumenter på serveren
  • Begræns rettigheder: en læsefunktion må ikke kunne skrive
  • Log kald: spor hvert funktionskald til revision
  • Rens input: escape specialtegn før SQL/shell-forespørgsler

Vigtige pointer

  • Maksimum 200 værktøjer pr. anmodning – men sigt efter 5-20 for effektivitet
  • Valider altid argumenter på klient-siden før eksekvering
  • Returner fejl til modellen i struktureret JSON
  • Navne skal være unikke, bruge snake_case og være eksplicitte
  • Detaljerede beskrivelser forbedrer pålideligheden markant
  • Vælg dynamisk relevante værktøjer til hver anmodning
  • Stol aldrig på argumenter uden validering