Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Flere runder med kontekst: Lagring og kryptering

Lektion 9 af 12 Opdateret 30. juli 2026 Avanceret
På denne side
  1. Problemet med kontekst mellem anmodninger
  2. Metode 1: store_messages og previous_response_id
  3. Metode 2: use_encrypted_content
  4. Valg mellem de to metoder
  5. Kombination med det hybride workflow
  6. Vigtige pointer

Problemet med kontekst mellem anmodninger

I en samtale over flere runder med værktøjer vokser kontekstmængden hurtigt. Hvert værktøjskald føjer sine resultater til beskedtråden, og modellens interne ræsonnement skal bevares for at sikre konsistens. To mekanismer løser dette problem: fjernlagring og klientside-kryptering.

Metode 1: store_messages og previous_response_id

Fjernlagring delegerer konteksthåndteringen til xAI-serverne. Du aktiverer store_messages=True i din første anmodning og kæder derefter efterfølgende anmodninger sammen med previous_response_id:

# Første anmodning: aktiver lagring
response = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": "Analyze this sales dataset"}],
    tools=my_tools,
    store_messages=True
)

response_id = response.id  # gem ID'et

# Næste anmodning: brug gemt kontekst
response2 = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": "What are the top 3 selling products?"}],
    previous_response_id=response_id,
    store_messages=True
)

Med denne tilgang behøver du ikke at gensende hele beskedhistorikken. xAI-serveren holder på konteksten og vedhæfter den automatisk. Dette reducerer anmodningsstørrelsen og forenkler din kode.

Fordele

  • Lettere anmodninger (behøver ikke at gensende hele historikken)
  • Modellens interne ræsonnement bevares automatisk
  • Ingen kompleks tilstandshåndtering på klientsiden

Begrænsninger

  • Beskeder gemmes på xAI-servere (overvejelse af privatliv)
  • response_id skal bevares mellem anmodninger
  • Lagring har en begrænset opbevaringsperiode

Metode 2: use_encrypted_content

Klientside-kryptering tilbyder et alternativ til tilfælde, hvor du vil beholde kontrollen over konteksten uden at gemme dine data på xAI-servere:

# Aktiver krypteret indhold
response = await client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": "Analyze this contract"}],
    tools=my_tools,
    use_encrypted_content=True
)

# Ræsonnement og værktøjsoutput returneres krypteret
# Du tilføjer dem som de er til efterfølgende beskeder
messages = [
    {"role": "user", "content": "Analyze this contract"},
    response.choices[0].message,  # indeholder krypteret indhold
    {"role": "user", "content": "What are the termination clauses?"}
]

response2 = await client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    use_encrypted_content=True
)

Med use_encrypted_content=True returneres internt ræsonnement og værktøjsresultater i krypteret form. Du kan ikke læse dem, men du gensender dem i efterfølgende anmodninger. Serveren dekrypterer dem for at opretholde kontinuiteten i ræsonnementet.

Fordele

  • Konteksten forbliver under din kontrol (ingen fjernlagring)
  • Internt ræsonnement bevares uden at blive eksponeret som klartekst
  • Kompatibel med strenge privatlivspolitikker

Begrænsninger

  • Anmodninger er større (krypteret indhold inkluderes)
  • Du skal håndtere beskedhistorikken på klientsiden

Valg mellem de to metoder

Valget afhænger af din kontekst:

  • store_messages: foretrækkes til chat-applikationer, interaktive assistenter og tilfælde, hvor enkelhed kommer først. Konteksten håndteres automatisk.
  • use_encrypted_content: foretrækkes til følsomme applikationer, behandling af fortrolige dokumenter og tilfælde, hvor data ikke må forlade din infrastruktur (bortset fra API-transit).

Kombination med det hybride workflow

Begge metoder integreres i løkkemønsteret set i den tidligere lektion:

async def multi_turn_conversation(questions: list[str]) -> list[str]:
    responses = []
    previous_id = None

    for question in questions:
        kwargs = {
            "model": "grok-4.5",
            "messages": [{"role": "user", "content": question}],
            "tools": my_tools,
            "store_messages": True,
        }
        if previous_id:
            kwargs["previous_response_id"] = previous_id

        response = await client.chat.completions.create(**kwargs)
        previous_id = response.id
        responses.append(response.choices[0].message.content)

    return responses

Dette mønster kæder spørgsmål sammen, mens hele samtalekonteksten bevares, herunder værktøjsresultater og modellens interne ræsonnement.

Vigtige pointer

  • store_messages=True + previous_response_id delegerer konteksthåndteringen til xAI
  • use_encrypted_content=True bevarer ræsonnement uden fjernlagring
  • Valget afhænger af dine krav til privatliv og enkelhed
  • Begge metoder er kompatible med workflows over flere runder og hybride værktøjer
  • previous_response_id eliminerer behovet for at gensende hele beskedhistorikken