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

ChatKit

Entwickle mit ChatKit einen einbettbaren Chat und passe ihn an.

Mit ChatKit lassen sich Chat-Anwendungen mit Agenten am besten entwickeln. Ob dein Agent Fragen anhand einer internen Wissensdatenbank beantwortet, neue Mitarbeitende bei der Einarbeitung begleitet, bei der Recherche, beim Einkaufen oder bei der Terminplanung hilft, Fehler behebt, zur Finanzplanung berät oder Support leistet: ChatKit bietet dir einen anpassbaren Chat zum Einbetten und kümmert sich um alle Details der Bedienung.

Mit ChatKit kannst du Agenten entwickeln, ohne die Chat-Oberfläche von Grund auf neu zu erstellen. Dafür stehen dir einbettbare UI-Widgets, anpassbare Prompts, Unterstützung für Tool-Aufrufe, Dateianhänge und Visualisierungen von Gedankenketten zur Verfügung.

Überblick

Für die Integration von ChatKit hast du zwei Möglichkeiten:

  • Integration mit eigenem Server. Betreibe ChatKit auf deiner eigenen Infrastruktur. Mit dem ChatKit Python SDK kannst du jeden agentenbasierten Dienst anbinden, auch einen, den du mit dem Agents SDK entwickelt hast. Das Frontend erstellst du mit Widgets.
  • Bestehende Integration mit einem in Agent Builder gehosteten Workflow. Wenn du ChatKit bereits mit einem Workflow in Agent Builder nutzt, kannst du diesen gehosteten Workflow während der Übergangsfrist weiterverwenden.

OpenAI stellt Agent Builder ein. Wenn du Agent Builder bereits nutzt, kannst du ihn während der Übergangsfrist weiterverwenden. Die Abschaltung ist für den 30. November 2026 geplant. ChatKit bleibt verfügbar. Nutze für neue Projekte oder bei der Migrationsplanung die erweiterten ChatKit-Integrationen mit deiner eigenen serverseitigen Agentenimplementierung. Hinweise zum Umstieg findest du im Leitfaden zur Migration von Agent Builder.

Erste Schritte mit ChatKit

ChatKit in dein Frontend einbetten

Nutze diesen Weg nur, wenn deine ChatKit-Implementierung bereits auf einem Workflow in Agent Builder basiert. Wenn du eine neue ChatKit-App entwickelst oder vor der Abschaltung von Agent Builder migrierst, nutze die erweiterte Integration, um ChatKit mit deiner eigenen serverseitigen Agentenimplementierung zu verbinden.

So richtest du ChatKit in drei Schritten mit einem bestehenden gehosteten Workflow ein. Öffne deinen bestehenden Workflow, solange Agent Builder verfügbar ist. Richte dann ChatKit ein und ergänze die gewünschten Chat-Funktionen.


Von OpenAI gehostetes
ChatKit

1. Einen bestehenden gehosteten Workflow verwenden

Öffne deinen bestehenden Workflow in Agent Builder. Dort erhältst du die Workflow-ID. Hinweise zur Planung des Umstiegs findest du im Leitfaden zur Migration von Agent Builder.

Der in dein Frontend eingebettete Chat verwendet den Workflow, den du auswählst.

2. ChatKit in deinem Produkt einrichten

Um ChatKit einzurichten, erstellst du eine ChatKit-Sitzung und einen Server-Endpunkt. Du übergibst deine Workflow-ID, tauschst das Client-Secret aus und fügst ein Skript hinzu, das ChatKit in deine Website einbettet.

