Hoppa till huvudinnehållet
Next.js-SDK för chattbotar

Lägg till en anpassad AI-chatbot till Next.js-integration

Använd @openstaticfish/chattybox inom en fokuserad klientgräns medan resten av din App Router-applikation förblir serverrenderad. ChattyBox hanterar hämtning, citat, konversationer och skalning.

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^
Next.js-plattform 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.

Håll den interaktiva chattytan inom en liten `use client`-gräns.
Visa endast en offentlig, ursprungsbegränsad widgetnyckel genom NEXT_PUBLIC-variabler.
Återge citerade svar med ditt befintliga Next.js-designsystem och applikationsskal.
Låt ChattyBox hantera genomsökning, hämtning, vektorlagring, svarsgenerering och skalning.
Arbetsflödessteg

Installera @openstaticfish/chattybox i Next.js-applikationen.

Arbetsflödessteg

Lägg till den offentliga widgetens API-nyckel och API-URL som NEXT_PUBLIC miljövariabler.

Arbetsflödessteg

Skapa en klientkomponent för chattstatus och webbläsarinteraktion.

Arbetsflödessteg

Importera den klientkomponenten från en serverkomponentsida eller layout.

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 Next.js chatbot
App Router-integration

Lägg till interaktivitet utan att ge upp serverrenderingen

Håll SDK vid klientkanten där chattinteraktion sker och bevara serverkomponenter för resten av programmet.

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

Liten klientgräns

Markera endast den interaktiva chattmodulen med `use client` i stället för att flytta en hel sida eller layout till webbläsaren.

02

Tydlighet i den offentliga nyckeln

Använd en webbläsarsäker projektnyckel med tillåtna ursprung; exponera aldrig hanteringsuppgifter via NEXT_PUBLIC-variabler.

03

Anpassad produktgränssnitt

Återge meddelanden och citat i din egen navigering, kontoområde, dokumentskal eller supportarbetsflöde.

04

Ingen anpassad RAG-tjänst

Undvik att lägga till rutthanterare enbart för att proxyservera ett hanterat webbläsar-API om inte din produkt har ett konkret krav på serversidan.

Installationsväg

Skapa en Next.js App Router-chattklient

SDK:n använder fetch och projektuppgifter som är synliga i webbläsaren, så initiera den i en klientmodul. Håll hemligheter och hanterings-API:er borta från NEXT_PUBLIC-variabler.

  1. 1Installera npm-paketet och konfigurera en ursprungsbegränsad offentlig nyckel.
  2. 2Skapa en `use client`-komponent som hanterar meddelande- och konversationsstatus.
  3. 3Rendera komponenten från din serverrenderade sida utan att konvertera hela rutten till en klientkomponent.
Bygg en Next.js chatbot
app/components/chat.tsx
tsx
'use client';

import { useState, type FormEvent } from 'react';
import { Chattybox, ChattyboxError, type ChatResponse } from '@openstaticfish/chattybox';

const chattybox = new Chattybox({
  apiKey: process.env.NEXT_PUBLIC_CHATTYBOX_API_KEY!,
  baseUrl: process.env.NEXT_PUBLIC_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>
  );
}

// Import and render <Chat /> from your page or layout. 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

Fungerar ChattyBox SDK med Next.js App Router?

Ja. Använd den i en klientkomponent för interaktivt chattläge och rendera den komponenten från en App Router-sida eller layout.

2

Behöver jag en Next.js-rutthanterare för ChattyBox?

Inte för normal webbläsarintegration. Offentliga widgetnycklar är designade för klientanvändning och kan begränsas till godkända ursprung.

3

Är NEXT_PUBLIC ChattyBox-nycklar hemligheter?

Den offentliga widgetnyckeln identifierar ett projekt men är inte en administrativ autentiseringsuppgift. Begränsa den till dina produktions- och förhandsgranskningsorigins och exponera aldrig administrativa hemligheter.

4

Kan jag använda den värdbaserade ChattyBox-widgeten med Next.js?

Ja. Installationsguiden för den värdbaserade widgeten visar hur du använder next/script när du föredrar ett underhållet gränssnitt framför ett anpassat SDK-gränssnitt.

Starta gratis

Inget kreditkort krävs

Skapa gratis chatbot

Free-nivå. Inget kort behövs.