Spring til hovedindhold
Dansk— Vælg et sprog
Menu

ChatKit: Oversigt og installation

Lektion 17 af 25 Opdateret 3. november 2026 Udvikler
På denne side
  1. Hvorfor ChatKit
  2. To måder at drive den på
  3. Arkitekturen med tre dele
  4. Installation
  5. Den minimale server
  6. React-grænsefladen
  7. Uden React
  8. Sikkerhed fra dag ét
  9. Hvis du allerede har et Agent Builder-workflow
  10. Vigtige pointer

Lektionen er omskrevet den 3. november 2026. Den tidligere version beskrev et API, der ikke længere eksisterer: et new ChatKit({ apiKey, agentId })-objekt, ChatProvider-, ChatWindow- og MessageInput-komponenter, et @openai/chatkit/react-modul og et cdn.openai.com/chatkit/…-script. Denne lektion følger nu de officielle OpenAI ChatKit-guider, Python SDK openai-chatkit 1.6.5 og @openai/chatkit-react 1.6.1. Vi har kørt eksempelserveren lokalt for at verificere hvert trin. Bemærk: Agent Builder lukker ned den 30. november 2026; ChatKit forbliver tilgængeligt. Kilder: ChatKit · Avancerede integrationer med ChatKit · Python SDK hurtigstart · Officiel startapp.

Hvorfor ChatKit

Du har bygget en agent med Agents SDK. Den kører i din terminal, og ingen andre kan bruge den. For at gøre den tilgængelig for dine brugere har du brug for en samtalegrænseflade – og at bygge en god chat-UI fra bunden er dyrt. Du skal håndtere rulning, streaming af beskeder, genoptagelse af samtaler, vedhæftede filer, visning af værktøjskald og håndtering af netværksfejl.

ChatKit er OpenAIs svar: en samtalekomponent, du indlejrer i dit produkt, som håndterer hele brugeroplevelsen. Dokumentationen fremhæver dens interaktive widgets, startforslag, visning af værktøjskald, vedhæftede filer og visualisering af agentens ræsonnement. Du beholder kontrollen over det, der betyder noget: agenten, dine data og dine regler.

To måder at drive den på

ChatKit er blot en grænseflade. Den har brug for en server, der modtager beskeder, kører agenten og streamer svaret tilbage. OpenAI beskriver to tilgange:

VejHvordan det virkerHvem det er til
Din egen ChatKit-server (avanceret integration)Din Python-server, der bruger openai-chatkit SDK’et, modtager anmodninger fra UI’en og kører den agent, du vælger, f.eks. en Agents SDK-agentEthvert nyt projekt: dette er den vej, OpenAI anbefaler
Hostet Agent Builder-workflowOpenAI kører et workflow designet i Agent Builder; din server opretter kun sessionerEksisterende integrationer i overgangsperioden: Agent Builder lukker ned den 30. november 2026

Dette kursus følger den første vej – den eneste med en fremtid. Vi opsummerer den anden i slutningen af lektionen for dem, der skal vedligeholde en eksisterende integration indtil nedlukningen.

Arkitekturen med tre dele

