Zum Hauptinhalt springen
FIM One ist anbieterunabhängig — jeder OpenAI-kompatible Endpunkt funktioniert. Diese Seite hilft Ihnen, die beste Modellkombination für Ihren Anwendungsfall auszuwählen. Konfigurationsdetails finden Sie unter Umgebungsvariablen.

​
Wie FIM One Modelle nutzt

FIM One hat zwei Modell-Slots:
SlotUmgebungsvariableVerwendet für
Main LLMLLM_MODELPlanung, Analyse, ReAct-Agent, komplexes Reasoning
Fast LLMFAST_LLM_MODELDAG-Schrittausführung, Kontext-Komprimierung (günstiger, schneller)
Wenn FAST_LLM_MODEL nicht gesetzt ist, wird auf LLM_MODEL zurückgegriffen. Für Produktionsbereitstellungen bietet die Aufteilung in zwei Modelle das beste Kosten-Qualitäts-Verhältnis.

​
Schnellauswahlmatrix

AnbieterHaupt-LLMSchnelles LLMReasoningHinweise
OpenAIgpt-5.4 / o3gpt-5-mini / gpt-5-nano✅ reasoning_effortBeste native Tool-Aufrufe; GPT-5.4 ist das neueste Flaggschiff
Anthropicclaude-sonnet-4-6claude-haiku-4-5✅ via LiteLLMNative API-Weiterleitung; vollständige reasoning_content-Unterstützung
Google Geminigemini-2.5-pro / gemini-3.1-pro-previewgemini-2.5-flash / gemini-3-flash-preview✅ reasoning_effort2.5 ist stabiles GA; 3.x ist Vorschau
DeepSeekdeepseek-chat (V3.2)deepseek-chat✅ deepseek-reasonerBestes Kosten-/Leistungsverhältnis; V4 steht bevor
Qwen (Alibaba)qwen3.5-plus / qwen3-maxqwen-turbo✅ qwen3-max-thinkingStärkste Unterstützung für chinesische Sprache
ChatGLM (Zhipu)glm-5glm-4-flash❌GLM-5 ist 744B MoE; kostenlos auf glm-4-flash
MiniMaxMiniMax-M2.5MiniMax-M2.5-Lightning❌Open-Weight, starke Codierung (80,2% SWE-Bench)
Kimi (Moonshot)kimi-k2.5kimi-k2.5❌256K Kontext, starke Codierung
Ollama (lokal)qwen3.5 / llama4qwen3.5:9b❌Vollständig offline, kein API-Schlüssel

​
Anbieterdetails

​
OpenAI

Die am meisten bewährte Option. OpenAI-Modelle haben die beste native Unterstützung für Funktionsaufrufe (Tool-Calling), was sich direkt auf die Zuverlässigkeit von Agenten auswirkt. Die GPT-5-Familie (August 2025+) stellt einen großen generationalen Sprung gegenüber GPT-4 dar. Empfohlene Modelle:
  • Hauptmodell: gpt-5.4 (neuestes Flaggschiff, März 2026 — integrierte Computernutzung) oder o3 (beste Reasoning-Genauigkeit)
  • Schnell: gpt-5-mini (0,25/0,25/2,00 pro MTok) oder gpt-5-nano (günstigste bei 0,05/0,05/0,40 pro MTok)
  • Legacy: gpt-4.1 (noch in API, 1M Kontext, gut für Coding) — aus ChatGPT Februar 2026 eingestellt
Reasoning: Setzen Sie LLM_REASONING_EFFORT=medium — funktioniert nativ mit o-Series- und GPT-5.x-Modellen. Die o-Series erfordert max_completion_tokens anstelle von max_tokens, was LiteLLM automatisch handhabt. Hinweis: GPT-5.x unterstützt reasoning_effort nicht in Kombination mit Tool-Calling in /v1/chat/completions — FIM One löscht es während der Agent-Tool-Use-Schritte automatisch, damit Workflows unterbrechungsfrei ablaufen. GPT-5.x unterstützt auch nur temperature=1 — FIM One handhabt dies automatisch über die Parameterfilterung von LiteLLM (drop_params).
ModellInput $/MTokOutput $/MTokKontext
gpt-5.4$2,50$15,00272K
o3$2,00$8,00200K
o4-mini$1,10$4,40200K
gpt-5-mini$0,25$2,00—
gpt-5-nano$0,05$0,40—
# .env — OpenAI (Produktion mit Reasoning)
LLM_API_KEY=sk-...
LLM_BASE_URL=https://api.openai.com/v1
LLM_MODEL=gpt-5.4
FAST_LLM_MODEL=gpt-5-nano
LLM_REASONING_EFFORT=medium

