gpt-6.1-sol Prompt-Rezepte: Codierung, Reasoning, JSON und Tool-Aufrufe (mit echten Ausgaben)

gpt-6.1-sol ist ein Reasoning-Textmodell auf hiapi – Konversation, Codierung und schrittweises Reasoning, alles über die Responses API bereitgestellt (POST /v1/responses). Wenn du bereits weißt, wie man es aufruft, ist diese Seite der nächste Schritt: eine Sammlung direkt kopierbarer Prompt-Rezepte für die vier Aufgabentypen, die Menschen tatsächlich am häufigsten nutzen – Codierung, Reasoning, striktes JSON und Tool-Aufrufe –, wobei jedes Rezept die exakte Ausgabe enthält, die wir bei der tatsächlichen Ausführung für diesen Artikel erhalten haben. Für Authentifizierung, Streaming und SSE-Parsing beginne mit dem Einrichtungsleitfaden; hier konzentrieren wir uns nur auf die Prompts selbst.

Jedes Rezept unten ist ein Request-Body, den du direkt in diese Einrichtung einfügst. Der Prompt wird von zwei Feldern getragen: dem Top-Level-instructions (Rollendefinition und Formatregeln) und dem input-Array (die Aufgabe selbst). Hier gibt es keine Theorie – die Ausgaben sind wörtlich aus echten response.completed-Ereignissen kopiert.

Drei Hebel, die beeinflussen, wie du Prompts für gpt-6.1-sol schreibst

Bevor wir zu den Rezepten kommen, prägen drei Dinge über dieses Modell jeden Prompt, den du schreibst. Alle drei wurden gegen den Live-Vertrag des Modells auf hiapi bestätigt.

1. Kein temperature, kein top_p. Diese Ausführungskonfiguration deaktiviert beide (sowie max_output_tokens). Du kannst Determinismus oder Kreativität nicht über Sampling regulieren – der einzige einstellbare Hebel sind deine instructions, deine input und reasoning.effort. Wenn du knappe, deterministisch wirkende Ausgaben willst, sag es in den instructions; du kannst temperature: 0 nicht setzen.
2. reasoning.effort hat fünf Stufen: low, medium, high, xhigh, max (Standard medium). Höherer effort verbraucht mehr verborgene Reasoning-Token – und diese werden als Ausgabe-Token abgerechnet. Rezept 2 zeigt die reale Kurve.
3. Kontextfenster ca. 1,05 Mio. Token (maximale Ausgabe 128K). Die Abrechnung pro Token ist gestaffelt: Sobald die Eingabe einer einzelnen Anfrage 272K Token überschreitet, verdoppeln sich die Eingabe-/Ausgaberaten ungefähr. Bei alltäglichen Prompts kommst du dieser Grenze nicht nahe; bei Long-Context-Aufgaben (Rezept 5) lohnt es sich, das zu wissen.

Rezept 1 – Codierung: eine Funktion nach Spezifikation erzeugen

Setze die Engineering-Rolle und die Form der Ausgabe in instructions und die Spezifikation in input. Die Form einzuschränken („ein einzelner Code-Fence-Block, dann ein Satz“) ist genau die Methode, die Reasoning-Modelle davon abhält, Code in drei Absätze Vorwort zu hüllen.

{
  "model": "gpt-6.1-sol",
  "instructions": "Du bist ein erfahrener Python-Ingenieur. Gib einen einzelnen Python-Codeblock in einem Fence zurück und erkläre dann in einem Satz die Komplexität. Kein Vorwort.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Schreibe `merge_intervals(intervals: list[list[int]]) -> list[list[int]]`, die überlappende geschlossene Intervalle zusammenführt und sortiert nach Startpunkt zurückgibt. Behandle leere Listen. Füge einen Docstring hinzu." }
    ] }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Was es zurückgibt (wörtlich):

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    """Führt überlappende geschlossene Intervalle zusammen und gibt sie sortiert nach Startpunkt zurück.

    Die Eingabeliste und die Intervalle darin werden nicht verändert.
    """
    if not intervals:
        return []

    ordered = sorted(intervals, key=lambda interval: interval[0])
    merged = [ordered[0].copy()]

    for start, end in ordered[1:]:
        if start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])

    return merged

