Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Flersvars-samtaler med værktøjer

Lektion 11 af 14 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Flersvars-samtaler med funktionskald
  2. Parameteren max_turns
  3. Klient-side flersvars-løkke
  4. Flersvars-kontekst med Responses API
  5. Mønstre for flersvars-samtaler
  6. Hukommelseshåndtering
  7. Vigtige pointer

Flersvars-samtaler med funktionskald

I en rigtig samtale kan modellen have behov for at kalde værktøjer flere gange undervejs i udvekslingen. Hvert svar kan involvere nye kald, resultater der udløser andre kald, eller anmodninger om afklaring fra brugeren, før et værktøj tages i brug.

Parameteren max_turns

Parameteren max_turns begrænser antallet af assistent/værktøj-svar på serversiden i en enkelt anmodning. Den gælder kun for indbyggede værktøjer (web_search, code_interpreter osv.).

response = client.responses.create(
    model="grok-4.5",
    input="Analyser tech-trends i 2026",
    tools=[{"type": "web_search"}],
    max_turns=5  # Maksimum 5 websøgninger før svar
)

Vigtigt punkt: Klient-side kald af værktøjer nulstiller tælleren. Når du sender et function_call_output tilbage, starter en ny max_turns-kvote.

Klient-side flersvars-løkke

For at håndtere samtaler, hvor modellen kalder værktøjer flere gange, skal du implementere en løkke:

import json

def multi_turn_chat(user_message, tools, max_iterations=10):
    messages = [{"role": "user", "content": user_message}]

    for i in range(max_iterations):
        response = client.chat.completions.create(
            model="grok-4.5",
            messages=messages,
            tools=tools
        )

        message = response.choices[0].message
        messages.append(message)

        # Hvis ingen tool_call, er samtalen slut
        if not message.tool_calls:
            return message.content

        # Udfør alle anmodede værktøjer
        for tool_call in message.tool_calls:
            args = json.loads(tool_call.function.arguments)
            result = execute_function(tool_call.function.name, args)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result)
            })

    return "Maksimalt antal iterationer nået"

Variablen max_iterations er en essentiel sikkerhedsforanstaltning for at forhindre uendelige løkker. I produktion bør du sætte en rimelig grænse (5–10 svar).

Flersvars-kontekst med Responses API

Responses API tilbyder to mekanismer til at bevare kontekst:

1. Fjernlagring

# Første besked
r1 = client.responses.create(
    model="grok-4.5",
    input="Hvordan er vejret i Paris?",
    tools=tools,
    store_messages=True
)

# Værktøjsresultat
r2 = client.responses.create(
    model="grok-4.5",
    input=[{
        "type": "function_call_output",
        "call_id": r1.output[0].call_id,
        "output": {temp: 18}
    }],
    previous_response_id=r1.id,
    store_messages=True
)

# Opfølgningsspørgsmål (kontekst bevares)
r3 = client.responses.create(
    model="grok-4.5",
    input="Hvad med i morgen?",
    previous_response_id=r2.id,
    tools=tools,
    store_messages=True
)

Fordelen: Du behøver ikke administrere beskedhistorikken. xAI gemmer og henter den automatisk via previous_response_id.

2. Krypteret indhold på klienten

response = client.responses.create(
    model="grok-4.5",
    input="Søg efter flypriser til Nice",
    tools=tools,
    use_encrypted_content=True
)

Med use_encrypted_content=True modtager du ræsonnementer og værktøjsoutput i krypteret form. Du sender dem tilbage, som de er, i efterfølgende anmodninger uden at kunne læse dem. Dette er nyttigt, når du ikke ønsker, at data passerer i klar tekst gennem din server.

Mønstre for flersvars-samtaler

Mønster: Søgning derefter handling

Svar 1 : Bruger → "Find en billig flybillet Paris-Nice"
         Model → tool_call: search_flights(from="CDG", to="NCE")
         Klient → result : [{flight1}, {flight2}, {flight3}]
Svar 2 : Model → "Jeg fandt 3 fly. Det billigste er 89 €. Vil du booke det?"
         Bruger → "Ja, book flyet til 89 €"
Svar 3 : Model → tool_call: book_flight(flight_id="FL123", passengers=1)

Mønster: Dataaggregering

Svar 1 : Model → tool_call: get_sales(month="march")
Svar 2 : Model → tool_call: get_expenses(month="march")
Svar 3 : Model → tool_call: get_headcount(month="march")
Svar 4 : Model → "Her er månedsrapporten: salg +12 %, udgifter -3 %, personaleantal stabilt."

Mønster: Progressiv forfining

Svar 1 : Model → tool_call: search_products(query="running shoes")
         Resultat → 150 produkter
Svar 2 : Model → "Jeg fandt 150 produkter. Hvilken størrelse og hvilket budget?"
         Bruger → "42, maks. 120 €"
Svar 3 : Model → tool_call: search_products(query="running shoes", size=42, max_price=120)
         Resultat → 8 produkter

Hukommelseshåndtering

I lange samtaler vokser historikken – som inkluderer hvert tool_call og hvert værktøjsresultat – hurtigt, og med den omkostningen ved hvert svar. Tre strategier står til din rådighed, lige fra manuel til fuldt delegeret. Periodisk opsummering kondenserer ældre svar til et afsnit, der injiceres i system-prompten: du beholder substansen af tidligere udvekslinger for en brøkdel af deres token-vægt, på bekostning af visse detaljetab. Det skydende vindue er mere brutalt, men enklere: behold kun de sidste N svar, og accepter, at modellen vil glemme begyndelsen af samtalen – velegnet, når ældre udvekslinger ikke længere har operationel betydning. Fjernlagring delegerer endelig problemet til xAI med store_messages=True: historikken lever på serversiden, og din applikation bærer kun en reference. Det rigtige valg afhænger af, hvad din applikation skal huske, og hvor længe.

Vigtige pointer

  • max_turns begrænser værktøjssvar på serversiden – klientværktøjer nulstiller tælleren
  • Implementer en løkke med max_iterations for at forhindre uendelige løkker
  • previous_response_id kæder samtaler sammen uden at gensende historik
  • store_messages=True delegerer kontekstlagring til xAI
  • use_encrypted_content=True beskytter data under overførsel
  • Håndtér hukommelse i lange samtaler (opsummering, skydende vindue)