# .env — OpenAI (Budget-Reasoning)
LLM_API_KEY=sk-...
LLM_BASE_URL=https://api.openai.com/v1
LLM_MODEL=o3
FAST_LLM_MODEL=gpt-5-nano
LLM_REASONING_EFFORT=medium

​
Anthropic (Claude)

Claude zeichnet sich durch differenziertes Denken und komplexe mehrstufige Aufgaben aus. FIM One verbindet sich über LiteLLM, das Anthropic-Modelle automatisch über ihre native API leitet. Die aktuelle Generation ist Claude 4.6 (Februar 2026). Empfohlene Modelle:
  • Main: claude-sonnet-4-6 (beste Balance zwischen Leistung und Kosten — 3/3/15 pro MTok)
  • Fast: claude-haiku-4-5 (schnell und günstig — 1/1/5 pro MTok)
  • Premium: claude-opus-4-6 (am leistungsfähigsten, 128K maximale Ausgabe — 5/5/25 pro MTok)
Basis-URL: https://api.anthropic.com/v1/ Alle aktuellen Claude-Modelle unterstützen erweitertes Denken und haben ein 200K-Kontextfenster (1M in Beta). Reasoning: Setzen Sie LLM_REASONING_EFFORT=medium — LiteLLM leitet Anthropic-Modelle über die native API, sodass reasoning_content (erweitertes Denken) vollständig zurückgegeben und im UI-Schritt “thinking” sichtbar ist. Wenn erweitertes Denken aktiviert ist, erfordert Anthropic temperature=1 — setzen Sie LLM_TEMPERATURE=1 in Ihrer .env oder Modellkonfiguration. Siehe Extended Thinking für Details.

​
.env — Anthropic Claude

LLM_API_KEY=sk-ant-… LLM_BASE_URL=https://api.anthropic.com/v1/ LLM_MODEL=claude-sonnet-4-6 FAST_LLM_MODEL=claude-haiku-4-5 LLM_REASONING_EFFORT=medium 

---

### Google Gemini

Gemini-Modelle bieten starke Leistung zu wettbewerbsfähigen Preisen über Googles OpenAI-kompatiblen Endpunkt. Die 3.x-Generation (Ende 2025+) ist ein großer Sprung — Gemini 3 Flash übertrifft 2.5 Pro und ist dabei 3x schneller.

**Empfohlene Modelle:**
- Stabil (GA): `gemini-2.5-pro` (Hauptmodell) + `gemini-2.5-flash` (schnell) — produktionsreif
- Neueste (Vorschau): `gemini-3.1-pro-preview` (Hauptmodell) + `gemini-3-flash-preview` (schnell) — beste Leistung, aber Vorschaustatus

**Basis-URL:** `https://generativelanguage.googleapis.com/v1beta/openai/`

**Reasoning:** `reasoning_effort` wird auf dem Kompatibilitäts-Endpunkt unterstützt — setzen Sie `LLM_REASONING_EFFORT=medium` und es funktioniert sofort.

| Modell | Eingabe $/MTok | Ausgabe $/MTok | Status |
|---|---|---|---|
| `gemini-3.1-pro-preview` | $2.00 | $12.00 | Vorschau |
| `gemini-3-flash-preview` | $0.50 | $3.00 | Vorschau |
| `gemini-2.5-pro` | $1.25 | $10.00 | Stabil GA |
| `gemini-2.5-flash` | $0.30 | $2.50 | Stabil GA |
| `gemini-2.5-flash-lite` | $0.10 | $0.40 | Stabil GA |

