DE ▾
API-Schlüssel erhalten

StartseiteAnleitung

Aktualisiert

Kontextfenster des KI-Agenten: Wie 100k Token genutzt werden

Das Kontextfenster eines KI-Agenten ist der gesamte Token-Speicher, der von Prompt, Tool-Ergebnissen und der Antwort des Modells geteilt wird. Auf dieser API beträgt dieser Speicher 100.000 Token, und langlaufende Agenten füllen ihn schneller als erwartet.

Glasbehälter, der sich mit leuchtenden Blöcken füllt, während ein Pfeil ihn umkreist, zur Veranschaulichung des Kontextfensters eines Agenten

Wichtige Punkte

  1. Das 100.000-Token-Fenster deckt Prompt und Completion ab, daher reduziert jedes Tool-Ergebnis, das du behältst, den Platz für die nächste Antwort.
  2. In einer Agenten-Schleife wird die gesamte Historie in jedem Schritt erneut gesendet, sodass die Eingabe mit dem Quadrat der Schrittzahl wächst, nicht linear.
  3. Kürze zuerst die alten Tool-Ausgaben, behalte den System-Prompt und die neuesten Nachrichten und misse mit dem usage-Feld.
  4. Eine 20-Schritte-Schleife mit 1.500 neuen Token pro Schritt kostet insgesamt etwa 0,055 $.

Keine Karte nötig. Nach der Anmeldung beanspruche mit einem Klick 0,50 $ kostenloses Testguthaben (einmal pro Person).

API-Schlüssel erhalten

Die kurze Antwort: Ein gemeinsames Budget von 100.000 Token

Wenn nach dem Kontextfenster des KI-Agenten gesucht wird, wollen die meisten wissen, wie viel sich ein Agent merken kann, bevor er abstürzt. Hier sind es 100.000 Token, und alles zählt: der System-Prompt, die Tool-Definitionen, jede frühere Nachricht, jedes Tool-Ergebnis und die Completion, die das Modell gerade schreibt. Die Completion nutzt den verbleibenden Platz, und max_tokens ist optional.

Das macht das Fenster zu einem Budget, nicht zu einem Speicherplatz. Ein Chatbot erreicht das Limit selten. Ein Agent, der Tools in einer Schleife aufruft, kann es am Nachmittag erreichen, da jeder Schritt eine Modellnachricht und ein Tool-Ergebnis zur Historie hinzufügt und die gesamte Historie bei der nächsten Anfrage erneut gesendet wird. Das Modell hat keine Erinnerung zwischen Anfragen. Was wie Erinnerung aussieht, ist dein erneutes Senden des Transkripts.

Was das Fenster in einem Agenten tatsächlich füllt

Der Großteil des Speichers ist nicht der Text des Nutzers. Verfolge diese fünf Quellen, und du kannst vorhersagen, wo einem Lauf der Platz ausgeht.

  • System-Prompt. Regeln, Persona und Ausgabeformat. Oft 500 bis 2.000 Token und bei jeder Anfrage gesendet.
  • Tool-Definitionen. Jeder Funktionsname, jede Beschreibung und jedes JSON-Schema zählt. Zehn Tools mit langen Beschreibungen können mehrere tausend Token kosten, bevor die erste Nutzernachricht kommt.
  • Tool-Ergebnisse. Der übliche Übeltäter. Ein Suchergebnis, ein Datei-Dump oder ein Datenbank-Satz können Tausende Token umfassen und bleiben in der Historie, es sei denn, du entfernst sie.
  • Assistant-Nachrichten. Ausformulierte Reasoning-Texte und die tool_calls-Argumente, die das Modell erzeugt hat.
  • Die generierte Antwort. Sie braucht ebenfalls Platz. Wenn der Prompt 99.000 Token hat, bleiben für die Antwort etwa 1.000.

Die API gibt genaue Zahlen im usage-Block jeder Antwort aus, sodass du nicht schätzen musst. Logge prompt_tokens nach jedem Schritt, und du siehst die Kurve.

Ein durchgerechnetes Beispiel: 20 Schritte einer Tool-Schleife

Nimm einen Agenten mit einem Start von 3.000 Token (System-Prompt plus Tool-Definitionen). Jeder Schritt fügt etwa 1.500 Token zur Historie hinzu: der Tool-Aufruf des Modells und das Tool-Ergebnis. Er schreibt außerdem etwa 300 Token Ausgabe pro Schritt. Der Agent läuft 20 Schritte.

