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

Optimering från början till slut: från prompt till nätverk

Lektion 2 av 20 Uppdaterad 3 november 2026 Avancerad
På denna sida
  1. Optimering är ett system, inte en parameter
  2. Optimera prompten
  3. Optimera API-parametrar
  4. Optimera nätverket
  5. Optimera efterbehandling
  6. Viktiga punkter

Lektionen uppdaterad 3 november 2026 baserat på OpenAIs dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete (reasoning effort) på none, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificera reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Källor: Använda GPT-6 · GPT-5.6 Terra.

Optimering är ett system, inte en parameter

Att minska latens och kostnader för en LLM-applikation handlar inte bara om att välja en snabbare modell. Det är en kedja av optimeringar som sträcker sig från prompten till nätverkskonfigurationen, och den svagaste länken styr prestandan för resten. Ett team som halverar storleken på sin systemprompt men låter servern öppna en ny TLS-anslutning för varje begäran kommer att förlora i nätverksöverhead det de sparade på tokens.

Ordningen du tar dig an dessa hävstänger för spelar roll. Börja med prompten eftersom den påverkar både kostnad och latens utan att kräva infrastrukturändringar. Därefter kommer API-parametrar, sedan nätverkskonfiguration och slutligen hur din applikation konsumerar svaret. Denna lektion guidar dig genom varje hävstång i den ordningen.

Optimera prompten

Varje input-token kostar tid och pengar, och de flesta produktionsprompter bär på bagage från sin prototypphas: instruktioner som lagts till en efter en, där varje ny formulering upprepar den föregående. Ditt första reflex bör vara att skriva om prompten tätare, ta bort tilltalsformer och upprepningar utan att röra de faktiska begränsningar som överförs till modellen.

# ❌ Utförlig prompt
prompt_long = """
Du är en expert på finansiell analys. Du måste alltid
svara på ett professionellt och strukturerat sätt. Du måste använda
numerisk data när det är möjligt. Du måste undvika onödig jargong.
Du måste vara koncis men fullständig.
Analysera följande kvartalsrapport: ...
"""

# ✅ Optimerad prompt (samma resultat, färre tokens)
prompt_court = """Roll: Senior finansiell analytiker.
Begränsningar: Strukturerat, numeriskt, koncist.
Uppgift: Analysera denna kvartalsrapport: ..."""

Båda versionerna överför exakt samma fem begränsningar; den andra gör det utan de fem “Du måste”-fraserna som inte tillför något för modellen. På en tjänst som bearbetar tiotusen rapporter om dagen betalar sig denna trettio sekunders omskrivning varje dag.

Välj rätt modell för uppgiften

Den andra hävstången bygger på att inte varje anrop kräver samma modell. Att routa en uppgift för fältextraktion till en modell med högt resonemangsarbete innebär att du betalar för kapacitet som uppgiften inte använder och väntar längre på ett identiskt resultat.

UppgiftstypRekommenderad modellAnledning
Klassificering / extraktiongpt-5.6-lunaSnabb, ekonomisk
Komplex resonemanggpt-5.6-terra med medium resonemangBästa kvalitet/kostnad-förhållande
Kritiska uppgiftergpt-5.6-sol med högt resonemangHögst kvalitet, långsammare
Hög volymgpt-5.6-luna via Batch API-50 % kostnad

I praktiken bör du kodifiera detta val i en routningsfunktion istället för att lämna det till utvecklarnas omdöme; annars vinner alltid standardmodellen:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Väljer optimal modell baserat på uppgiften."""
    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

Optimera API-parametrar

Ett svar som är för långt slösar genereringstid som ingen kommer att läsa. Ange alltid max_output_tokens: detta är en hård gräns som skyddar både din faktura och ditt gränssnitt, och förhindrar att en dåligt formulerad prompt spiralerar iväg till en tvåtusenords utvikning.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature kräver effort none
    input="Sammanfatta denna text i en mening.",
    max_output_tokens=100,  # Hård gräns
    temperature=0.0,         # Deterministisk = snabbare
)

Samplingsparametrar arbetar i samma riktning. Att ställa in temperature=0 gör svaren deterministiska och något snabbare, vilket är exakt vad du vill ha för extraktions- eller klassificeringsuppgifter där kreativitet är en källa till varians, inte en tillgång. Att reducera top_p till 0,1 begränsar sökrymden och påskyndar genereringen; reservera denna inställning för uppgifter där endast en formulering är acceptabel, och behåll standardvärden där svarsmängd är en del av produkten.

Optimera nätverket

Kostnaden för paketresor adderas vid varje anrop, ändå förblir de osynliga i dina applikationsmått. OpenAI:s API hostas främst på USA:s östkust: att placera din applikationsserver i samma region som slutpunkten kan ge en potentiell vinst på 50 till 150 millisekunder i nätverkslatens. För en konversationsapplikation är detta en betydande del av Time to First Token (TTFT).

Den andra vinsten kommer från återanvändning av anslutningar. Utan en pool spelar varje begäran om TLS-handskaken, vilket lägger till flera runturer innan någon användbar data flödar. Att konfigurera en HTTP-klient en gång för alla löser detta:

import httpx

# Klient med persistent anslutningspool
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optimera efterbehandling

Den sista länken är ofta den folk glömmer: en applikation som tar emot ett strömmande svar men väntar till slutet för att visa det, tar ut alla fördelar med strömning. Bearbeta svaret löpande istället för efter fullständig mottagning.

async def progressive_processing(prompt: str):
    """Bearbetar varje chunk så snart den anländer."""
    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
            # Bearbeta per hel mening
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Att dela upp efter hela meningar är en medveten kompromiss: att sända ut varje token producerar en skakig visning, medan att vänta på hela stycket återskapar känslan av att vänta. Meningen är den enhet läsare naturligt konsumerar. Återanvänd detta mönster närhelst ditt gränssnitt behöver visa, läsa upp eller strömma det modellen producerar.

Viktiga punkter

  • Optimera prompten först: färre tokens = mindre latens och kostnad
  • Routa till rätt modell baserat på uppgiftens komplexitet
  • Begränsa max_output_tokens och använd temperature=0 när möjligt
  • Återanvänd HTTP-anslutningar och bearbeta svar via strömning