Ga naar de hoofdinhoud
SDK voor React-chatbots

Bouw je eigen React-chatbotinterface

Verbind React-componenten met ChattyBox via @openstaticfish/chattybox. Uw team beheert weergave en status; de beheerde infrastructuur verzorgt brongebonden antwoorden, bronverwijzingen en gespreksgroepering.

Crawlt gepubliceerde documentatiepagina'sAntwoorden met bronvermeldingenBouw een aangepaste gebruikersinterface met de SDKGeen documentatiemigratie vereistGeen creditcard vereistJe content blijft van jou
Vraag ChattyBox
Waar moet ik beginnen als ik een betrouwbaar antwoord van deze site nodig heb?
Voeg eerst uw openbare website-URL toe aan ChattyBox. Het haalt geïndexeerde inhoud op om antwoorden te sturen en kan bronlinks tonen ter controle. Test antwoorden en terugvalantwoorden vóór de lancering.
iBronnen3^
React gids
chattybox.ai
Analyse
chattybox.ai
Startpagina
chattybox.ai

Illustratief gesprek — geen livechat.

Aangedreven door ChattyBox

Start een chatbot met bronvermeldingen zonder uw website-stack opnieuw op te bouwen

ChattyBox crawlt uw bestaande website, documentatie, helpcentrum, CMS of kennisbank. Opgehaalde inhoud kan de antwoorden van de chatbot sturen; controleer antwoorden en bronvermeldingen op juistheid.

Maak aangepaste bericht-, citatie-, laad-, fallback- en foutcomponenten.
Bewaar gespreks-ID's voor vervolgvragen in React-state die per bezoeker is afgebakend.
Gebruik openbare browser-API-sleutels, met optionele exacte originbeperkingen voor extra beveiliging.
Vermijd het onderhouden van uw eigen crawler, vectoropslag, ophaalservice of generatiepijplijn.
Workflowstap

Installeer JavaScript SDK in uw React-applicatie.

Workflowstap

Maak één Chattybox-client buiten het renderpad van de component.

Workflowstap

Verzend berichten vanaf een gebeurtenishandler en update de status UI met het antwoord.

Workflowstap

Geef bronlinks weer en handel gestructureerde ChattyboxError-fouten af.

Lancering in drie stappen

Koppel je openbare website of documentatie, test antwoorden met bronvermeldingen en bouw vervolgens je interface met de SDK.

Bouw een React chatbot
React-integratie

Integreer op bronnen gebaseerde chat in uw bestaande componentsysteem

Gebruik de status-, toegankelijkheids-, stijl- en ontwerpsysteempatronen die uw toepassing al volgt in plaats van zich aan te passen aan een vaste widgetshell.

Beslissingspad

Gebruik deze controlepunten om te beslissen of ChattyBox naast uw documentplatform moet worden geplaatst, een afzonderlijke assistent moet vervangen of geïsoleerd moet blijven om te testen.

01

Eigendom van componenten

Stel berichten, citatiekaarten, aanwijzingen, lege statussen en bedieningselementen samen vanuit uw eigen React-componenten.

02

State op uw eigen manier

Gebruik lokale state of uw bestaande statelaag en houd gesprekken van bezoekers van elkaar gescheiden.

03

Toegankelijke reacties

Beheer de focus, liveregio's, toetsenbordgedrag en foutaankondigingen binnen uw toepassing.

04

Beheerde backend

Houd de browserintegratie klein, terwijl ChattyBox de inhoudsindexering, het ophalen en geciteerde antwoorden afhandelt.

Installatiepad

Sluit een React-component aan op ChattyBox

Maak de client één keer aan, roep deze aan vanuit een gebeurtenishandler en bewaar de gespreks-ID van elke bezoeker in de component- of applicatiestatus.

  1. 1Voeg @openstaticfish/chattybox toe aan de React-applicatie.
  2. 2Initialiseer de client met Vite of door het raamwerk geleverde openbare omgevingsvariabelen.
  3. 3Sla het geretourneerde bericht, de bronnen en de gespreks-ID op in state die per bezoeker is afgebakend.