Die Eingabe in Schritt k ist 3.000 + 1.500 × (k − 1). Summiert über 20 Schritte:

  • 3.000 × 20 = 60.000 Token für den festen Start, der jedes Mal erneut gesendet wird.
  • 1.500 × (0 + 1 + ... + 19) = 1.500 × 190 = 285.000 Token angesammelter Historie.
  • Gesamte Eingabe: 345.000 Token. Gesamte Ausgabe: 20 × 300 = 6.000 Token.
PositionTokenPreis pro 1MKosten
Eingabe345,000$0.15$0.05175
Ausgabe6,000$0.50$0.003
Gesamtca. $0,055

Zwei Dinge stechen hervor. Erstens beträgt der Kontext in Schritt 20 3.000 + 1.500 × 19 = 31.500 Token, weit innerhalb des Fensters, doch du hast für 345.000 Input-Token bezahlt, weil die Historie jedes Mal erneut gesendet wurde. Zweitens kostet ein einzelner Aufruf mit einem vollständig gefüllten Fenster (100.000 Input-Token) 100.000 × $0,15 / 1M = $0,015 für die Input-Seite. Lange Kontexte sind pro Aufruf erschwinglich; die Kosten entstehen durch die Wiederholung über viele Schritte hinweg. Sieh dir die Preisseite für die Raten und Auflade-Boni an.

Wie viele Schritte passen, bevor das Fenster voll ist

Du kannst das vor dem Schreiben von Code abschätzen. Halte eine Reserve für die Antwort bereit, z. B. 20.000 Token, was ein Budget von 80.000 Token für den Prompt lässt. Mit einem Start von 3.000 Token und 1.500 Token pro Schritt erreicht die Historie dieses Budget nach (80.000 − 3.000) / 1.500, also etwa 51 Schritten.

Berechne nun die Kosten für einen Lauf dieser Länge. Über 51 Schritte beträgt der Input 3.000 × 51 + 1.500 × (0 + 1 + ... + 50) = 153.000 + 1.500 × 1.275 = 153.000 + 1.912.500 = 2.065.500 Token. Output bei 300 Token pro Schritt sind 15.300 Token. Kosten: 2.065.500 × $0,15 / 1M = $0,30983, plus 15.300 × $0,50 / 1M = $0,00765, also etwa $0,32.

Vergleiche das mit dem 20-Schritte-Lauf zu etwa $0,055. Der Lauf ist 2,55-mal länger, kostet aber etwa 5,8-mal mehr, weil jeder Schritt eine längere Historie mit sich bringt. Dies ist der praktische Grund zum Kürzen: Es begrenzt die Kosten pro Schritt und schützt gleichzeitig das Fenster.

Einen Agenten im Fenster halten

Lösche zuerst alte Tool-Ausgaben

Rohe Tool-Ergebnisse sind der größte und am wenigsten nützliche Teil einer alten Historie. Sobald das Modell auf eine Dateiliste reagiert hat, braucht es diese Liste selten erneut. Ersetze alte Ergebnisse durch einen einzeiligen Platzhalter wie "Ergebnis entfernt, 4.200 Token" oder lösche das Paar vollständig.

Fasse die Mitte zusammen, behalte beide Enden

Behalte den System-Prompt und die letzten paar Schritte wörtlich. Für alles dazwischen bitte das Modell um eine kurze Zusammenfassung der getroffenen Entscheidungen und gefundenen Fakten, und speichere diese Zusammenfassung als einzelne Nachricht. Führe den Zusammenfassungs-Aufruf aus, bevor du das Limit erreichst, nicht danach.

Fakten aus dem Transkript entfernen

Wenn der Agent etwas lernt, das er stundenlang behalten muss, schreibe es über ein Tool in eine Datei oder eine kleine Datenbank und lese es bei Bedarf wieder aus. Das ist günstiger, als es in jeder Anfrage mitzuführen, und überlebt Neustarts.

Tool-Schemata kurz halten

Kürze Beschreibungen auf das, was das Modell braucht, um das Tool zu wählen. Übergebe nur die Tools, die für die aktuelle Phase der Aufgabe relevant sind.

Code: Eine Tool-Schleife mit Token-Budget