En ChatKit-integration koges ned til tre elementer. At skelne mellem dem undgår de fleste begynderfejl:

  1. ChatKit.js, selve komponenten: en webkomponent <openai-chatkit>, der viser samtalen i en iframe. Den indlæses fra OpenAIs CDN (https://cdn.platform.openai.com/deployments/chatkit/chatkit.js), ikke fra npm: npm-pakken @openai/chatkit indeholder kun dens typedeklarationer.
  2. React-bindings, @openai/chatkit-react, som eksponerer ChatKit-komponenten og useChatKit-hooket. Disse er valgfrie: uden React styrer du webkomponenten direkte.
  3. Din ChatKit-server, et enkelt HTTP-endepunkt, konventionelt /chatkit, der modtager alle anmodninger fra grænsefladen. En ChatKitServer-instans router dem, bruger en store til at persistere samtaletråde og kører din agent.

OpenAI API-nøglen forlader aldrig serveren: grænsefladen taler kun til dit /chatkit-endepunkt.

Installation

På grænsefladesiden installerer du React-bindings og indlæser ChatKit-scriptet i din side:

npm install @openai/chatkit-react
<!-- I <head> på din side -->
<script src="https://cdn.platform.openai.com/deployments/chatkit/chatkit.js"></script>

På serversiden installerer du ChatKit Python SDK (Python 3.10 eller nyere), som medbringer Agents SDK, plus en webserver:

pip install openai-chatkit fastapi uvicorn

Den minimale server

Serveren nedenfor følger den officielle hurtigstart. ChatKitServer kræver kun én metode, respond, som kaldes for hver brugerbesked. Den genindlæser de seneste trådelementer, konverterer dem til agent-input med simple_to_agent_input, kører agenten i streaming-tilstand og oversætter den stream til ChatKit-begivenheder med stream_agent_response:

# main.py
from typing import Any, AsyncIterator

from agents import Agent, Runner
from chatkit.agents import AgentContext, simple_to_agent_input, stream_agent_response
from chatkit.server import ChatKitServer, StreamingResult
from chatkit.types import ThreadMetadata, ThreadStreamEvent, UserMessageItem
from fastapi import FastAPI, Request
from fastapi.responses import Response, StreamingResponse

from memory_store import MemoryStore  # in-memory store fra startappen

assistant = Agent[AgentContext[dict[str, Any]]](
    name="Product Assistant",
    instructions="You help product users. Respond in English, briefly.",
    model="gpt-6.1-sol",
)


class MyChatKitServer(ChatKitServer[dict[str, Any]]):
    async def respond(
        self,
        thread: ThreadMetadata,
        input_user_message: UserMessageItem | None,
        context: dict[str, Any],
    ) -> AsyncIterator[ThreadStreamEvent]:
        # De sidste 30 trådelementer, genoprettet i kronologisk rækkefølge
        page = await self.store.load_thread_items(
            thread.id, after=None, limit=30, order="desc", context=context
        )
        agent_input = await simple_to_agent_input(list(reversed(page.data)))
        agent_context = AgentContext(thread=thread, store=self.store, request_context=context)
        result = Runner.run_streamed(assistant, agent_input, context=agent_context)
        async for event in stream_agent_response(agent_context, result):
            yield event


app = FastAPI()
server = MyChatKitServer(MemoryStore())


@app.post("/chatkit")
async def chatkit_endpoint(request: Request) -> Response:
    result = await server.process(await request.body(), {})
    if isinstance(result, StreamingResult):
        return StreamingResponse(result, media_type="text/event-stream")
    return Response(content=result.json, media_type="application/json")

Kør den med OPENAI_API_KEY i dit miljø: uvicorn main:app --port 8000.

Store-delen fortjener to ord. ChatKit gemmer intet selv: tråde, beskeder, widgets og værktøjskald persisters af en klasse, der arver fra chatkit.store.Store og implementerer omkring et dusin metoder (load_thread, save_thread, load_thread_items, add_thread_item…). For at komme i gang skal du genbruge memory_store.py-filen fra den officielle startapp: den holder alt i hukommelsen, mens processen kører. I produktion erstatter du den med en database. Dokumentationen anbefaler at gemme objekter som JSON, så SDK-opdateringer ikke tvinger skemamigrationer på dig.

React-grænsefladen

På grænsefladesiden modtager useChatKit konfigurationen og returnerer et control-objekt, som du sender til ChatKit-komponenten:

import { ChatKit, useChatKit } from '@openai/chatkit-react';

export function Assistant() {
  const { control } = useChatKit({
    api: {
      url: '/chatkit',
      // I udvikling er en pladsholderværdi nok; i produktion
      // skal du bruge din domænenøgle (se nedenfor)
      domainKey: 'local-dev',
    },
  });

  return <ChatKit control={control} className="h-[600px] w-[360px]" />;
}

Server grænsefladen og /chatkit fra samme oprindelse: i udvikling håndterer dit build-værktøjs proxy dette (startappen konfigurerer Vites proxy til at omdirigere /chatkit til port 8000). Hvis serveren lever på en anden oprindelse, skal du tillade den eksplicit, f.eks. med FastAPIs CORSMiddleware.

Uden React

En WordPress-side, en Rails-applikation eller en statisk side kan integrere den samme assistent: webkomponenten virker direkte, når CDN-scriptet er indlæst.

<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <script src="https://cdn.platform.openai.com/deployments/chatkit/chatkit.js"></script>
  </head>
  <body>
    <div id="chat-root" style="height: 600px"></div>
    <script>
      const chatkit = document.createElement('openai-chatkit');
      chatkit.setOptions({
        api: { url: '/chatkit', domainKey: 'local-dev' },
      });
      document.getElementById('chat-root').append(chatkit);
    </script>
  </body>
</html>

Hver indstilling, du vil se i de følgende lektioner, har samme form i begge tilfælde: et objekt sendt til useChatKit i React eller til setOptions på webkomponenten.

Sikkerhed fra dag ét

Tre regler, hentet fra ChatKit-produktionsguiden, gælder fra prototype-stadiet:

  • API-nøglen bliver på serveren. Den må ikke optræde i grænsefladekode eller i dit repository: læs den fra en miljøvariabel eller en hemmelighedsadministrator.
  • Godkend hver anmodning til /chatkit. SDK’et håndterer ikke dette: din applikation skal verificere brugerens session eller token og derefter sende deres identitet til server.process i konteksten (lektion 21). Uden dette kan alle køre din agent på din regning.
  • Registrer dine domæner. Før du går live, skal du erklære hvert værtsnavn, der vil vise ChatKit, på OpenAI-platformens side Domain allowlist og kopiere den genererede nøgle til domainKey. Ved indlæsning verificerer ChatKit-iframen denne nøgle med OpenAI og nægter at vise sig, hvis den mangler eller ikke matcher.

Hvis du allerede har et Agent Builder-workflow

Eksisterende integrationer koblet til et hostet workflow fungerer, indtil Agent Builder lukker ned. Deres princip er anderledes: din server opretter en ChatKit-session ved at kalde POST https://api.openai.com/v1/chatkit/sessions, med headeren OpenAI-Beta: chatkit_beta=v1, workflow-ID’et og en user-identifikator, der er unik for hver godkendt bruger. Den returnerer derefter den opnåede client_secret til grænsefladen. På grænsefladesiden tager indstillingen api derefter en getClientSecret-funktion i stedet for en URL.

Start ikke et nyt projekt på denne model. For en eksisterende integration skal du eksportere workflowet til Agents SDK-kode og skifte til din egen ChatKit-server før den 30. november 2026 ved at følge guiden Migrate from Agent Builder.

Vigtige pointer

  • ChatKit er en samtalegrænseflade klar til integration; din server kører agenten
  • Til ethvert nyt projekt: din egen ChatKit-server (pip install openai-chatkit), med en respond-metode og et /chatkit-endepunkt; den hostede Agent Builder lukker ned den 30. november 2026
  • Grænsefladen indlæses fra OpenAIs CDN; i React skal du bruge useChatKit og <ChatKit control={control} /> fra @openai/chatkit-react
  • Store persistere samtaletråde: i hukommelsen til test, i en database til produktion
  • API-nøgle kun på serversiden, godkendt /chatkit, registrerede domæner for at opnå domainKey