Wichtiger Sicherheitshinweis: Beim Erstellen einer ChatKit-Sitzung musst du den Parameter user übergeben. Sein Wert sollte für jede Person, die deine Anwendung nutzt, eindeutig sein. Dein Server muss jede dieser Personen authentifizieren und ihre eindeutige Kennung in diesem Parameter übergeben.

  1. Erzeuge auf deinem Server ein Client-Token.

    Dieses Beispiel startet einen Dienst, der über die OpenAI API eine ChatKit-Sitzung erstellt und das Client-Secret der Sitzung zurückgibt:

    # Replace the illustrative IDs and URLs below with your own resource values.
    import hmac
    import json
    import os
    from typing import Annotated
    
    import requests
    from fastapi import Depends, FastAPI, HTTPException
    from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
    from pydantic import BaseModel
    
    
    api_key = os.environ["OPENAI_API_KEY"]
    workflow_id = "wf_123"
    authenticated_users: dict[str, str] = json.loads(
        os.environ["CHATKIT_AUTHENTICATED_USERS"]
    )
    bearer_auth = HTTPBearer(auto_error=False)
    
    
    def get_authenticated_user_id(
        credentials: Annotated[
            HTTPAuthorizationCredentials | None,
            Depends(bearer_auth),
        ],
    ) -> str:
        if credentials is not None:
            for token, user_id in authenticated_users.items():
                if hmac.compare_digest(credentials.credentials, token):
                    return user_id
        raise HTTPException(status_code=401, detail="Invalid authentication token")
    
    
    class ChatKitSession(BaseModel):
        client_secret: str
    
    
    app = FastAPI()
    
    
    @app.post("/api/chatkit/session")
    def create_chatkit_session(
        user_id: Annotated[str, Depends(get_authenticated_user_id)],
    ):
        response = requests.post(
            "https://api.openai.com/v1/chatkit/sessions",
            headers={
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json",
                "OpenAI-Beta": "chatkit_beta=v1",
            },
            json={
                "workflow": {"id": workflow_id},
                "user": user_id,
            },
            timeout=30,
        )
        response.raise_for_status()
        session = ChatKitSession.model_validate(response.json())
        return {"client_secret": session.client_secret}

    Für Ruby installierst du WEBrick mit gem install webrick.

    Ersetze vor dem Start des Dienstes wf_123 durch deine Workflow-ID und setze die Umgebungsvariablen OPENAI_API_KEY und CHATKIT_AUTHENTICATED_USERS. Der Wert der zweiten Variable ist ein JSON-Objekt, das die Bearer-Token deiner Anwendung stabilen Benutzer-IDs zuordnet. Ermittle die Benutzer-ID im Produktivbetrieb über die Authentifizierung deiner Anwendung oder durch Abfragen der Sitzung. Das ersetzt die Zuordnung per Umgebungsvariable.

  2. Übergib in deinem serverseitigen Code deine Workflow-ID und deinen geheimen Schlüssel an den Sitzungsendpunkt.

    Mit dem Client-Secret authentifiziert sich dein ChatKit-Frontend, um die Chat-Sitzung zu öffnen oder zu erneuern. Gib es sofort an die ChatKit-Clientbibliothek weiter, ohne es zu speichern.

    Weitere Informationen findest du im chatkit-js-Repository auf GitHub.

    Für Go führst du go get github.com/openai/openai-go/v3@v3.70.0 aus. Für Java fügst du die Maven-Abhängigkeit com.openai:openai-java:4.75.1 hinzu.

    Token für eine ChatKit-Sitzung erstellen
    export default async function getChatKitSessionToken(deviceId: string) {
      const apiKey = process.env.OPENAI_API_KEY;
      if (!apiKey) {
        throw new Error("OPENAI_API_KEY is required");
      }
    
      const response = await fetch("https://api.openai.com/v1/chatkit/sessions", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "OpenAI-Beta": "chatkit_beta=v1",
          Authorization: `Bearer ${apiKey}`,
        },
        body: JSON.stringify({
          workflow: { id: "wf_68df4b13b3588190a09d19288d4610ec0df388c3983f58d1" },
          user: deviceId,
        }),
      });
    
      if (!response.ok) {
        throw new Error(
          `Failed to create a ChatKit session: ${response.status} ${await response.text()}`
        );
      }
    
      const { client_secret } = await response.json();
    
      if (!client_secret) {
        throw new Error("ChatKit session response did not include client_secret");
      }
    
      return client_secret;
    }
  3. Installiere die React-Bindings für ChatKit in deinem Projektverzeichnis:

    npm install @openai/chatkit-react
  4. Füge das JavaScript-Skript für ChatKit in deine Seite ein. Platziere den folgenden Code im <head> deiner Seite oder dort, wo du Skripte lädst. Der Browser lädt ChatKit dann automatisch und führt es aus.

    index.html
    <script
    src="https://cdn.platform.openai.com/deployments/chatkit/chatkit.js"
    async
    ></script>
  5. Zeige ChatKit in deiner Benutzeroberfläche an. Übergib der React-Komponente MyChat eine Funktion namens getAppAuthToken, die das Bearer-Token der aktuell angemeldeten Person zurückgibt. Wenn du den TypeScript-Tab verwendest, stelle dieselbe Funktion im Gültigkeitsbereich des Codebeispiels bereit. Der Code sendet das Bearer-Token an deinen Server, ruft das Client-Secret ab und bindet ein aktives Chat-Widget ein, das mit deinem Workflow verbunden ist.

    Dein Frontend-Code
    import { ChatKit, useChatKit } from '@openai/chatkit-react';
    
       export function MyChat({ getAppAuthToken }) {
         const { control } = useChatKit({
           api: {
             async getClientSecret(existing) {
               if (existing) {
                 // implement session refresh
                }
    
               const appAuthToken = await getAppAuthToken();
               const res = await fetch('/api/chatkit/session', {
                 method: 'POST',
                 headers: {
                   'Authorization': 'Bearer ' + appAuthToken,
                   'Content-Type': 'application/json',
                 },
               });
               const { client_secret } = await res.json();
               return client_secret;
             },
           },
         });
    
         return <ChatKit control={control} className="h-[600px] w-[320px]" />;
       }

3. Den Chat entwickeln und verbessern

In der Dokumentation zur Anpassung des Designs, zu Widgets und zu Aktionen erfährst du mehr darüber, wie ChatKit funktioniert. Mit den folgenden Ressourcen kannst du deinen Chat testen, Prompts schrittweise verbessern und Widgets und Tools hinzufügen.

Deine ChatKit-Integration entwickeln

ChatKit-Dokumentation auf GitHub

Erfahre unter anderem, wie du die Authentifizierung umsetzt, das Design festlegst und den Chat anpasst.

ChatKit Python SDK

Ergänze serverseitigen Speicher, Zugriffskontrolle, Tools und weitere Backend-Funktionen.

ChatKit JS SDK

Sieh dir das Repository für ChatKit JS an.

Die ChatKit-Oberfläche erkunden

chatkit.world

Probiere ChatKit in einer interaktiven Demo aus.

Widget-Editor

Stöbere in den verfügbaren Widgets.

ChatKit Playground

Lerne ChatKit kennen, indem du die Funktionen in einer interaktiven Demo ausprobierst.

Lauffähige Beispiele ansehen

Beispiele auf GitHub

Sieh dir lauffähige ChatKit-Beispiele an und sammle Ideen für deine eigene App.

Repository der Starter-App

Klone das Repository, um mit einer voll funktionsfähigen Vorlage zu starten.

Nächste Schritte

Wenn du mit deiner ChatKit-Implementierung zufrieden bist, sieh dir an, wie du sie mit Evaluierungen optimieren kannst. Wenn du eine neue ChatKit-App entwickelst oder eine bestehende ChatKit-App von einem in Agent Builder gehosteten Workflow auf deinen eigenen Server umstellen möchtest, hilft dir die Dokumentation zur erweiterten Integration.