```bash
# .env — Gemini (stabil)
LLM_API_KEY=AIza...
LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/
LLM_MODEL=gemini-2.5-pro
FAST_LLM_MODEL=gemini-2.5-flash
LLM_REASONING_EFFORT=medium

# .env — Gemini (latest preview)
LLM_API_KEY=AIza...
LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/
LLM_MODEL=gemini-3.1-pro-preview
FAST_LLM_MODEL=gemini-3-flash-preview
LLM_REASONING_EFFORT=medium

​
DeepSeek

DeepSeek bietet das beste Kosten-Leistungs-Verhältnis auf dem Markt. V3.2 (Dezember 2025) vereinigte die Chat- und Reasoning-Linien in einem einzigen Modell mit unglaublich niedrigen Preisen. Modell-IDs (beide unterstützt durch V3.2):
  • deepseek-chat — allgemeiner Zweck (Non-Thinking-Modus)
  • deepseek-reasoner — Chain-of-Thought-Reasoning-Modus, gibt reasoning_content zurück
Basis-URL: https://api.deepseek.com Preisgestaltung: 0,28/0,28/0,42 pro MTok (Cache-Treffer: $0,028) — bei weitem die günstigste Frontier-Klasse-API.
V4 steht unmittelbar bevor (März 2026): Billionen-Parameter-Multimodal-Modell mit 1M-Kontextfenster. Erwarten Sie neue Modell-IDs bei der Veröffentlichung. 
# .env — DeepSeek (kostengünstig)
LLM_API_KEY=sk-...
LLM_BASE_URL=https://api.deepseek.com
LLM_MODEL=deepseek-chat
FAST_LLM_MODEL=deepseek-chat

# .env — DeepSeek (mit Reasoning)
LLM_API_KEY=sk-...
LLM_BASE_URL=https://api.deepseek.com
LLM_MODEL=deepseek-reasoner
FAST_LLM_MODEL=deepseek-chat

​
Chinesische inländische Modelle

Alle großen chinesischen Modellanbieter stellen OpenAI-kompatible Endpunkte zur Verfügung. Diese sind besonders stark für chinesischsprachige Aufgaben geeignet und bieten wettbewerbsfähige lokale Preise.

​
Qwen / 通义千问 (Alibaba Cloud)

Qwen 3.5 (Februar 2026) ist die neueste Generation — das 397B MoE Flaggschiff übertrifft GPT-5.2 bei MMLU-Pro.
  • Basis-URL: https://dashscope.aliyuncs.com/compatible-mode/v1
  • International: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
  • Main: qwen3.5-plus (Flaggschiff, 1M Kontext) oder qwen3-max (Billionen-Parameter)
  • Schnell: qwen-turbo (schnell und günstig)
  • Reasoning: qwen3-max-thinking (vergleichbar mit GPT-5.2-Thinking)
# .env — Qwen
LLM_API_KEY=sk-...
LLM_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
LLM_MODEL=qwen3.5-plus
FAST_LLM_MODEL=qwen-turbo

​
ChatGLM / 智谱

GLM-5 (2026) ist das neueste Flaggschiff — 744B Gesamtparameter (40B aktiv), nähert sich Claude Opus-Niveau bei Coding-/Agent-Aufgaben.
  • Basis-URL: https://open.bigmodel.cn/api/paas/v4
  • Hauptmodell: glm-5 (Flaggschiff)
  • Schnell: glm-4-flash (kostenlose Stufe verfügbar!)
Einige HTTP-Clients hängen automatisch /v1 an Basis-URLs an. Zhipu verwendet /v4 — stellen Sie sicher, dass Ihr Client keinen OpenAI-ähnlichen Pfad-Suffix erzwingt, sonst erhalten Sie 404-Fehler.
# .env — ChatGLM
LLM_API_KEY=...
LLM_BASE_URL=https://open.bigmodel.cn/api/paas/v4
LLM_MODEL=glm-5
FAST_LLM_MODEL=glm-4-flash

​
MiniMax

MiniMax M2.5 (Februar 2026) ist Open-Weight und erreicht 80,2% bei SWE-Bench.
  • Basis-URL (China): https://api.minimaxi.com/v1
  • Basis-URL (Global): https://api.minimax.io
  • Main: MiniMax-M2.5
  • Fast: MiniMax-M2.5-Lightning
# .env — MiniMax
LLM_API_KEY=...
LLM_BASE_URL=https://api.minimaxi.com/v1
LLM_MODEL=MiniMax-M2.5
FAST_LLM_MODEL=MiniMax-M2.5-Lightning

​
Kimi / 月之暗面 (Moonshot)

Kimi K2.5 (Januar 2026) hat 256K Kontext und starke Codierungsleistung (76,8% SWE-Bench unter Open-Source-Modellen).
  • Basis-URL: https://api.moonshot.ai/v1
  • Modell: kimi-k2.5
# .env — Kimi
LLM_API_KEY=...
LLM_BASE_URL=https://api.moonshot.ai/v1
LLM_MODEL=kimi-k2.5
FAST_LLM_MODEL=kimi-k2.5

​
Lokale Modelle (Ollama)

Führen Sie Modelle vollständig auf Ihrer eigenen Hardware aus — kein API-Schlüssel erforderlich, vollständig offline. Ollama stellt standardmäßig einen OpenAI-kompatiblen Endpunkt bereit. Die Open-Source-Landschaft hat sich dramatisch verändert — Qwen 3.5, Llama 4 und GPT-OSS (OpenAIs erste Open-Weight-Modelle) sind alle verfügbar. Basis-URL: http://localhost:11434/v1 Empfohlene Modelle nach VRAM:
VRAMHaupt-LLMSchnelles LLMHinweise
8 GBqwen3.5:9b / gemma3:4bqwen3.5:4bQwen 3.5 9B ist das Highlight in dieser Kategorie
16 GBgpt-oss:20b / deepseek-r1:14bqwen3.5:9bGPT-OSS 20B ist Agent-optimiert
24 GBqwen3:32b / deepseek-r1:32bqwen3.5:9bQwen 3 32B ist am besten für Tool-Aufrufe
48 GB+llama3.3:70b / gpt-oss:120bqwen3.5:14bQualität nahe an der Grenze
Am besten für Tool-Aufrufe: Qwen 3/3.5 (32B+), GLM-4.7, GPT-OSS, Mistral — diese haben explizites Funktionsaufrufe-Training. Modelle mit 14B+ Parametern sind das Minimum für zuverlässige Tool-Aufrufe; 32B+ wird dringend empfohlen.
Die Qualität der Tool-Aufrufe variiert erheblich zwischen lokalen Modellen. Nicht alle Modelle generieren zuverlässig gültige Funktionsaufrufe. Testen Sie Ihr gewähltes Modell mit Agent-Workflows, bevor Sie es in der Produktion einsetzen. Die allgemeine Regel: 14B Minimum, 32B+ empfohlen für Agent-Aufgaben.
# .env — Ollama (ausgewogen, 16GB VRAM)
LLM_API_KEY=ollama
LLM_BASE_URL=http://localhost:11434/v1
LLM_MODEL=gpt-oss:20b
FAST_LLM_MODEL=qwen3.5:9b
LLM_CONTEXT_SIZE=32768
LLM_MAX_OUTPUT_TOKENS=8192

# .env — Ollama (Agent-optimiert, 24GB VRAM)
LLM_API_KEY=ollama
LLM_BASE_URL=http://localhost:11434/v1
LLM_MODEL=qwen3:32b
FAST_LLM_MODEL=qwen3.5:9b
LLM_CONTEXT_SIZE=32768
LLM_MAX_OUTPUT_TOKENS=8192

​
Third-Party Relay-Plattformen

Viele Benutzer greifen auf mehrere Modellanbieter über einen einzigen Relay- (Proxy-)Dienst zu. FIM One erkennt automatisch das richtige API-Protokoll basierend auf URL-Pfadmustern — füllen Sie einfach die LLM_BASE_URL aus und es funktioniert.

​
Funktionsweise

Wenn Ihre Basis-URL auf ein Drittanbieter-Relay verweist, inspiziert FIM One den URL-Pfad, um das zu verwendende Protokoll zu bestimmen:
URL-Pfad enthältErkanntes ProtokollAuth-HeaderHauptvorteil
/v1 (oder keine Übereinstimmung)OpenAI-kompatibelAuthorization: BearerUniverseller Fallback, funktioniert mit den meisten Relays
/claude oder /anthropicAnthropic nativx-api-keyVollständige reasoning_content (erweitertes Denken) Unterstützung
/geminiGoogle nativx-goog-api-keyNative Gemini-Parameterübersetzung
Auflösungsreihenfolge: Explizites DB-Anbieterfeld > Domain-Übereinstimmung (offizielle APIs) > URL-Pfad-Hinweis (Relay-Plattformen) > OpenAI-kompatibler Fallback.

​
Beispiel: Ein Relay, drei Protokolle

Mit einem einzelnen Relay-Konto können Sie auf verschiedene Anbieter zugreifen, indem Sie einfach den Basis-URL-Pfad ändern:

​
.env — Claude via Relay (Anthropic natives Protokoll)

LLM_API_KEY=your-relay-key LLM_BASE_URL=https://relay.example.com/anthropic LLM_MODEL=claude-sonnet-4-6 

```bash
# .env — Gemini über Relay (Google natives Protokoll)
LLM_API_KEY=your-relay-key
LLM_BASE_URL=https://relay.example.com/gemini
LLM_MODEL=gemini-2.5-pro