Zeitkomplexität O(n log n), Speicherkomplexität O(n).

Beachte, was die Einschränkung bewirkt hat: Sie behandelt leere Listen korrekt, kopiert jedes Intervall vor der Änderung (ordered[0].copy()), sodass die Daten des Aufrufers unverändert bleiben, und stoppt genau nach einer Analyse. Für diese mechanische Codierung reicht effort: low – es wurden null Reasoning-Token verwendet und trotzdem korrekter, nicht in-place verändernder Code erzeugt.

Rezept 2 – Reasoning: das Denkbudget mit effort steuern

Da du temperature nicht setzen kannst, ist reasoning.effort dein wichtigster Hebel für schwierige Probleme. Halte den Prompt unverändert und ändere nur effort:

{
  "model": "gpt-6.1-sol",
  "instructions": "Denke schrittweise und ende dann mit einer Zeile `Answer: <value>`.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Eine Bäckerei verkauft Kekse in Schachteln mit 6 und mit 11 Stück. Was ist die größte Keksanzahl, die sich nicht exakt kaufen lässt? Zeige die Überlegung." }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Wir haben denselben Prompt mit allen fünf effort-Stufen ausgeführt. Jede Stufe lieferte die richtige Antwort 49. Geändert hat sich, wie viel Denken dafür aufgewendet wurde:

reasoning.effort	Reasoning-Token	Ausgabe-Token gesamt	Ungefähre Kosten*
low	76	305	≈ $0.0008
medium	121	380	≈ $0.0010
high	209	427	≈ $0.0011
xhigh	626	845	≈ $0.0021
max	622	813	≈ $0.0021

*Zur Basistarif-Rate ($0.50 / 1M Eingabe, $2.50 / 1M Ausgabe); Reasoning-Token werden als Ausgabe abgerechnet. Daten aus diesem Lauf, Stand 2026-10. Aktuelle Raten findest du auf der Preisseite.

Die praktische Lehre steckt in den letzten beiden Zeilen: effort steigt von low bis high stetig an und erreicht dann ein Plateau – xhigh und max landen beide bei etwa 620 Reasoning-Token, weil das Problem einfach nicht schwer genug ist, um mehr Denken zu erfordern. Den effort bei einfachen Prompts voll aufzudrehen, bringt keine bessere Antwort; es kostet nur etwa 2,5-mal so viele Ausgabe-Token für dieselbe „49“. Passe effort an die Schwierigkeit an: low/medium für die meisten Prompts, high und höher nur, wenn die Aufgabe wirklich eine tiefere Suche erfordert.

Hier ist die Ausgabe von medium, damit du siehst, welche Form der Prompt erzeugt hat:

Die größte Zahl ist 49 Kekse.

1. Beweis, dass 49 nicht exakt gekauft werden kann. Angenommen 49 = 6a + 11b, wobei a, b nichtnegative ganze Zahlen sind. Modulo 6 auf beiden Seiten ergibt 5b ≡ 1 (mod 6), daher b ≡ 5 (mod 6). Also ist b mindestens 5, aber fünf Schachteln mit 11 Stück enthalten bereits 55 Kekse. Das ist unmöglich.

2. Beweis, dass jede Zahl über 49 gekauft werden kann. … Jede ganze Zahl von mindestens 50 ist eine von sechs aufeinanderfolgenden erreichbaren Summen plus ein nichtnegatives Vielfaches von 6.

Answer: 49

