Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Optimalisatie van end-to-end: van prompt tot netwerk

Les 2 van 20 Bijgewerkt op 3 november 2026 Gevorderd
Op deze pagina
  1. Optimalisatie is een systeem, geen parameter
  2. Optimaliseer de prompt
  3. Optimaliseer API-parameters
  4. Optimaliseer het netwerk
  5. Optimaliseer de nabewerking
  6. Belangrijkste punten

Les bijgewerkt op 3 november 2026 op basis van OpenAI-documentatie: temperature en top_p worden alleen geaccepteerd met een redeneerinspanning van none, terwijl GPT-5.6-modellen standaard redeneren (medium). Aanroepen die deze parameters instellen, moeten daarom reasoning={"effort": "none"} (Responses API) of reasoning_effort="none" (Chat Completions) specificeren. Bronnen: Using GPT-6 · GPT-5.6 Terra.

Optimalisatie is een systeem, geen parameter

Het verminderen van latentie en kosten voor een LLM-toepassing draait niet alleen om het kiezen van een sneller model. Het is een keten van optimalisaties die loopt van de prompt tot de netwerkconfiguratie, waarbij de zwakste schakel de prestaties van de rest bepaalt. Een team dat de grootte van zijn systeemprompt halveert, maar zijn server voor elk verzoek een nieuwe TLS-verbinding laat openen, verliest aan netwerkkosten wat het aan tokens heeft bespaard.

De volgorde waarin u deze hefbomen aanpakt, is belangrijk. Begin bij de prompt, omdat dit zowel kosten als latentie beïnvloedt zonder infrastructuurwijzigingen. Daarna volgen de API-parameters, vervolgens de netwerkconfiguratie en tot slot de manier waarop uw applicatie het antwoord verwerkt. Deze les leidt u door elke hefboom in die volgorde.

Optimaliseer de prompt

Elke input-token kost tijd en geld, en de meeste productie-prompts dragen bagage mee uit hun prototypefase: instructies die één voor één zijn toegevoegd, waarbij elke de vorige herformuleert. Uw eerste reflex moet zijn om de prompt compact herschrijven, aanspreekvormen en herhalingen verwijderen zonder de daadwerkelijke beperkingen die aan het model worden doorgegeven aan te tasten.

# ❌ Woordrijke prompt
prompt_long = """
You are an expert financial analysis assistant. You must always
respond in a professional and structured manner. You must use
numerical data when possible. You must avoid unnecessary jargon.
You must be concise but complete.
Analyze the following quarterly report: ...
"""

# ✅ Geoptimaliseerde prompt (zelfde resultaat, minder tokens)
prompt_court = """Role: Senior financial analyst.
Constraints: Structured, numerical, concise.
Task: Analyze this quarterly report: ..."""

Beide versies geven exact dezelfde vijf beperkingen door; de tweede doet dit zonder de vijf zinnen met “You must” die niets toevoegen voor het model. Bij een dienst die tienduizend rapporten per dag verwerkt, verdient deze herschrijving van dertig seconden zich dagelijks terug.

Kies het juiste model voor de taak

De tweede hefboom berust op het feit dat niet elke oproep hetzelfde model vereist. Het routeren van een taak voor veldextractie naar een model met hoge redeneercapaciteit betekent dat u betaalt voor capaciteit die de taak niet gebruikt en langer wacht op een identiek resultaat.

Soort taakAanbevolen modelReden
Classificatie / extractiegpt-5.6-lunaSnel, zuinig
Complexe redeneringgpt-5.6-terra met gemiddelde redeneringBeste kwaliteit/prijsverhouding
Kritieke takengpt-5.6-sol met hoge redeneringHoogste kwaliteit, langzamer
Hoge volumesgpt-5.6-luna via Batch API-50% kosten

Codificeer deze keuze in de praktijk in een routeringsfunctie in plaats van deze aan de discretie van ontwikkelaars over te laten; anders wint het standaardmodel het altijd:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Selecteert het optimale model op basis van de taak."""
    if complexity == "low":
        return "gpt-5.6-luna"
    elif task in ("reasoning", "math", "code"):
        return "gpt-5.6-terra"
    elif complexity == "critical":
        return "gpt-5.6-sol"
    return "gpt-5.6-terra"

def optimized_call(prompt: str, task: str, complexity: str) -> str:
    model = route_model(task, complexity)
    response = client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

Optimaliseer API-parameters

Een antwoord dat te lang is, verspilt generatietijd die niemand zal lezen. Specificeer altijd max_output_tokens: dit is een harde limiet die zowel uw factuur als uw interface beschermt en voorkomt dat een slecht geformuleerde prompt ontaardt in een uitweiding van tweeduizend woorden.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature vereist effort none
    input="Summarize this text in one sentence.",
    max_output_tokens=100,  # Harde limiet
    temperature=0.0,         # Deterministisch = sneller
)

Sampling-parameters werken in dezelfde richting. Het instellen van temperature=0 maakt antwoorden deterministisch en iets sneller, wat precies is wat u wilt voor extractie- of classificatietaken waarbij creativiteit een bron van variantie is, geen asset. Het verlagen van top_p naar 0,1 beperkt de zoekruimte en versnelt de generatie; reserveer deze instelling voor taken waarbij slechts één formulering acceptabel is, en houd standaardwaarden aan waar de rijkdom van het antwoord deel uitmaakt van het product.

Optimaliseer het netwerk

Pakketreiskosten tellen bij elke oproep op, maar blijven onzichtbaar in uw applicatiemetrieken. De OpenAI API wordt voornamelijk gehost aan de oostkust van de VS: het plaatsen van uw applicatieserver in dezelfde regio als het eindpunt kan een potentiële winst van 50 tot 150 milliseconden in netwerklatentie opleveren. Voor een conversationele applicatie is dit een aanzienlijk deel van de Time to First Token (TTFT).

De tweede winst komt door het hergebruik van verbindingen. Zonder pool herhaalt elk verzoek de TLS-handshake, wat meerdere round-trips toevoegt voordat er nuttige data stroomt. Dit lost u op door een HTTP-client eenmalig te configureren:

import httpx

# Client met persistente verbindingspool
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optimaliseer de nabewerking

De laatste schakel is vaak degene die men vergeet: een applicatie die een streaming-antwoord ontvangt maar wacht tot het einde om dit weer te geven, tenietdoet alle voordelen van streaming. Verwerk het antwoord direct in plaats van na volledige ontvangst.

async def progressive_processing(prompt: str):
    """Verwerkt elk chunk zodra het binnenkomt."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Verwerk per volledige zin
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Splitsen per volledige zin is een bewuste afweging: het emitteren van elke token produceert een schokkerig beeld, terwijl wachten op de hele alinea het gevoel van wachten recreateert. De zin is de eenheid die lezers van nature consumeren. Gebruik dit patroon opnieuw wanneer uw interface moet weergeven, voorlezen of streamen wat het model produceert.

Belangrijkste punten

  • Optimaliseer eerst de prompt: minder tokens = minder latentie en kosten
  • Routeer naar het juiste model op basis van taakcomplexiteit
  • Beperk max_output_tokens en gebruik waar mogelijk temperature=0
  • Hergebruik HTTP-verbindingen en verwerk antwoorden via streaming