> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Unterstützte Modelle
> Die Modelle, die FlexInference routet, und die von ihnen akzeptierten Eingaben.
FlexInference routet Modell-Aliase von **OpenAI**, **Google Gemini** und **Anthropic**. Übergeben Sie das Modell über seinen **Alias** (z. B. `gpt-5.5` oder `gemini-3.5-flash`), nicht über einen datierten Snapshot.
Setzen Sie `start_within` auf die längste Zeit, die Sie auf den Start der Anfrage warten möchten. Der Surface Planner führt den flex race nur für die unten aufgeführten flex-fähigen OpenAI- und Gemini-Modelle aus: Er versucht, den günstigeren provider flex tier gegen dieses Budget zu nutzen, und wechselt dann zum standard tier, wenn flex nicht rechtzeitig startet. Die vollständige Funktionsweise finden Sie unter [Wie flex racing funktioniert](/de/deadline-routing).
Für Anfragen ohne Dauerangabe leitet FlexInference jedes Modell auf den von ihm unterstützten provider tiers weiter. Gemini hat keinen `auto` tier, daher gibt `auto` bei einem Gemini-Modell `400 auto_unsupported_for_gemini` zurück.
## Flex-fähige Modelle
### OpenAI
`gpt-5.6`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`
`gpt-5.5`, `gpt-5.5-pro`
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`, `gpt-5.4-pro`
`gpt-5.2`
`gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-5.1`
`o3`, `o4-mini`
### Gemini
`gemini-3.5-flash`, `gemini-3.1-pro-preview`, `gemini-3.1-flash-lite`
`gemini-3-flash-preview`
`gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-2.5-flash-lite`
Eine Dauer `start_within` bei einem OpenAI- oder Gemini-Modell außerhalb dieser Zulassungsliste führt nicht zum flex race. FlexInference gibt `400 flex_model_not_capable` zurück. Wählen Sie ein aufgeführtes Modell, um flex zu nutzen. Um den flex race zu überspringen, senden Sie einen tier-Wert anstelle einer Dauer: `default`, `priority` oder, falls unterstützt, `auto`. FlexInference leitet unterstützte tier-Anfragen an den provider weiter. Für Gemini wird `default` auf Geminis **standard** tier abgebildet, und `auto` gibt `400 auto_unsupported_for_gemini` zurück.
## Anthropic (Claude)
Claude-Modelle werden an Anthropic geroutet und sind **nur Proxy**. Sie unterstützen `default`, `priority` und `auto`, aber nicht den flex race. Eine Dauer `start_within` bei einem `claude-*`-Modell gibt `400 flex_unsupported_for_anthropic` zurück, da Anthropic keinen flex tier hat.
`default` wird auf Anthropic's **standard\_only** service tier abgebildet. `auto` lässt Anthropic wählen. `priority` ist ein Best-Effort-Ansatz und wird auf `auto` abgebildet, da Anthropic einen expliziten priority tier ablehnt.
Anthropic erfordert `max_tokens` upstream. FlexInference leitet Ihr output-token-Feld weiter, wenn Sie eines setzen, und synthetisiert keinen Standardwert, wenn Sie es weglassen. Daher gibt Anthropic seinen eigenen Anfragefehler für fehlende Limits zurück.
`claude-opus-4-8`, `claude-opus-4-7`, `claude-opus-4-6`, `claude-opus-4-5`,
`claude-opus-4-1`
`claude-sonnet-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`
`claude-haiku-4-5`
`claude-fable-5`
Claude funktioniert mit jedem unterstützten Aufruferformat: `/v1/responses`, `/v1/chat/completions`, `/v1/interactions` und der Anthropic-nativen [`/v1/messages`](/de/sdks). FlexInference übersetzt jedes davon in Anthropic's Messages API. Anthropic entscheidet über den bereitgestellten tier. Eine `standard_only`-Anfrage wird in der Antwort als `"service_tier": "standard"` gemeldet.
## Provider-Routing
Ein optionales, geordnetes `provider`-Array legt die Route fest, die Ihre Anfrage nimmt. Element 0 ist die primäre Route und das einzige flex gate; die Elemente 1 bis n bilden die Fallback-Kette für dasselbe Modell, die der Reihe nach versucht wird, wenn eine Route vorübergehend fehlschlägt. Lassen Sie `provider` weg, und FlexInference verwendet die native direkte Route des Modells, genau wie zuvor. Das Setzen des Arrays auf die native Route Ihres Modells ist eine Routing-No-Op, die dasselbe Verhalten explizit festlegt.
`google`, `openai` und `anthropic` sind **direkte Routen**. `vertex` (Gemini) und `bedrock` (Claude) sind **Cloud-Routen**, die dasselbe Modell über einen anderen provider bereitstellen: `bedrock` stellt `claude-*` über Amazon Bedrock (Bedrock Converse) bereit, und `vertex` stellt `gemini-*` über Google Vertex AI (Vertex generateContent) bereit. Ein provider fallback ändert nur die Route: Es ändert niemals das Modell oder den tier, und ein Fallback-Eintrag ist immer ein einfacher standard call, niemals ein flex race.
### Jede von Ihnen benannte Route benötigt ihren Schlüssel
Eine Kette ist eine Deklaration, dass Sie jede Route darin konfiguriert haben. Jede Route verwendet ihren eigenen BYOK key: `openai` verwendet Ihren OpenAI key, `google` Ihren Gemini key, `anthropic` Ihren Anthropic key, `vertex` Ihren Vertex express key und `bedrock` Ihren Bedrock key und Ihre Region. Fügen Sie diese im Dashboard unter Settings -> API keys hinzu, bevor Sie die Route benennen.
Ein fehlender Schlüssel ist ein Konfigurationsfehler, keine vorübergehende Störung, daher wird nicht auf die nächste Route zurückgegriffen. FlexInference lehnt die Anfrage mit dem `400 no_..._key`-Code für die Route ab, deren Schlüssel fehlt, bevor ein upstream call und bevor abrechenbare Arbeit geleistet wird. `["bedrock","anthropic"]` ohne einen Bedrock key gibt [`400 no_bedrock_key`](/de/errors#no_bedrock_key) zurück, selbst wenn Ihr Anthropic key vorhanden ist und das Modell hätte bedienen können. Ein Fallback hier würde die unkonfigurierte Route verbergen und Sie stillschweigend über einen provider bedienen, den Sie nicht verwenden wollten. Daher informiert FlexInference Sie stattdessen. Fügen Sie den fehlenden Schlüssel hinzu oder entfernen Sie diese Route aus der Kette.
Fallback deckt vorübergehende upstream-Fehler und nichts anderes ab: einen `429`, einen `5xx`, einen Verbindungsfehler oder einen Timeout, die jeweils abgefangen werden, bevor die Antwort festgeschrieben wird. Alles, wofür eine Route im Voraus abgelehnt werden kann, einschließlich eines fehlenden Schlüssels, eines Modells, das die Route nicht bedienen kann, und einer fehlerhaften Kette, ist Ihre Aufgabe zu beheben und gibt einen `400` zurück.
Jede Route bedient eine Modellfamilie, daher gibt eine Kette, die eine Route festlegt, die Ihr Modell nicht bedienen kann, [`400 provider_model_mismatch`](/de/errors#provider_model_mismatch) zurück. `openai` bedient GPT- und o-series-Modelle, `google` und `vertex` bedienen Gemini, und `anthropic` und `bedrock` bedienen Claude.
| Modell | Native direkte Route | Cloud-Route | Beispiel gültiger Arrays | Flex race? |
| ---------------------- | -------------------- | ----------- | ------------------------------------------------------------------------------------ | ----------------------------------------------------------------- |
| `claude-*` | `anthropic` | `bedrock` | `["anthropic"]`, `["bedrock"]`, `["anthropic","bedrock"]`, `["bedrock","anthropic"]` | Nein, Claude hat keinen flex tier |
| Flex-fähige `gemini-*` | `google` | `vertex` | `["google"]`, `["vertex"]`, `["google","vertex"]`, `["vertex","google"]` | Nur wenn Element 0 `google` ist und `start_within` eine Dauer ist |
| Nicht-flex `gemini-*` | `google` | `vertex` | wie oben | Nein, nicht auf der flex-Zulassungsliste |
| Flex-fähige `gpt-*` | `openai` | none | `["openai"]` | Nur wenn Element 0 `openai` ist und `start_within` eine Dauer ist |
| Nicht-flex `gpt-*` | `openai` | none | `["openai"]` | Nein, nicht auf der flex-Zulassungsliste |
Eine ein-elementige Cloud-First-Kette wie `["vertex"]` oder `["bedrock"]` ist eine gültige direkte Route ohne flex zu diesem Cloud-provider. Eine Dauer `start_within` mit einer Cloud-Route als Element 0 gibt [`400 flex_unsupported_on_cloud`](/de/errors#flex_unsupported_on_cloud) zurück, da Cloud-Routen keinen flex tier für den race haben; senden Sie stattdessen einen tier-Wert (`default`, `priority` oder `auto`). Ein fehlerhaftes Array (ein unbekannter Name, ein Duplikat, ein leeres Array oder mehr als drei Einträge) gibt [`400 invalid_provider_chain`](/de/errors#invalid_provider_chain) zurück.
### Claude auf Bedrock: globales Routing, opus-4-1 und Zugriffsberechtigungen
Die `bedrock`-Route bedient Claude über Amazons regionenübergreifende Inferenzprofile. FlexInference routet es **global-first**: Jedes `claude-*`-Modell, das es auf Bedrock bedient, wird über ein globales Inferenzprofil adressiert, sodass es aus jeder AWS-Region bedient wird, unabhängig davon, wo der Bedrock key Ihrer Organisation gesetzt ist. Eine Konsequenz ist ein wissenswerter Kompromiss bei der Datenresidenz: Ein globales Profil routet jede Anfrage über alle unterstützten AWS-Regionen, sodass nicht garantiert ist, dass eine Anfrage in Ihrer eigenen Region ausgeführt wird. Unter global-first garantiert keine Route die Verarbeitung in einer bestimmten AWS-Region, und die `anthropic` direkte Route ist keine In-Region-Alternative: Sie erreicht Anthropic's eigene Infrastruktur, nicht Ihr AWS-Konto. Wenn die In-Region-Verarbeitung eine Anforderung ist, ist ein regionsgebundenes Bedrock-Profil (`us.` oder `eu.`, passend zur Region Ihres Bedrock key) auf Anfrage über eine organisationsspezifische Datenresidenzrichtlinie verfügbar.
`claude-opus-4-1` ist die einzige Ausnahme, die **überhaupt nicht auf der `bedrock`-Route verfügbar ist**. Amazon veröffentlicht es nur in den USA und nicht einmal in jeder US-Region. Anstatt eine partielle Regionsausnahme zu führen, bedient FlexInference es nur über die `anthropic` direkte Route; eine `["bedrock"]`-Kette dafür gibt in jeder Region [`400 bedrock_model_unavailable`](/de/errors#bedrock_model_unavailable) zurück. Es ist immer über die `anthropic` direkte Route verfügbar, daher lassen Sie `provider` weg oder senden Sie `["anthropic"]`, um es aus jeder Region zu erreichen.
Unabhängig davon kann ein Modell global bereitgestellt werden und dennoch für Ihr AWS-Konto gesperrt sein, bis Sie in der Amazon Bedrock-Konsole Zugriff darauf anfordern. Wenn Bedrock das Modell hat, Ihr AWS-Konto jedoch keinen Zugriff darauf erhalten hat, erhalten Sie [`403 bedrock_model_access_denied`](/de/errors#bedrock_model_access_denied), der das Modell benennt und zitiert, was Bedrock gesagt hat. (Der andere Fall, [`400 bedrock_model_unavailable`](/de/errors#bedrock_model_unavailable) für ein Modell, für das Bedrock kein Profil veröffentlicht, gilt nun effektiv nur für `claude-opus-4-1`, da jedes andere bereitgestellte Modell ein globales Profil hat.)
Keines davon ist ein Problem mit Ihrem Bedrock key, und ein funktionierender Schlüssel bleibt funktionsfähig: Beide Fehler beziehen sich auf das Modell, nicht auf die Anmeldeinformationen. Keines davon fällt auch auf die nächste Route in der Kette zurück, da eine von Ihnen benannte Route eine Route ist, die Sie eingerichtet haben sollten. Senden Sie das Modell stattdessen an die `anthropic`-Route oder gewähren Sie dem AWS-Konto Zugriff darauf.
### Die neuesten Claude-Modelle auf Bedrock erfordern eine einmalige Kontoeinrichtung
Fünf Claude-Modelle werden über die `bedrock`-Route bereitgestellt, sobald das AWS-Konto die normale **Modellzugriffsberechtigung** hat: `claude-haiku-4-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`, `claude-opus-4-6` und `claude-opus-4-5`.
Die vier neuesten Modelle – `claude-sonnet-5`, `claude-fable-5`, `claude-opus-4-8` und `claude-opus-4-7` – benötigen zwei zusätzliche einmalige Schritte im AWS-Konto, bevor Bedrock sie bereitstellt. Die **Modellzugriffsberechtigung** in der Amazon Bedrock-Konsole allein aktiviert sie nicht. Führen Sie beide Schritte einmal pro AWS-Konto aus, unter Verwendung der AWS-Anmeldeinformationen eines Administrators (nicht Ihres Bedrock inference key).
**Schritt 1 – Das Konto für die provider data sharing anmelden.** Dieser Schritt hat keine Konsolen-Benutzeroberfläche und muss daher über die AWS CLI ausgeführt werden:
```bash theme={null}
aws bedrock put-account-data-retention --mode provider_data_share
```
**Schritt 2 – Akzeptieren Sie die Modellvereinbarung** für jedes dieser Modelle, die Sie aufrufen möchten (einmal pro Modell ausführen):
```bash theme={null}
aws bedrock create-foundation-model-agreement
```
Bis beide Schritte abgeschlossen sind, gibt eine `bedrock`-Anfrage für eines dieser vier Modelle [`403 bedrock_model_access_denied`](/de/errors#bedrock_model_access_denied) zurück. Dies ist eine Anforderung des Amazon Bedrock-Kontos, keine von FlexInference, daher ist es dasselbe, ob Sie Bedrock über FlexInference oder direkt erreichen. `claude-opus-4-1` ist davon nicht betroffen, da es überhaupt nicht über die `bedrock`-Route bereitgestellt wird; erreichen Sie es über die `anthropic`-Route.
`vertex` und `bedrock` Cloud-Routen sind heute verfügbar. `bedrock` bedient `claude-*`
über Amazon Bedrock und `vertex` bedient `gemini-*` über Google Vertex
AI, immer dasselbe Modell, das Sie angefordert haben. Jede Cloud-Route benötigt den
eigenen Schlüssel dieser Cloud, der im Dashboard hinzugefügt wird: einen Vertex express key
(Präfix `AQ.`) für `vertex`, einen Bedrock bearer key (Präfix `ABSK`) und die Region für `bedrock`. Cloud-Routen
laufen nur im standard tier, ohne flex race. Beide Cloud-Routen
unterstützen Text, Bilder und Dateien: Eine remote `https` Bild- oder Datei-URL wird
serverseitig abgerufen und für sie inline eingefügt (siehe [Eingaben](#inputs) unten).
## Funktionen pro Route
Die Tabelle zeigt die schnellen Ja/Nein-Antworten pro Route. Jede Route unterstützt Text, Streaming, function calling, Bilder, Dateien (einschließlich PDFs) und thinking/reasoning; die Zeilen unterhalb der Basislinie zeigen, wo sich die Routen unterscheiden. `openai`, `anthropic` und `google` sind die direkten Routen; `vertex` und `bedrock` sind die Cloud-Routen.
| Funktion | OpenAI (`openai`) | Anthropic (`anthropic`) | Gemini (`google`) | Vertex (`vertex`) | Bedrock (`bedrock`) |
| ----------------------------------------- | ----------------- | ----------------------- | ----------------- | ----------------- | ------------------- |
| Text, Streaming, function calling | Ja | Ja | Ja | Ja | Ja |
| Bilder und Dateien (einschließlich PDF) | Ja | Ja | Ja | Ja | Ja |
| Thinking / reasoning | Ja | Ja | Ja | Ja | Ja\* |
| Web search | Ja | Ja | Ja | Ja | Nein |
| Zitate (`url_citation`) | Ja | Ja | Ja | Ja | Nein |
| Strukturierte Ausgaben (`json_schema`) | Ja | Ja | Ja | Ja | Nein |
| `json_object` Ausgabeformat | Ja | Nein | Ja | Ja | Nein |
| Strenges Schema (`text.format.strict`) | Ja | Nein | Nein | Nein | Nein |
| `code_execution` / `url_context` (Gemini) | Nein | Nein | Ja | Ja | Nein |
\*Bedrock führt thinking aus, aber fasst reasoning tokens in der Ausgabezählung zusammen und meldet keine separate Gesamtzahl an reasoning tokens; Vertex meldet reasoning tokens.
Ein `No` ist ein lautes `400 unsupported_parameter`, kein stilles Weglassen. Senden Sie `web_search`, eine `json_schema` strukturierte Ausgabe oder `text.format.strict: true` an eine Route, die dies nicht unterstützt, und FlexInference lehnt die Anfrage ab und benennt das Feld. Routen Sie web search oder strukturierte Ausgaben an jede direkte Route oder `vertex`, und routen Sie die strikte Schema-Konformität an `openai`.
## Flex-Ergebnisse und Fehler
`x-flexinference-flex-*`-Header melden flex outcomes bei erfolgreichen Antworten. Validierungsfehler verwenden weiterhin den normalen Fehlertext. Die vollständige Fehlerstruktur und die Flex outcome headers finden Sie auf der [Fehlerseite](/de/errors).
* `flex_model_not_capable` bedeutet, dass Sie eine Dauer `start_within` an ein OpenAI- oder Gemini-Modell außerhalb der flex-Zulassungsliste gesendet haben. Verwenden Sie einen tier-Wert oder wählen Sie ein flex-fähiges Modell.
* `auto_unsupported_for_gemini` bedeutet, dass Sie `auto` bei einem Gemini-Modell angefordert haben, das keinen `auto` tier hat. Verwenden Sie `default` für Geminis standard tier.
* `flex_unsupported_for_anthropic` bedeutet, dass Sie eine Dauer `start_within` an ein `claude-*`-Modell gesendet haben. Verwenden Sie `default`, `priority` oder `auto` für Claude.
## Eingaben
Diese Routen akzeptieren OpenAI-kompatible Eingaben:
* **Text**: system-, developer-, user- und assistant-Nachrichten.
* **Bilder**: Übergeben Sie Bild-URLs oder base64 data URLs. Base64 data URLs sind am zuverlässigsten. Für die Bedrock- und Vertex-Routen, die Inline-Bytes benötigen, wird eine remote `https` Bild-URL serverseitig heruntergeladen und für Sie inline eingefügt, hinter SSRF-Sicherheitsprüfungen (nur https, keine privaten oder Metadaten-Hosts, eine Größenbeschränkung und eine Magic-Byte-Typüberprüfung für png/jpeg/gif/webp); eine URL, die eine Prüfung nicht besteht, gibt `400 unsupported_parameter` zurück, anstatt stillschweigend verworfen zu werden.
* **Dateien**: PDFs und andere Dateieingaben, die die Responses API akzeptiert. Remote `https` PDF-URLs werden für Bedrock und Vertex unter denselben Prüfungen heruntergeladen und inline eingefügt.
Ausgaben sind Text, einschließlich tool calls, structured outputs und reasoning. Streaming funktioniert bei jedem Modell. Bei Gemini wird `reasoning.effort` auf ein modellspezifisches `thinking_level` abgebildet und kann auf den vom Modell unterstützten Bereich begrenzt werden.
Native provider parameters werden nur durchgereicht, wenn das Modell zu diesem provider gehört. Siehe [SDKs](/de/sdks) für endpunktspezifische Passthrough-Regeln.
Die [Funktionsmatrix](#capabilities-by-route) oben zeigt die Ja/Nein-Antworten pro Route;
diese Anmerkung beschreibt, wie die gemeinsamen Funktionen auf jeden provider abgebildet werden. Für web search
senden Sie ein Responses `web_search` tool; Gemini bildet es auf `google_search`
ab und Anthropic auf sein `web_search_20250305` tool. Unabhängig davon, welcher provider
die Anfrage bedient, gibt `web_search` (und Geminis `url_context`) seine Quellen als
kanonische `url_citation`-Annotationen in der Nachrichtenausgabe zurück, sodass Sie Zitate
unabhängig von der Route auf dieselbe Weise lesen. Structured outputs (`text.format`
mit einem `json_schema`) werden auf Geminis `response_format` und Anthropic's
`output_config` abgebildet; `json_object` wird auf Gemini, aber nicht auf Anthropic abgebildet.
Das `strict`-Flag wird nur bei OpenAI berücksichtigt. Gemini, Vertex und Anthropic
respektieren die Form des Antwortschemas, können aber keine strikte Konformität garantieren,
daher gibt `text.format.strict: true` dort `400 unsupported_parameter` zurück, anstatt
stillschweigend ignoriert zu werden; lassen Sie `strict` weg oder routen Sie zu OpenAI, um es durchzusetzen.
Gemini akzeptiert zusätzlich die `code_execution`- und `url_context`-Tools sowie `top_k`.
Übergeben Sie Dateien als base64 data URLs; PDFs sind bei Gemini am zuverlässigsten.
FlexInference fügt neue flex-fähige Modelle von OpenAI und Gemini hinzu, sobald die
provider diese bereitstellen. Wenn ein von Ihnen erwartetes Modell fehlt, überprüfen Sie, ob Sie
seinen Alias verwenden und ob der provider einen flex tier dafür anbietet.