# .env — GPT über Relay (OpenAI-kompatibles Protokoll)
LLM_API_KEY=your-relay-key
LLM_BASE_URL=https://relay.example.com/v1
LLM_MODEL=gpt-5.4
Keine zusätzliche Konfiguration erforderlich — Authentifizierungsheader, Parameterformate und Response-Parsing wechseln automatisch.

​
Schritt für Schritt: Wie die Pfaderkennung funktioniert

Hier ist ein konkretes Beispiel, das zeigt, was intern passiert, wenn Sie ein Relais konfigurieren:

​
.env — Claude über eine Relay-Plattform

LLM_API_KEY=your-relay-key LLM_BASE_URL=https://my-relay.example.com/claude LLM_MODEL=claude-sonnet-4-6 LLM_REASONING_EFFORT=medium 

1. FIM One erkennt `/claude` im URL-Pfad → erkennt **Anthropic natives** Protokoll
2. Modell wird als `anthropic/claude-sonnet-4-6` für LiteLLM-Routing präfixiert
3. Anfragen verwenden Anthropics `/v1/messages`-Format mit `x-api-key`-Authentifizierungsheader
4. `reasoning_effort=medium` wird in Anthropics natives `thinking`-Parameter übersetzt (nicht OpenAIs `reasoning_effort`)