Diese Schleife kürzt die ältesten Nachrichten, wenn die grobe Größe ein Budget von 80.000 Token überschreitet, und lässt Platz für die Antwort. Die Schätzung teilt Zeichen durch vier, eine gängige Näherung für englischen Text; die genaue Zählung kommt in usage zurück. Das Kürzen entfernt verwaiste tool-Nachrichten, sodass ein Ergebnis nie ohne seinen Aufruf erscheint.

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.aivideogenapi.com/v1", api_key=os.environ["API_KEY"])
BUDGET = 80_000

tools = [{"type": "function", "function": {
    "name": "get_scene_length",
    "description": "Return the length of a scene in seconds",
    "parameters": {"type": "object",
                   "properties": {"scene": {"type": "integer"}},
                   "required": ["scene"]}}}]

def rough_tokens(messages):
    return sum(len(json.dumps(m)) for m in messages) // 4

def trim(messages):
    system, rest = messages[0], messages[1:]
    while rough_tokens([system] + rest) > BUDGET and len(rest) > 4:
        rest.pop(0)
        while rest and rest[0]["role"] == "tool":
            rest.pop(0)
    return [system] + rest

def run_tool(name, args):
    return json.dumps({"seconds": 4 * args["scene"]})  # stub

messages = [
    {"role": "system", "content": "You plan video scenes. Use tools for lengths."},
    {"role": "user", "content": "Total the length of scenes 1 to 5."},
]

for step in range(20):
    resp = client.chat.completions.create(
        model="uncensored", messages=trim(messages), tools=tools)
    msg = resp.choices[0].message
    messages.append(msg.model_dump(exclude_none=True))
    print(step, resp.usage.prompt_tokens)
    if not msg.tool_calls:
        print(msg.content)
        break
    for call in msg.tool_calls:
        result = run_tool(call.function.name, json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": result})

Tool Calling folgt dem OpenAI-Format: tools, tool_choice und Ergebnisse zurückgegeben als role: "tool". Die Dokumentation listet die Parameter auf, die durchgereicht werden.

Grenzen, die neben dem Fenster wichtig sind

Das Fenster ist eine Einschränkung. Agenten stoßen auch an Ratenlimits. Ein voller Schlüssel erlaubt 8 gleichzeitige Anfragen und 300 Anfragen pro Minute; ein Test-Schlüssel erlaubt 2 und 60. Eine enge Schleife mit parallelen Sub-Agenten kann die Parallelitätsbegrenzung schnell überschreiten. Die API antwortet mit HTTP 429 und dem Fehlercode concurrency oder rate_limited und bei temporärer Überlastung mit einem Retry-After: 5-Header. Warte diese Zeit und versuche es erneut.

Wenn du streamst, denke daran, dass eine gestreamte Anfrage ihren Parallelitäts-Slot bis zum Ende des Streams hält. Ein hängender Client, der den Stream nie schließt, hält einen Slot belegt.

Der maximale Body ist 8 MB, was weit mehr ist als 100.000 Token Text, daher ist das Fenster die Grenze, die du zuerst erreichst. Für ein Beispiel einer textbasierten Pipeline, die auf dieser API basiert, sieh dir den Video-Skript-Leitfaden an. Wenn du bereit bist, ihn auszuführen, erstelle einen API-Schlüssel; neue Nutzer können 0,50 $ Testguthaben mit einem Klick beanspruchen, gültig für 7 Tage und ohne Zahlungsangabe.

Fragen und Antworten

Wie groß ist das Kontextfenster?

100.000 Token, zusammengezählt aus Prompt und Completion. Die Completion kann alles nutzen, was der Prompt übrig lässt.

Merkt sich das Modell frühere Anfragen?

Nein. Jede Anfrage ist unabhängig, daher muss dein Code die Nachrichten, die das Modell sehen soll, erneut senden.

Was passiert, wenn ich das Limit überschreite?

Die Anfrage passt nicht mehr, also kürze oder fasse die Historie vor dem Senden zusammen. Fehlgeschlagene Anfragen werden nicht berechnet.

Wie zähle ich Token?

Lies prompt_tokens und completion_tokens aus dem usage-Block jeder Antwort ab oder nutze vor dem Senden eine grobe Schätzung von vier Zeichen pro Token für Englisch.

Dein Schlüssel ist nur ein Formular entfernt

Erstelle ein Konto, kopiere den Schlüssel, ändere die Basis-URL. Das ist die gesamte Einrichtung.

API-Schlüssel erhalten