Models

Für Mitglieder und die Organisationsverwaltung. Mitglieder können ihr eigenes ChatGPT-Konto verbinden. Anbieter mit API-Schlüsseln brauchen die unten genannten Rechte. Nur Plattform-Admins ändern Einstellungen unter /v1/platform. Beginne mit dem Administrationshandbuch.

Ein Bot braucht ein Sprachmodell, um zu arbeiten. OpenBot enthält kein Modell. Du verbindest eins. OpenBot speichert dafür zwei Arten von Einträgen:

Ein Model beschreibt ein Sprachmodell, zum Beispiel gpt-5: seinen Namen, seine Optionen und seine Grenzen. Ein Model gehört nicht zu einem Anbieter.
Ein Model Provider (Modell-Anbieter) ist ein Dienst für Modelle mit seinem API-Schlüssel. Ein Anbieter verknüpft die Models, die er anbietet. Eine Verknüpfung kann manche Werte des Model nur für diesen Anbieter ändern.

ChatGPT nutzt einen normalen Modellanbieter. Siehe Mit ChatGPT anmelden. Das Konto gehört zum Anbieter.

Du fügst beide über die API hinzu. OpenBot speichert sie in der Datenbank. So nutzt jede Instanz dieselben.

Die Platform oder eine Organization besitzt jeden solchen Model- und Anbieter-Eintrag:

Besitzer	Wer es hinzufügt	Wer es nutzen kann
Organization	Eine Organization, mit ihrem eigenen Schlüssel	Nur diese Organization. Das heißt “Bring your own key” (bring deinen eigenen Schlüssel mit).
Platform	Ein Admin der Platform, mit dem Schlüssel der Platform	Die Organizations in ihrer `availability`. Siehe Platform.

Eine Organization kann ein Model eines Anbieters nur nutzen, wenn sie sowohl den Anbieter als auch das Model nutzen darf.

Jedes Model hat einen von drei Typen:

Ein language-Model schreibt Text und ruft Werkzeuge auf. Es führt Turns aus, beurteilt Rules und lernt Bot-Memory.
Ein decision-Model wählt nur eine Antwort aus einer festen Liste. Es schreibt keinen Text. Es kann Rules beurteilen. Jev von TypeSafe ist ein Beispiel. Siehe Decision-Model.
Ein live-Model spricht in Echtzeit mit einer Person, mit Ton. Nur der Live-Modus nutzt es.

Wenn du OpenBot aus Code startest, kannst du auch eingebaute Models angeben. Siehe Eingebaute Models.

Ein Model hinzufügen

POST /v1/organization/models fügt deiner Organization ein Model hinzu. Es braucht write auf ModelProvider.

curl -H "Authorization: Bearer $OPENBOT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "id": "qwen3-32b", "name": "Qwen3 32B", "reasoningEfforts": [], "serviceTiers": [], "contextWindow": 131072 }' \
  https://api.example.com/v1/organization/models

Feld	Regeln
`id`	Pflicht. 1 bis 200 Zeichen. Sie ist für ihren Besitzer eindeutig, und du kannst sie nicht ändern. Ein Anbieter schickt sie als Namen des Modells, außer die Verknüpfung setzt `upstream`.
`name`	Pflicht. Ein Name für Menschen.
`reasoningEfforts`	Pflicht. Die Werte für `reasoningEffort`, die das Model annimmt. Kann leer sein.
`serviceTiers`	Pflicht. Die Werte für `serviceTier`, die das Model annimmt. Kann leer sein.
`contextWindow`	Optional. Die Größe des Kontextfensters, in Tokens.
`maxOutputTokens`	Optional. Die meisten Tokens, die das Model in einer Antwort schreiben kann.

Wenn deine Organization schon ein Model mit dieser id hat, gibt OpenBot 409 mit ModelConflict zurück.