<Warning>
Wenn die gleiche Relay-URL stattdessen `https://my-relay.example.com/v1` wäre, würde der `/claude`-Hinweis fehlen — FIM One würde auf das OpenAI-kompatible Protokoll zurückfallen und `/v1/chat/completions`-Anfragen an einen Claude-nativen Endpunkt senden, was fehlschlagen würde. **Der URL-Pfad ist wichtig.**
</Warning>

### Warum das wichtig ist

- **Anthropic nativer Endpunkt** bietet dir ordnungsgemäße `reasoning_content`-Unterstützung (erweitertes Denken sichtbar in der UI), korrektes Tool-Calling-Format und `x-api-key`-Authentifizierung — Funktionen, die bei der Verwendung von OpenAI-kompatibler Übersetzung verloren gehen.
- **Google nativer Endpunkt** bietet dir native Gemini-Parameter und `x-goog-api-key`-Authentifizierung.
- **OpenAI kompatibel** ist der universelle Fallback und funktioniert mit jedem Relay, aber anbieter-spezifische Funktionen (wie erweiterte Thinking-Ausgabe) sind möglicherweise nicht verfügbar.

<Note>
Wenn deine Relay-Plattform nicht-standardisierte Pfadkonventionen verwendet (z. B. kein `/claude` oder `/anthropic` in der URL), greift FIM One auf das OpenAI-kompatible Protokoll zurück — das für die meisten Anwendungsfälle funktioniert. Für vollständige native Protokollunterstützung kannst du das Feld `provider` explizit über die Admin-Modellkonfiguration UI setzen.
</Note>

## Konfigurationsstrategie

### Main vs Fast: Wann sollte man aufteilen

- **Aufteilen** wenn dein Hauptmodell teuer oder langsam ist (z. B. `gpt-5.4` + `gpt-5-nano`). DAG-Modus führt viele parallele Schritte aus — die Verwendung eines günstigeren schnellen Modells spart erhebliche Kosten.
- **Gleiches Modell** wenn dein Modell bereits günstig ist (z. B. `deepseek-chat` für beide). Der Aufwand für die Verwaltung von zwei Modellen lohnt sich nicht.

### Wann sollte man Reasoning aktivieren

- **Aktivieren** für komplexe analytische Aufgaben, mehrstufige Planung und Aufgaben, die sorgfältige Beurteilung erfordern
- **Deaktivieren** (Standard) für Routineaufgaben, einfache Fragen und Antworten sowie kostensensitive Bereitstellungen
- Reasoning erhöht typischerweise die Kosten um das 2-5-fache pro Anfrage — `medium` Aufwand ist ein guter Ausgangspunkt

### Kontextfenster-Dimensionierung

Setzen Sie `LLM_CONTEXT_SIZE` auf die tatsächliche Größe des Kontextfensters Ihres Modells:

| Modell | Kontextfenster |
|---|---|
| GPT-5.4 | 272K |
| o3 / o4-mini | 200K |
| Claude Sonnet 4.6 | 200K (1M Beta) |
| Gemini 2.5 Pro | 1M |
| Gemini 3.1 Pro | 1M |
| DeepSeek V3.2 | 128K |
| Qwen 3.5 Plus | 1M |
| Local (Ollama) | 4K–128K (variiert) |

Für lokale Modelle setzen Sie sowohl `LLM_CONTEXT_SIZE` als auch `LLM_MAX_OUTPUT_TOKENS` explizit – die Standardwerte gehen von Cloud-Kontextfenstern aus, die lokale Modelle nicht unterstützen können.