Die Zeile Answer: <value> in den instructions wirkt tatsächlich: Sie erlaubt dir, einfach die letzte Zeile zu parsen (text.rsplit("Answer:", 1)[-1].strip()), ohne das Modell zu zwingen, seinen Reasoning-Prozess wegzulassen.

Rezept 3 – Striktes JSON mit Schema

Fordere JSON nicht in Prosa an und hoffe dann. gpt-6.1-sol unterstützt strikte strukturierte Ausgaben: Übergib ein text.format mit json_schema, und das Modell wird auf die Ausgabe von konformem JSON beschränkt – keine Code-Fences, keine überflüssige Prosa.

{
  "model": "gpt-6.1-sol",
  "instructions": "Klassifiziere Support-Tickets. Antworte nur mit dem JSON-Objekt.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Ticket: 'Seit heute Morgen gibt der 4K-Upscale-Endpunkt bei jedem Aufruf 500 zurück. Wir wollen morgen launchen, das blockiert uns.'" }
    ] }
  ],
  "text": {
    "format": {
      "type": "json_schema",
      "name": "ticket",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "sentiment": { "type": "string", "enum": ["positive", "neutral", "negative"] },
          "topics": { "type": "array", "items": { "type": "string" } },
          "action_required": { "type": "boolean" }
        },
        "required": ["sentiment", "topics", "action_required"],
        "additionalProperties": false
      }
    }
  },
  "reasoning": { "effort": "low" },
  "stream": true
}

Was es zurückgibt (wörtlich, eine Zeile):

{"action_required":true,"sentiment":"negative","topics":["4K upscale endpoint","HTTP 500 errors","Service outage","Launch blocker","Urgent support"]}

Zwei Dinge solltest du verinnerlichen. Erstens: strict: true garantiert Typen und erforderliche Schlüssel, aber nicht die Schlüsselreihenfolge – beachte, dass action_required zuerst erscheint, obwohl es im Schema zuletzt aufgeführt ist; parse daher nach Schlüsselnamen, niemals nach Position. Zweitens: Du musst die Antwort weiterhin wie jede andere aus den response.output_text.delta-Blöcken akkumulieren; das Schema formt den Inhalt, nicht die Übertragung.

Rezept 4 – Tool-Aufrufe und Fortsetzung mit dem Ergebnis

gpt-6.1-sol kann Funktionen aufrufen und – wichtig – nach deiner Rückgabe des Ergebnisses fortsetzen. Deklariere ein tools-Array; wenn das Modell sich zum Aufruf entscheidet, gibt es ein function_call-Element statt Text aus.