Route	Was sie tut
`GET /v1/organization/models`	Listet die Models deiner Organization auf. Geteilte Models sind nicht in dieser Liste.
`GET /v1/organization/models/:modelId`	Liest ein Model.
`PATCH /v1/organization/models/:modelId`	Ändert ein Model. Der Body braucht `expectedVersion`. Schicke `null` für eine Grenze, um sie zu entfernen.
`DELETE /v1/organization/models/:modelId`	Entfernt ein Model.

Lesen braucht read auf ModelProvider. Änderungen brauchen write auf ModelProvider. Du kannst ein Model nicht entfernen, solange einer deiner Anbieter es verknüpft. OpenBot gibt 409 mit ModelInUse zurück. Entferne zuerst die Verknüpfung.

Einen Anbieter hinzufügen

POST /v1/organization/model_providers fügt deiner Organization einen Anbieter hinzu. Es braucht write auf ModelProvider.

curl -H "Authorization: Bearer $OPENBOT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "kind": "openai-compat",
    "name": "Local vLLM",
    "endpoint": "https://llm.example.com/v1",
    "apiKey": "sk-...",
    "models": [
      { "model": "qwen3-32b", "modelOwner": "organization", "upstream": "Qwen/Qwen3-32B" }
    ]
  }' \
  https://api.example.com/v1/organization/model_providers

Feld	Regeln
`kind`	Pflicht. Die API, die der Dienst spricht: `chatgpt`, `openai`, `anthropic` oder `openai-compat`. Siehe die Tabelle unten.
`name`	Pflicht. 1 bis 120 Zeichen.
`endpoint`	Pflicht für `openai-compat`. Optional für die anderen. Eine Basis-URL mit `http` oder `https`, oft mit `/v1` am Ende. Kein Nutzername, kein Passwort, keine Query und kein Teil mit `#`.
`apiKey`	Pflicht außer bei `chatgpt`. ChatGPT nutzt die Browser-Anmeldung.
`models`	Pflicht. 0 bis 200 Verknüpfungen. Die Reihenfolge ist die Reihenfolge der Liste der Models.

OpenBot verbindet sich nur mit öffentlichen Adressen. Für einen Model-Server in deinem eigenen Netzwerk oder auf deiner Maschine muss der Betreiber seinen Host in OPENBOT_OUTBOUND_ALLOW schreiben. Bis dahin schlagen Aufrufe an ihn fehl. Siehe Ausgehende Verbindungen.

Jede Verknüpfung hat diese Felder:

Feld	Regeln
`model`	Pflicht. Die `id` des Model. Ein Anbieter verknüpft jede Model-ID nur einmal.
`modelOwner`	Pflicht. `organization` für ein Model deiner Organization oder `platform` für ein geteiltes Model.
`upstream`	Optional. Der Name des Modells, den der Dienst bekommt, wenn er nicht die `id` des Model ist.
`reasoningEfforts`	Optional. Ersetzt die `reasoningEfforts` des Model für diesen Anbieter.
`serviceTiers`	Optional. Ersetzt die `serviceTiers` des Model für diesen Anbieter.
`contextWindow`	Optional. Ersetzt das `contextWindow` des Model für diesen Anbieter.
`maxOutputTokens`	Optional. Ersetzt `maxOutputTokens` des Model für diesen Anbieter.

Ein Anbieter deiner Organization kann deine eigenen Models verknüpfen und die geteilten Models, die die Platform dir zur Verfügung stellt. Für jedes andere Model gibt OpenBot 404 mit ModelNotFound zurück.

OpenBot antwortet mit dem Anbieter. Seine id beginnt mit prov_. Eine Anbieter-ID ist in der ganzen Platform eindeutig. Eine Auswahl eines Model nennt sie als provider. Der API-Schlüssel kommt nie zurück. Die Antwort zeigt stattdessen apiKey: { set, hint }. Siehe Platform.

Einen Anbieter ändern oder entfernen

Route	Was sie tut
`GET /v1/organization/model_providers`	Listet die Anbieter auf.
`GET /v1/organization/model_providers/:providerId`	Liest einen Anbieter.
`PATCH /v1/organization/model_providers/:providerId`	Ändert einen Anbieter.
`DELETE /v1/organization/model_providers/:providerId`	Entfernt einen Anbieter.

