Hoppa till huvudinnehållet
React-SDK för chattbotar

Bygg din egen React-chatbotgränssnitt

Anslut React-komponenter till ChattyBox med @openstaticfish/chattybox. Ditt team styr rendering och tillstånd medan hanterad infrastruktur sköter källbaserade svar, källhänvisningar och gruppering av konversationer.

Genomsöker publicerade dokumentsidorKällangivna svarBygg ett anpassat gränssnitt med SDK:nIngen dokumentmigrering krävsInget kreditkort krävsDitt innehåll förblir ditt
Fråga ChattyBox
Var ska jag börja om jag behöver ett tillförlitligt svar från den här webbplatsen?
Börja med att lägga till din offentliga webbplats-URL i ChattyBox. Tjänsten hämtar indexerat innehåll som stöd för svar och kan visa källänkar som besökare kan granska. Testa svar och reservsvar före lansering.
iKällor3^
React vägledning
chattybox.ai
Analys
chattybox.ai
Hem
chattybox.ai

Illustrativ konversation — inte en livechatt.

Drivs av ChattyBox

Lansera en chatbot med källhänvisningar utan att bygga om webbplatsens stack

ChattyBox genomsöker din befintliga webbplats, dokumentation, ditt hjälpcenter, CMS eller din kunskapsbas. Hämtat innehåll kan vägleda chatbotens svar; kontrollera att svaren och källhänvisningarna är korrekta.

Skapa anpassade meddelande-, citerings-, laddnings-, reserv- och felkomponenter.
Behåll konversations-ID:n i ett besökarspecifikt React-tillstånd för uppföljningsfrågor.
Använd offentliga API-nycklar för webbläsare med valfria exakta originbegränsningar för extra härdning.
Undvik att underhålla din egen sökrobot, vektorlagring, hämtningstjänst eller genereringspipeline.
Arbetsflödessteg

Installera JavaScript SDK i din React-applikation.

Arbetsflödessteg

Skapa en Chattybox-klient utanför komponentrenderingssökvägen.

Arbetsflödessteg

Skicka meddelanden från en händelsehanterare och uppdatera UI-tillståndet med svaret.

Arbetsflödessteg

Återge källlänkar och hantera strukturerade ChattyboxError-fel.

Lansering i tre steg

Anslut din offentliga webbplats eller dokumentation, testa svar med källhänvisningar och bygg sedan ditt gränssnitt med SDK:n.

Bygg en React chatbot
React-integration

Anpassa källbaserad chatt till ditt befintliga komponentsystem

Använd tillstånd, tillgänglighet, stil och designsystem som din applikation redan följer istället för att anpassa till ett fast widgetskal.

Beslutsväg

Använd dessa kontrollpunkter för att avgöra om ChattyBox ska användas vid sidan av din dokumentationsplattform, ersätta en separat assistent eller användas separat för testning.

01

Komponentägande

Sätt samman meddelanden, källhänvisningskort, uppmaningar, tomma tillstånd och kontroller av dina egna React-komponenter.

02

Tillstånd på dina villkor

Använd lokala tillstånd eller ditt befintliga tillståndslager samtidigt som konversationer isoleras mellan besökare.

03

Tillgängliga svar

Kontrollera fokus, liveregioner, tangentbordsbeteende och felmeddelanden i din applikation.

04

Hanterad backend

Håll webbläsarintegrationen liten medan ChattyBox hanterar innehållsindexering, hämtning och citerade svar.

Installationsväg

Anslut en React-komponent till ChattyBox

Skapa klienten en gång, anrop den från en händelsehanterare och håll varje besökskonversations-ID i komponent- eller applikationstillstånd.

  1. 1Lägg till @openstaticfish/chattybox till React-applikationen.
  2. 2Initiera klienten med offentliga miljövariabler från Vite eller ramverket.
  3. 3Lagra det returnerade meddelandet, källorna och konversations-ID:t i ett besökarspecifikt tillstånd.
Bygg en 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.
Vanliga frågor

Vanliga frågor

1

Kan jag bygga en anpassad React-chatbot med ChattyBox?

Ja. JavaScript-SDK:n returnerar meddelanden, konversations-ID:n och källadresser så att din React-applikation kan återge ett helt anpassat gränssnitt.

2

Tillhandahåller ChattyBox en React-komponent?

Inga React-komponenter eller hooks exporteras. Använd headless-metoder med egna komponenter, eller anropa mountWidget() från en beständig webbläsarlayout för att ladda den underhållna flytande widgeten.

3

Var ska jag skapa Chattybox-klienten i React?

Skapa den en gång utanför komponentens renderingsflöde eller i en stabil provider i applikationen i stället för att skapa en ny klient vid varje rendering.

4

Kan jag använda den värdbaserade widgeten i React istället?

Ja. Använd installationsguiden för den värdbaserade widgeten när du vill ha ett underhållet gränssnitt snarare än anpassad React-rendering.

Starta gratis

Inget kreditkort krävs

Skapa gratis chatbot

Free-nivå. Inget kort behövs.