{
  "model": "gpt-6.1-sol",
  "instructions": "Du kannst Tools aufrufen. Wenn der Nutzer nach einem Task fragt, rufe get_task_status auf.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Kannst du nachsehen, was mit task_abc123 los ist? Es ist schon lange pending." }
    ] }
  ],
  "tools": [
    {
      "type": "function",
      "name": "get_task_status",
      "description": "Fragt den Status einer asynchronen Bild-/Video-Generierungsaufgabe anhand der id ab.",
      "parameters": {
        "type": "object",
        "properties": { "task_id": { "type": "string", "description": "Die Task-id, z. B. 'task_abc123'." } },
        "required": ["task_id"],
        "additionalProperties": false
      }
    }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Die Antwort enthält keinen Text – nur einen Tool-Aufruf, der als function_call-Element im abschließenden Ereignis übergeben wird (dessen Argumente als response.function_call_arguments.delta-Blöcke gestreamt werden):

{
  "type": "function_call",
  "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b",
  "name": "get_task_status",
  "arguments": "{\"task_id\":\"task_abc123\"}"
}

Jetzt kommt die zweite Hälfte, die die Basiseinrichtung nicht abdeckt: Führe deine Funktion aus und gib das Ergebnis zurück – hänge den function_call des Modells und deine function_call_output (mit derselben call_id verknüpft) an das input-Array an und rufe erneut auf:

{
  "model": "gpt-6.1-sol",
  "instructions": "Du kannst Tools aufrufen. Fasse das Tool-Ergebnis für den Nutzer in ein bis zwei Sätzen zusammen.",
  "input": [
    { "type": "message", "role": "user", "content": [ { "type": "input_text", "text": "Kannst du nachsehen, was mit task_abc123 los ist? Es ist schon lange pending." } ] },
    { "type": "function_call", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "name": "get_task_status", "arguments": "{\"task_id\":\"task_abc123\"}" },
    { "type": "function_call_output", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "output": "{\"status\":\"failed\",\"error\":\"INVALID_REQUEST: image url could not be downloaded\",\"created_at\":\"2026-10-17T06:12:00Z\"}" }
  ],
  "tools": [ { "type": "function", "name": "get_task_status", "description": "Fragt den Status einer asynchronen Generierungsaufgabe anhand der id ab.", "parameters": { "type": "object", "properties": { "task_id": { "type": "string" } }, "required": ["task_id"], "additionalProperties": false } } ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Nach Erhalt des Ergebnisses antwortet es in einfacher Sprache (wörtlich):

Die Aufgabe task_abc123 ist nicht mehr pending – sie ist fehlgeschlagen, weil die Bild-URL nicht heruntergeladen werden konnte (INVALID_REQUEST). Bitte prüfe, ob die Bild-URL öffentlich erreichbar ist, und reiche die Aufgabe dann erneut ein.

Die call_id ist der Kleber: Deine function_call_output muss exakt die call_id aus dem function_call des Modells wiedergeben, sonst wird die Folge-Runde nicht daran gebunden.

Rezept 5 – Belegte Antworten über langen Kontext

Das 1,05-Mio.-Token-Fenster dient dazu, echtes Material – Logs, Changelogs, Spezifikationsdokumente – zu füttern und Fragen daraus zu beantworten. Das Prompt-Muster, das es ehrlich hält, liegt in den instructions: Zwinge es, nur anhand des bereitgestellten Textes zu antworten und für jeden Fakt die Quelle zu zitieren.

{
  "model": "gpt-6.1-sol",
  "instructions": "Antworte ausschließlich anhand des bereitgestellten CHANGELOG. Wenn ein Fakt nicht existiert, sage 'not in the changelog'. Zitiere das Datum für jeden verwendeten Fakt.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "<CHANGELOG hier einfügen>\nFrage: Die Ausgabe-URL einer Videoaufgabe hat mir gestern meine Datei zurückgegeben, aber heute 404. Außerdem geben meine Bildaufrufe plötzlich 402 zurück. Welche zwei Changelog-Einträge erklären das, und was sollte ich ändern?" }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Mit einem kurzen Plattform-Changelog extrahiert es genau die zwei relevanten Einträge, zitiert deren Daten und trennt „was passiert ist“ von „was zu ändern ist“ (wörtlich):

Zwei Einträge erklären die Probleme:

1. 2026-10-02 – Temporäre Ausgabe-URLs laufen ab. Ausgabe-URLs auf temp.hiapi.ai sind 7 Tage gültig und geben danach 404 zurück … Änderung: Lade die Bytes sofort herunter und speichere deine eigene Kopie; kein Hotlinking. Verfolge den Ablauf mit expireAt.

2. 2026-09-20 – Leeres Guthaben löst 402 bei Bildmodellen aus. Konten mit vollständig leerem Guthaben erhalten jetzt bei allen Bildmodellen HTTP 402 … Änderung: Prüfe, ob dein Kontoguthaben vollständig leer ist, und lade es gegebenenfalls auf.

Die Anweisung „Datum zitieren“ ist ein billiger Belegtrick: Sie macht Halluzinationen sichtbar (ein Fakt ohne zitierbares Datum ist ein erfundener Fakt) und macht die Antwort prüfbar. Denk an die Staffelpreise – Prompts mit über 272K Token Eingabe werden zum höheren Long-Context-Tarif abgerechnet.

Eine Falle aus diesem Lauf: Streams als UTF-8 dekodieren

Reasoning-Modelle mögen Gedankenstriche und geschwungene Anführungszeichen. Beim Schreiben dieses Artikels hat unser erster SSE-Reader mehrbyte-UTF-8-Zeichen auf zwei Netzwerk-Chunks aufgeteilt und einen sauberen Gedankenstrich („—“) in Zeichensalat („â“) verwandelt. Die Ausgabe des Modells war in Ordnung; der Client dekodierte zu eifrig zeilenweise. Die Lösung besteht darin, rohe Bytes zu puffern, an Zeilenumbrüchen zu splitten und jede vollständige Zeile als UTF-8 zu dekodieren – dekodiere keine unvollständigen Chunks. Wenn bei deiner gpt-6.1-sol-Ausgabe sporadisch Ã/â-Zeichen auftauchen, liegt die Ursache hier, nicht beim Modell.

Häufig gestellte Fragen

Worin unterscheidet sich das vom gpt-6.1-sol-Einrichtungsleitfaden? Der Einrichtungsleitfaden behandelt das Aufrufen des Modells – Authentifizierung, warum Streaming erforderlich ist, SSE-Parsing. Diese Seite behandelt das Prompten – die instructions/input/effort-Muster für konkrete Aufgaben und die Ausgaben, die sie erzeugen.

Kann ich einfach reasoning.effort auf max setzen, um die beste Antwort zu bekommen? Nicht kostenlos, und oft auch nicht besser. Bei unserem Testproblem erreichten xhigh und max beide ein Plateau bei etwa 620 Reasoning-Token und lieferten dieselbe Antwort wie high. Reasoning-Token werden als Ausgabe abgerechnet, daher kostet das Vollaufdrehen einfacher Prompts mehr Geld für dasselbe Ergebnis. Spare high+ für wirklich schwieriges Reasoning auf.

Wie erzwinge ich gültiges JSON, statt es im Prompt zu verlangen? Übergib ein text.format mit einem strict-json_schema (Rezept 3). Das Modell wird auf die Typen und erforderlichen Schlüssel des Schemas beschränkt. Parse nach Schlüsselnamen, da strict die Schlüsselreihenfolge nicht festlegt.

Warum kann ich temperature oder top_p nicht setzen? Diese Ausführungskonfiguration deaktiviert beide (sowie max_output_tokens). Forme die Ausgabe stattdessen über instructions, deine input und reasoning.effort.

Funktionieren Tool-Aufrufe genauso wie bei Chat-Modellen? Der Vertrag ist etwas anders: Tools werden im Top-Level-tools-Array deklariert, das Modell antwortet mit einem function_call-Element (keine Nachricht), und du setzt fort, indem du eine function_call_output mit passender call_id anhängst (Rezept 4).

Ist gpt-6.1-sol dasselbe wie gpt-5.6-sol? Sie gehören beide zur Sol-Familie und teilen diesen Responses-API-, reine Streaming-Vertrag; gpt-6.1-sol ist eine neuere Generation. Siehe gpt-6 Astra vs. gpt-5.6 Sol im Vergleich, um zu verstehen, wie die Generationen einander zugeordnet sind.

Starte hier

Kopiere ein beliebiges der obigen Rezepte in den Request-Body des Einrichtungsleitfadens, ersetze es durch deine eigene Aufgabe und passe reasoning.effort an die Schwierigkeit an. Eine Einführung in die Fähigkeiten und ein Online-Testfeld findest du auf der gpt-6.1-sol-Modellseite; Endpunkte und das gemeinsame Anfrageformat in der API-Dokumentation; die Raten pro Token auf der Preisseite. Ein einziger hiapi-Schlüssel gewährt Zugang zu gpt-6.1-sol sowie allen anderen Modellen der Plattform.