Lesen braucht read auf ModelProvider. Änderungen brauchen write auf ModelProvider.

Der Body von PATCH braucht expectedVersion, also die version, die du gelesen hast. Wenn jemand den Anbieter geändert hat, nachdem du ihn gelesen hast, gibt OpenBot 409 mit ModelProviderConflict zurück. Lass apiKey weg, um den aktuellen Schlüssel zu behalten. Schicke models, um alle Verknüpfungen des Anbieters zu ersetzen.

curl -X PATCH -H "Authorization: Bearer $OPENBOT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"expectedVersion":0,"apiKey":"sk-new..."}' \
  https://api.example.com/v1/organization/model_providers/prov_4c1e...

Der nächste Aufruf eines Modells nach einer Änderung nutzt den neuen Schlüssel, Endpoint oder die neuen Verknüpfungen. OpenBot baut jedes Model einmal und baut es neu, wenn sich sein Anbieter ändert.

Du kannst einen Anbieter nicht entfernen, solange rulesModel oder botMemoryModel in den Einstellungen der Organization ihn nennt. OpenBot gibt 409 mit ModelProviderInUse zurück. Ändere zuerst die Einstellung.

Mit ChatGPT anmelden

Ein Modellanbieter mit kind: "chatgpt" nutzt die Anmeldung im Browser statt eines API-Schlüssels. Er gehört der Organisation oder der Plattform. Alle Arbeiten mit Zugriff auf ihn nutzen dasselbe verbundene Konto. Modellverknüpfungen, Rechte, Preise, Budgets und Plattformguthaben gelten wie bei anderen Anbietern.

Erstelle ihn mit POST /v1/organization/model_providers:

{ "kind": "chatgpt", "name": "ChatGPT", "models": [] }

Sende weder apiKey noch endpoint. Bewahre die erhaltene prov_*-ID auf. Für einen Plattformanbieter nutze /v1/platform/model_providers und setze availability. Es gelten dieselben Schreibrechte wie für API-Schlüssel.

Nutze die Anbieter-API, um die Anmeldung zu starten, die Browser-Rückgabe zu senden und das Konto zu trennen. Die Pfade unten beginnen mit /v1/organization/model_providers/:providerId. Ersetze für die Plattform organization durch platform.

Methode und Pfad	Zweck
`POST /oauth/authorizations`	Sende `redirectUri` und `expectedVersion`. Lies `id`, `url` und `expiresAt`.
`POST /oauth/authorizations/:authorizationId/complete`	Sende die vollständige `callbackUrl` vom lokalen Listener.
`DELETE /oauth`	Lösche Tokens und versuche, die Sitzung bei OpenAI zu beenden. Anbieter und Modellverknüpfungen bleiben.
`GET /available_models`	Lies verfügbare Modelle des Kontos in `items`.

Der lokale Listener nutzt http://127.0.0.1:<port>/auth/callback. Starte ihn, bevor du die Anmelde-URL öffnest. Ein Versuch gilt zehn Minuten. Nur sein Absender kann ihn einmal abschließen. Eine Änderung am Anbieter beendet alte Versuche. API-Schlüssel und Session-Cookies desselben Origins werden unterstützt. Cookie-Schreibzugriffe brauchen den genauen öffentlichen Origin. Der Server speichert Tokens verschlüsselt und erneuert sie bei Bedarf.

Das Feld oauth zeigt connected, loginRequired und Kontodaten. Es gibt keine Tokens zurück. apiKey zeigt set: false und hint: null. Bei revoked: false sind die lokalen Tokens gelöscht, aber die Abmeldung bei OpenAI ist nicht bestätigt. Du kannst die App auch in den ChatGPT-Einstellungen trennen.

Die Liste verfügbarer Modelle ändert keine gespeicherten Modelle. Lege Modelle über die normale API an und verknüpfe sie mit dem Anbieter. Nutze die gelieferte Modell-ID als Upstream-Namen, wenn deine lokale Modell-ID anders ist. Wähle die normale Anbieter-ID:

{ "_tag": "Config.Selection", "provider": "prov_example", "model": "my-model" }

ChatGPT unterstützt Chats, Regeln, Bot-Gedächtnis und geplante Arbeit. Es bietet Sprachmodelle und OpenBot-Funktionswerkzeuge, kein Live-Audio. Es nutzt Sign in with ChatGPT und die öffentliche Responses API. Kontolimits gelten weiter. Bei fehlender Anmeldung oder erreichtem Limit wechselt die Arbeit nicht zu einem anderen Anbieter.

Typisierte Aufrufe stehen unter Client.

Ein Model auswählen

GET /v1/organization/model_catalog listet die Models, die du jetzt nutzen darfst: die Models deiner Organization, bei denen deine Policy use auf Model erlaubt. Jeder Eintrag ist ein Model eines Anbieters, mit den Werten der Verknüpfung schon angewendet. Ein Model, das zwei Anbieter verknüpfen, erscheint zweimal.

curl -H "Authorization: Bearer $OPENBOT_TOKEN" \
  https://api.example.com/v1/organization/model_catalog

{
  "providers": [
    {
      "id": "prov_4c1e...",
      "owner": "organization",
      "kind": "openai-compat",
      "name": "Local vLLM"
    }
  ],
  "models": [
    {
      "provider": "prov_4c1e...",
      "id": "qwen3-32b",
      "owner": "organization",
      "name": "Qwen3 32B",
      "reasoningEfforts": [],
      "serviceTiers": [],
      "contextWindow": 131072,
      "price": {
        "model": "qwen3-32b",
        "timeZone": "UTC",
        "tiers": [
          {
            "upToInputTokens": null,
            "inputUncached": 400000,
            "inputCacheRead": 100000,
            "inputCacheWrite": 0,
            "output": 1200000,
            "outputReasoning": null
          }
        ],
        "periods": [],
        "effectiveFrom": "2026-10-20T08:00:00.000Z"
      }
    }
  ]
}

price ist der aktuelle Preis des Model bei diesem Anbieter. Er fehlt, wenn niemand einen Preis gesetzt hat. Siehe Preise.

Eine Auswahl eines Model nennt den Anbieter und die Model-ID:

{ "_tag": "Config.Selection", "provider": "prov_4c1e...", "model": "qwen3-32b" }

OpenBot wählt nie ein Model für dich. Es gibt kein Standard-Model. Jede Nutzung nennt ihr eigenes Model:

Ein neuer Chat nutzt das model seines Bots. Wenn der Bot kein Model hat, schlägt die erste Nachricht an ihn mit 400, ChatModelInvalid und dem Grund missing fehl. Ein neuer Bot hat kein Model, wenn du ihm keines gibst. Setze also sein model, wenn du ihn erstellst, oder später mit PATCH /v1/bots/:id.
Das Prüf-Modell für Rules nutzt rulesModel in den Einstellungen der Organization. Wenn es null ist, gibt das Prüf-Modell keine Antwort. Dann entscheidet eine Person oder ein Bot.
Bot-Memory nutzt botMemoryModel in denselben Einstellungen. Wenn es null ist, lernen Bots nichts.

rulesModel kann ein language-Model oder ein decision-Model sein. botMemoryModel muss ein language-Model sein, weil der Memory-Bot Text schreibt. Sonst gibt OpenBot 400 mit SettingsInvalid zurück. Der Katalog nennt den type jedes Model, und ein Chat kann nur language-Models wählen.

Ältere Versionen von OpenBot hatten defaultModel und helperModel. Beim Update gibt OpenBot das alte defaultModel jedem Bot, der kein Model hat. rulesModel und botMemoryModel bekommen das alte Helfer-Modell: helperModel, sonst defaultModel. Wenn beide null waren, bleiben die neuen Werte leer, und du musst sie setzen.

So gibst du zum Beispiel einem Bot ein Model. Schicke seine aktuelle revision als expected:

curl -X PATCH -H "Authorization: Bearer $OPENBOT_TOKEN" -H 'Content-Type: application/json' \
  -d '{"expected":0,"model":{"_tag":"Config.Selection","provider":"prov_4c1e...","model":"qwen3-32b"}}' \
  https://api.example.com/v1/bots/$BOT_ID

Ein Chat kann seine eigene Auswahl speichern. Schicke die aktuelle Revision des Chats als expected:

curl -X PATCH -H "Authorization: Bearer $OPENBOT_TOKEN" -H 'Content-Type: application/json' \
  -d '{"expected":3,"model":{"_tag":"Config.Selection","provider":"prov_4c1e...","model":"qwen3-32b"}}' \
  https://api.example.com/v1/chats/$CHAT_ID

Sende "model": null, um wieder das Model des Bots zu nutzen. GET /v1/chats/:id/models zeigt dieselben Models für einen Chat. Alle Felder findest du in der API-Referenz für Chats.

Um festzulegen, welche Anbieter ein Member auswählen darf, gib dem Member eine Deny-Regel für use auf Model mit dem Feld provider. Siehe Berechtigungen.

Decision-Model

Deine Organization hat keine Einstellung für ein einziges Decision-Model (Entscheidungs-Model). Jede Nutzung eines Model nennt ihr eigenes Model. Manche Nutzungen können ein Decision-Model oder ein Language-Model nehmen. Darum passt ein festes Decision-Model für die ganze Organization nicht zu ihnen.

Um zum Beispiel Jev über TypeSafe zu nutzen, füge das Model hinzu und dann einen Anbieter, der es verknüpft:

curl -H "Authorization: Bearer $OPENBOT_TOKEN" -H "Content-Type: application/json" \
  -d '{ "id": "jev-latest", "type": "decision", "name": "Jev", "reasoningEfforts": [], "serviceTiers": [] }' \
  https://api.example.com/v1/organization/models

curl -H "Authorization: Bearer $OPENBOT_TOKEN" -H "Content-Type: application/json" \
  -d '{
    "kind": "typesafe",
    "name": "TypeSafe",
    "endpoint": "https://typesafe.example.com/v1",
    "apiKey": "...",
    "models": [{ "model": "jev-latest", "modelOwner": "organization" }]
  }' \
  https://api.example.com/v1/organization/model_providers

Danach zeigt GET /v1/organization/model_catalog Jev mit "type": "decision".

OpenBot ruft einen typesafe-Anbieter mit dem TypeSafe-Client von Effect (@effect/ai-typesafe) auf. Es schickt jede Anfrage an <endpoint>/systemone, mit dem API-Schlüssel als Bearer-Token, und schickt upstream als Namen des Model. OpenBot baut den Client einmal für jeden Anbieter und jedes Model und baut ihn neu, wenn sich der Anbieter ändert. OpenBot kann ein Decision-Model noch nicht über einen openai-compat-Anbieter fragen. Du kannst es dort verknüpfen, aber nutze einen typesafe-Anbieter, um es zu fragen.

Das Prüf-Modell für Rules kann ein Decision-Model nutzen. Setze rulesModel darauf. Siehe Das Prüf-Modell.

Ohne Model arbeiten

Eine Organization ohne Anbieter kann ihre Chats trotzdem lesen und ihren Verlauf löschen. Sie kann nicht mit einem Bot sprechen, weil jeder Turn ein Model braucht. Siehe Ein Model auswählen.

Eine Nachricht an einen Bot schlägt mit dem Status 503 und dem Fehler ChatExecutionUnavailable fehl, wenn kein Model ihren Turn ausführen kann:

{ "_tag": "ChatExecutionUnavailable", "chat": "..." }

Eine Mitteilung von OpenBot, zum Beispiel das Ergebnis einer Delegation, kommt trotzdem in die Inbox ihres Chats. Siehe Mitteilungen.

Eingebaute Models

Für diese Entwicklungsaufgabe siehe Model-Backends.

Models für die Entwicklung

Für diese Entwicklungsaufgabe siehe Model-Backends.