Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design

Vorhergesagte Ausgaben

Verkürze die Antwortzeit des Modells, wenn ein großer Teil der Antwort schon im Voraus bekannt ist.

Vorhergesagte Ausgaben beschleunigen API-Antworten von Chat Completions, wenn du viele der Ausgabetoken schon im Voraus kennst. Das ist häufig der Fall, wenn du eine Text- oder Codedatei mit kleinen Änderungen neu generieren lässt. Deine Vorhersage übergibst du in Chat Completions über den Anfrageparameter prediction.

Vorhergesagte Ausgaben sind mit den aktuellen Versionen der Modelle gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini und gpt-4.1-nano verfügbar. Die folgenden Beispiele zeigen dir, wie du damit die Latenz in deinen Anwendungen verringerst.

Beispiel für ein Code-Refactoring

Vorhergesagte Ausgaben eignen sich besonders gut, wenn du Textdokumente oder Codedateien mit kleinen Änderungen neu generieren lässt. Angenommen, du möchtest mit dem Modell GPT-4o JavaScript-Code überarbeiten und die Eigenschaft username der Klasse User in email umbenennen.

class User {
  firstName = "";
  lastName = "";
  username = "";
}

export default User;

Bis auf Zeile 4 bleibt die Datei unverändert. Wenn du den aktuellen Dateiinhalt als Vorhersage übergibst, kann das Modell die gesamte Datei schneller neu generieren. Bei größeren Dateien summiert sich die Zeitersparnis schnell.

Im folgenden Beispiel übergibst du den Inhalt der ursprünglichen Codedatei über den Parameter prediction in unseren SDKs. Damit gibst du an, dass du eine Modellausgabe erwartest, die dem ursprünglichen Code sehr ähnlich ist.

JavaScript-Klasse mit einer vorhergesagten Ausgabe überarbeiten
import OpenAI from "openai";

const code = `
class User {
  firstName = "";
  lastName = "";
  username = "";
}

export default User;
`.trim();

const openai = new OpenAI();

const refactorPrompt = `
Replace the "username" property with an "email" property. Respond only
with code, and with no markdown formatting.
`;

const completion = await openai.chat.completions.create({
  model: "gpt-4.1",
  messages: [
    {
      role: "user",
      content: refactorPrompt,
    },
    {
      role: "user",
      content: code,
    },
  ],
  store: true,
  prediction: {
    type: "content",
    content: code,
  },
});

// Inspect returned data
console.log(completion);
console.log(completion.choices[0].message.content);

Neben dem überarbeiteten Code enthält die Modellantwort Nutzungsdaten. Der folgende Auszug zeigt sie ohne das Feld choices.

{
  "id": "chatcmpl-xxx",
  "object": "chat.completion",
  "created": 1786652188,
  "model": "gpt-4.1-2025-04-14",
  "usage": {
    "prompt_tokens": 59,
    "completion_tokens": 24,
    "total_tokens": 83,
    "prompt_tokens_details": { "cached_tokens": 0, "audio_tokens": 0 },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 14,
      "rejected_prediction_tokens": 2
    }
  },
  "system_fingerprint": "fp_6ddb4f7408"
}

Achte auf die Felder accepted_prediction_tokens und rejected_prediction_tokens im Objekt usage. In diesem Beispiel hat das Modell 14 Token aus der Vorhersage übernommen und damit die Antwort beschleunigt. Zwei Token hat es verworfen.

Die API berechnet auch verworfene Token zum selben Preis wie andere von ihr generierte Ausgabetoken. Vorhergesagte Ausgaben können deine Anfragen daher verteuern.

Beispiel für Streaming

Wenn du API-Antworten per Streaming empfängst, lässt sich die Latenz mit vorhergesagten Ausgaben noch stärker verringern. Das folgende Beispiel zeigt dasselbe Code-Refactoring mit Streaming in den SDKs von OpenAI.

Vorhergesagte Ausgaben mit Streaming
import OpenAI from "openai";

const code = `
class User {
  firstName = "";
  lastName = "";
  username = "";
}

export default User;
`.trim();

const openai = new OpenAI();

const refactorPrompt = `
Replace the "username" property with an "email" property. Respond only
with code, and with no markdown formatting.
`;

