---
title: "OpenAI-kompatible Clients"
description: "OpenAI-kompatible Clients und Coding-Agents über die meinGPT-API anbinden"
canonical_url: "https://meingpt.com/docs/integrations/openai-compatible-clients"
language: de
---

# OpenAI-kompatible Clients

meinGPT stellt eine OpenAI-kompatible API bereit. Damit kannst Du OpenAI-kompatible Clients und Coding-Agents gegen Deine meinGPT-Modelle betreiben. Diese Seite zeigt die Einrichtung am Beispiel von [OpenCode](https://opencode.ai) und [Pi](https://pi.dev); andere Clients konfigurierst Du analog.

## Voraussetzungen

- Ein persönlicher API-Schlüssel: Öffne in den meinGPT-Einstellungen den Bereich "meinGPT API" und erstelle einen Schlüssel.
- Der Client Deiner Wahl, lokal installiert (z. B. OpenCode oder Pi).
- Die Basis-URL der API: `https://app.meingpt.com/api/openai/v1`

## Client konfigurieren

In beiden Fällen trägst Du meinGPT als eigenen Provider ein: Basis-URL, API-Schlüssel und die Modelle, die Du nutzen möchtest – für einen Coding-Agent reicht in der Regel eines. Gültige Modell-IDs sind die für Deine Organisation freigeschalteten Modelle; Du findest sie über den `/models`-Endpunkt oder in der Modellübersicht in meinGPT.

### OpenCode

Lege in Deinem Projekt eine `opencode.json` an:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "meingpt": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "meinGPT",
      "options": {
        "baseURL": "https://app.meingpt.com/api/openai/v1",
        "apiKey": "DEIN_API_SCHLUESSEL"
      },
      "models": {
        "claude-sonnet-4-6": {
          "name": "Claude Sonnet 4.6",
          "limit": { "context": 200000, "output": 64000 }
        }
      }
    }
  }
}
```

Danach startest Du OpenCode mit dem Modell:

```bash
opencode -m meingpt/claude-sonnet-4-6
```

Über `limit` kennt OpenCode das Kontextfenster (`context`) und die maximale Ausgabelänge (`output`) des Modells und kann darüber die Kontextauslastung anzeigen. Ohne diese Angaben bleibt die Auslastungsanzeige bei 0 %. Die passenden Werte je Modell findest Du in der Modellübersicht in meinGPT.

Weitere Modelle ergänzt Du unter `models`.

### Pi

Pi registriert Provider über eine Extension. Lege die Datei `~/.pi/extensions/meingpt.ts` an:

```ts
export default function (pi) {
  pi.registerProvider("meingpt", {
    baseUrl: "https://app.meingpt.com/api/openai/v1",
    apiKey: "DEIN_API_SCHLUESSEL",
    api: "openai-completions",
    models: [
      {
        id: "claude-sonnet-4-6",
        name: "Claude Sonnet 4.6",
        input: ["text"],
        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
        contextWindow: 200000,
        maxTokens: 64000,
      },
    ],
  });
}
```

Danach startest Du Pi mit dem Provider und Modell:

```bash
pi --provider meingpt --model claude-sonnet-4-6
```

Weitere Modelle ergänzt Du im `models`-Array der Extension.

Nicht jedes Modell beherrscht die Funktionsaufrufe (Tool Calls), die ein Coding-Agent nutzt. Such-Modelle wie Perplexity Sonar lehnen solche Anfragen mit einer Fehlermeldung ab – nimm dafür ein Modell wie Claude, GPT oder Gemini. Reasoning-Modelle verwenden intern einen festen `temperature`-Wert und können andere Werte ablehnen; lasse `temperature` in diesem Fall weg.

Coding-Agents senden Bilder (z. B. Screenshots) häufig als `image_url`-Content-Blöcke. Der meinGPT-Chat-Completions-Endpunkt akzeptiert das nicht - der `content`-Wert einer Nachricht muss reiner Text sein, sodass eine Anfrage mit Bild mit `400` fehlschlägt. Das betrifft jeden Client, der über diese Anbindung läuft, da Coding-Agents den in [Chat Completions](/docs/api/completions) dokumentierten Endpunkt verwenden. Eine direkte Lösung gibt es nicht: Für den Versand von Dateien oder Bildern müsstest Du stattdessen auf die [Assistant-](/docs/api/assistants) bzw. [Workflow-Ausführung](/docs/api/workflows) über die API wechseln - dort gilt ein anderes (`multipart/form-data`-)Anfrageformat, das die meisten OpenAI-kompatiblen Coding-Agent-Clients nicht nativ unterstützen.

## VS-Code-Erweiterungen: Continue.dev und Cline

Auch VS-Code-Erweiterungen wie **Continue.dev** und **Cline** lassen sich über die OpenAI-kompatible API anbinden.

Coding-Agents wie Cline und Continue.dev senden bei jedem Turn den gesamten Gesprächsverlauf und alle Tool-Definitionen erneut mit und können dadurch schnell ein großes Tokenbudget verbrauchen. Bei `429`-Fehlern hilft Dir der Abschnitt [Rate Limits](/docs/api#rate-limits) weiter – das Limit wird pro Nutzer, pro Organisation und pro Modell geprüft.

### Continue.dev

Lege in Deinem Projekt die Datei `.continue/config.yaml` an:

```yaml
models:
  - name: meinGPT
    provider: openai
    apiBase: https://app.meingpt.com/api/openai/v1
    apiKey: ${MEINGPT_API_KEY}
```

Cline lässt sich analog über seine OpenAI-kompatiblen Provider-Einstellungen mit derselben Basis-URL und demselben API-Schlüssel konfigurieren.

Prüfe das genaue Schema vor der Veröffentlichung gegen die aktuelle Continue.dev-Dokumentation, da es sich unabhängig von meinGPT ändern kann.

## Optional: alle Modelle übernehmen (OpenCode)

OpenCode liest die verfügbaren Modelle über den `/models`-Endpunkt aus, zeigt für eigene Provider aber nur Modelle an, die es selbst kennt. Wenn Du alle freigeschalteten Modelle in der Auswahl haben möchtest, ohne sie einzeln einzutragen, kannst Du den `models`-Block einmalig aus der API erzeugen (benötigt `curl` und `python3`) und bei Bedarf erneut ausführen. Der `/models`-Endpunkt liefert keine Kontextfenster mit – für so erzeugte Modelle bleibt die Auslastungsanzeige daher bei 0 %, bis Du `limit` von Hand ergänzt:

```bash
KEY="DEIN_API_SCHLUESSEL"
curl -s -H "Authorization: Bearer $KEY" \
  https://app.meingpt.com/api/openai/v1/models \
| KEY="$KEY" python3 -c '