Bouw een React chatbot
Chat.tsx
tsx
import { useState, type FormEvent } from 'react';
import { Chattybox, ChattyboxError, type ChatResponse } from '@openstaticfish/chattybox';

// Vite browser example. Other frameworks use different public environment APIs.
const chattybox = new Chattybox({
  apiKey: import.meta.env.VITE_CHATTYBOX_API_KEY,
  baseUrl: import.meta.env.VITE_CHATTYBOX_API_URL,
});

export function Chat() {
  const [question, setQuestion] = useState('');
  const [answer, setAnswer] = useState<ChatResponse | null>(null);
  const [pending, setPending] = useState(false);
  const [error, setError] = useState('');

  async function ask(event: FormEvent<HTMLFormElement>) {
    event.preventDefault();
    const message = question.trim();
    if (pending || !message || message.length > 2000) return;
    setPending(true);
    setError('');
    try {
      const result = await chattybox.sendMessage({
        message,
        // Same ID includes up to 12 recent saved messages, not the full transcript.
        conversationId: answer?.conversationId,
      });
      // The backend may return a provider failure in an otherwise successful response.
      if ('providerError' in result && typeof result.providerError === 'string' && result.providerError) {
        setError('Chat could not be completed.');
        return;
      }
      setAnswer(result);
      setQuestion('');
    } catch (failure) {
      setError(failure instanceof ChattyboxError
        ? failure.status + ': ' + failure.message
        : 'Chat could not be completed.');
    } finally {
      setPending(false);
    }
  }

  const sources = answer?.sources.filter((source) => {
    try { return ['https:', 'http:'].includes(new URL(source).protocol); }
    catch { return false; }
  }) ?? [];

  return (
    <section aria-label="Chat">
      <form onSubmit={ask}>
        <label>Question
          <input value={question} maxLength={2000} disabled={pending}
            onChange={(event) => setQuestion(event.target.value)} />
        </label>
        <button type="submit" disabled={pending || !question.trim()}>
          {pending ? 'Sending...' : 'Send'}
        </button>
      </form>
      {error && <p role="alert">{error}</p>}
      <div aria-live="polite" aria-busy={pending}>
        <p style={{ whiteSpace: 'pre-wrap' }}>{answer?.message}</p>
        {sources.length > 0 && <ul aria-label="Sources">
          {sources.map((source, index) => <li key={index}>
            <a href={source} target="_blank" rel="noopener noreferrer">{source}</a>
          </li>)}
        </ul>}
      </div>
    </section>
  );
}

// Render <Chat /> in your app. This shows the latest answer, not a saved transcript.
// No automatic retries: see the SDK retry-safety guide before adding retries.
Veelgestelde vragen

Veelgestelde vragen

1

Kan ik een aangepaste React chatbot bouwen met ChattyBox?

Ja. De JavaScript SDK retourneert berichten, gespreks-ID's en bron-URLs, zodat uw React-toepassing een volledig aangepaste interface kan weergeven.

2

Biedt ChattyBox een React-component?

Er worden geen React-componenten of hooks geëxporteerd. Gebruik de headless-methoden met uw eigen componenten, of roep mountWidget() aan vanuit een blijvende browserlay-out om de onderhouden zwevende widget te laden.

3

Waar moet ik de Chattybox-client maken in React?

Maak het eenmalig buiten het renderpad van de component of in een stabiele applicatieprovider, in plaats van voor elke render een nieuwe client te bouwen.

4

Kan ik in plaats daarvan de gehoste widget in React gebruiken?

Ja. Gebruik de gehoste widget-installatiegids als u een onderhouden interface wilt in plaats van aangepaste React-weergave.

Gratis starten

Geen creditcard vereist

Maak een gratis chatbot

Gratis niveau. Geen kaart nodig.