const completion = await openai.chat.completions.create({
  model: "gpt-4.1",
  messages: [
    {
      role: "user",
      content: refactorPrompt,
    },
    {
      role: "user",
      content: code,
    },
  ],
  store: true,
  prediction: {
    type: "content",
    content: code,
  },
  stream: true,
});

// Inspect returned data
for await (const chunk of completion) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}

Position des vorhergesagten Textes in der Antwort

Der Text, den du als Vorhersage übergibst, kann an jeder Stelle der generierten Antwort stehen und die Antwortzeit trotzdem verkürzen. Angenommen, du übergibst als Vorhersage den Code für diesen einfachen Hono-Server.

import { serve } from "@hono/node-server";
import { serveStatic } from "@hono/node-server/serve-static";
import { Hono } from "hono";

const app = new Hono();

app.get("/api", (c) => {
  return c.text("Hello Hono!");
});

// You will need to build the client code first: `pnpm run ui:build`.
app.use(
  "/*",
  serveStatic({
    rewriteRequestPath: (path) => `./dist${path}`,
  })
);

const port = 3000;
console.log(`Server is running on port ${port}`);

serve({
  fetch: app.fetch,
  port,
});

Mit einem Prompt wie diesem kannst du das Modell bitten, die Datei neu zu generieren.

Füge der Anwendung eine GET-Route hinzu, die den Text „hello world“ zurückgibt.
Gib die gesamte Anwendungsdatei mit der neuen Route und ohne zusätzliche
Markdown-Formatierung aus.

Die Antwort auf den Prompt könnte so aussehen.

import { serve } from "@hono/node-server";
import { serveStatic } from "@hono/node-server/serve-static";
import { Hono } from "hono";

const app = new Hono();

app.get("/api", (c) => {
  return c.text("Hello Hono!");
});

app.get("/hello", (c) => {
  return c.text("hello world");
});

// You will need to build the client code first: `pnpm run ui:build`.
app.use(
  "/*",
  serveStatic({
    rewriteRequestPath: (path) => `./dist${path}`,
  })
);

const port = 3000;
console.log(`Server is running on port ${port}`);

serve({
  fetch: app.fetch,
  port,
});

Auch in der gekürzten Modellantwort ohne das Feld choices siehst du, wie viele vorhergesagte Token das Modell übernommen hat. Der vorhergesagte Text steht hier teils vor und teils nach dem neu eingefügten Code.

{
  "id": "chatcmpl-xxx",
  "object": "chat.completion",
  "created": 1731014771,
  "model": "gpt-4o-2024-08-06",
  "usage": {
    "prompt_tokens": 203,
    "completion_tokens": 159,
    "total_tokens": 362,
    "prompt_tokens_details": { "cached_tokens": 0, "audio_tokens": 0 },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 60,
      "rejected_prediction_tokens": 0
    }
  },
  "system_fingerprint": "fp_9ee9e968ea"
}

Diesmal hat das Modell kein einziges vorhergesagtes Token verworfen, weil es den gesamten als Vorhersage übergebenen Dateiinhalt in die Antwort übernommen hat. Sehr gut! 🔥

Einschränkungen

Beachte beim Einsatz vorhergesagter Ausgaben die folgenden Punkte.

  • Nur die Modellreihen GPT-4o, GPT-4o mini, GPT-4.1, GPT-4.1 mini und GPT-4.1 nano unterstützen vorhergesagte Ausgaben.
  • Die API berechnet auch die Token aus deiner Vorhersage, die in der endgültigen Antwort fehlen, zum Preis für Ausgabetoken. An der Eigenschaft rejected_prediction_tokens des Objekts usage siehst du, wie viele Token das Modell für die Antwort verworfen hat.
  • Für die folgenden API-Parameter gelten bei vorhergesagten Ausgaben Einschränkungen.
    • n: Werte über 1 werden nicht unterstützt.
    • logprobs: Wird nicht unterstützt.
    • presence_penalty: Werte über 0 werden nicht unterstützt.
    • frequency_penalty: Werte über 0 werden nicht unterstützt.
    • audio: Vorhergesagte Ausgaben sind mit Audioein- und -ausgaben nicht kompatibel.
    • modalities: Nur die Modalität text wird unterstützt.
    • max_completion_tokens: Wird nicht unterstützt.
    • tools: Funktionsaufrufe werden bei vorhergesagten Ausgaben derzeit nicht unterstützt.