Erstellen Sie einen LLM-Chatbot mit einer benutzerdefinierten Wissensdatenbank
Published: 2024-02-01 21:19:38

Bei all der Aufmerksamkeit, die diese LLMs und ChatGPT erhalten haben, taucht ein neues Prinzip auf: "Garbage in, garbage out". Bei der Verwendung von GPT-4 oder GPT-3.5, oder jedem anderen großen Sprachmodell, gilt dieses Konzept an zwei Stellen [Eingabeaufforderungstechnik](https://en.wikipedia.org/wiki/Prompt_engineering#:~:text=Prompt%20engineering%20(also%20known%20as,of%20it%20being%20explicitly%20given.) und [Feinabstimmung](https://en.wikipedia.org/wiki/Fine-tuning_(deep_learning)). Wir sollten auch berücksichtigen, wann diese Modelle trainiert wurden, um zu überprüfen, wie alt oder neu die Daten sind, die sie uns liefern.

Die meisten Unternehmen arbeiten heute innerhalb von Unternehmensdatenquellen - innerhalb einer Firewall oder außerhalb und nicht im öffentlichen Internet. Wenn wir LLMs auf diese Daten anwenden können, ergeben sich neue Möglichkeiten.

Dieser Artikel behandelt die Erstellung eines Chatbots mit einer benutzerdefinierten Wissensdatenbank in 30 Minuten, damit Ihre KI Fragen zu Ihren Daten beantworten kann.

![](/cdn/3prze68gbwl1/3qYPBDJSpSd5oecj2fUDae/f2a980695856b249c645e7ea774b87fe/Screenshot_2023-07-20_at_10.17.38_PM.png)

Voraussetzungen für die Erstellung eines Wissensbots
----------------------------------------------------

Wir müssen berücksichtigen, wie viele Daten wir haben, um eine benutzerdefinierte Wissensdatenbank zu erstellen. In diesem Blog werden wir einen Assistenten mithilfe der PubNub-Dokumentation erstellen. Da die Dokumentation sehr umfangreich ist, sollten wir die Verwendung eines Produktionsdienstes wie [Vectara](https://vectara.com/), [Pinecone](https://www.pinecone.io/)oder [Weaviate](https://weaviate.io/) um unsere Vektoreinbettungen zu verwalten. Sie können LangChain verwenden, um eine lokale Vektordatenbank für kleinere Datenmengen zu erstellen. LangChain unterstützt auch das Mapping Ihrer benutzerdefinierten Einbettungen auf Ihre LLM-Modelle durch eine semantische oder Ähnlichkeitssuche.

In diesem Blog werden wir uns mit der Einrichtung einer Vektordatenbank auf Vectara beschäftigen, da diese eine einfache Drag-and-Drop-Lösung für alle Ihre Unternehmensdaten bietet. Der beste Weg, mit Vectara zu interagieren, ist die Verwendung von [PubNub-Funktionen](https://www.pubnub.com/docs/general/serverless/functions/overview#:~:text=PubNub%20provides%20Functions%20to%20capture,filter%2C%20and%20even%20aggregate%20data.)zu verwenden, die einen serverlosen JavaScript-Container bereitstellen, der immer dann ausgeführt wird, wenn ein vordefiniertes Ereignis eintritt. Sie können selbst bestimmen, wann die Funktion ausgeführt und abgefeuert wird, und so die Funktionsweise Ihres AI Knowledge Bot anpassen.

Vectara nutzt Ihren Datensatz, um Ihre Daten in mehrere Einbettungen zu indexieren. Wenn Sie eine Texteingabe oder eine Benutzereingabe übermitteln, führt Vectara eine semantische Suche in Ihren Daten durch und fasst die gefundenen Ergebnisse zusammen, um eine Antwort auf Ihre Frage unter Verwendung Ihrer benutzerdefinierten Daten zu liefern. Auf diese Weise erhalten Sie die relevanten Informationen, die Sie benötigen. Vectara unterstützt mehrere Dateitypen wie TXT-, HTML-, PDF- und Word-Dateien. Sammeln Sie alle Dokumente, die Sie hochladen möchten, und fügen Sie sie in einem eigenen Ordner zusammen.

### So richten Sie Vectara ein

Richten Sie Vectara wie folgt ein:

1.  [Registrieren Sie sich](https://console.vectara.com/login) oder melden Sie sich bei Vectara an
    
2.  Sobald Sie sich auf dem Dashboard befinden, klicken Sie auf `Korpus erstellen`
    
3.  Sobald Sie dem Korpus einen Namen und eine Beschreibung gegeben haben, ziehen Sie die Dateien, von denen Ihr LLM wissen soll, in den Abschnitt `Dateien hochladen`. Nachdem Sie Ihre Dateien hochgeladen haben, können Sie Ihre Korpus-ID oben auf der Webseite überprüfen, da Sie diese für die Anfrage benötigen, die wir gerade schreiben.
    
4.  Klicken Sie auf Ihre E-Mail in der oberen rechten Ecke und speichern Sie Ihre `Kunden-ID` für später
    
5.  Wählen Sie `API-Schlüssel` und erstellen Sie einen API-Schlüssel für Ihr Korpus, indem Sie Ihr Korpus im Dropdown-Menü auswählen. Speichern Sie Ihren API-Schlüssel für später.
    

### High-Level-Architektur

Die Architektur wird wie folgt aufgebaut sein:

1.  Die Chat-Anwendung wird PubNub verwenden, um Nachrichten zu senden und zu empfangen
    
2.  Eine PubNub-Funktion hört diese Nachrichten auf einem bestimmten Kanal ab
    
3.  Ein PubNub-Signal wird abgefeuert, um dem Benutzer mitzuteilen, wann die KI denkt und wann sie fertig ist.
    
4.  Die Nachricht wird dann mit Hilfe der Vectara Rest API an Vectara weitergeleitet.
    
5.  Die PubNub-Funktion parst dann eines von vielen Ergebnissen aus der Antwort von Vectara
    
6.  Die Antwort wird dann in einem mit Ihrem Chatbot verbundenen Kanal veröffentlicht.
    

Konfigurieren Ihrer PubNub-Funktion
-----------------------------------

1.  Navigiere zum [Admin-Dashboard](https://admin.pubnub.com/)
    
2.  Wählen Sie `Funktionen` im linken Menü und klicken Sie auf den entsprechenden Schlüsselsatz, den Sie verwenden möchten
    
3.  Wählen Sie `+ Modul erstellen` und geben Sie einen Modulnamen und eine Beschreibung ein
    
4.  Wählen Sie das soeben erstellte Modul aus und klicken Sie auf `+ Create a Function`
    
5.  Geben Sie der Funktion einen Namen, z. B. `Vectara Query`, und wählen Sie im Dropdown-Menü die Option `After Publish oder Fire`. Diese Funktion wird ausgelöst, nachdem die Nachricht im entsprechenden Channel veröffentlicht wurde, in diesem Fall `docs-pubnub-ai`
    
6.  Setzen Sie den Kanalnamen auf `docs-pubnub-ai`
    
7.  Klicken Sie auf `My Secrets` und erstellen Sie ein Geheimnis namens `VECTARA_API_KEY` und `CUSTOMER_ID`
    

Hier ist der Code für die Abfrage der Vectara-Datenbank aus einer PubNub-Funktion
---------------------------------------------------------------------------------

Der Codeschnipsel für die PubNub-Funktion ist wie folgt definiert:

```js
const Promise = require('promise');

//
// API Key For OpenAI
// **Add your Vectara API Key and Customer ID to MY SECRETS (Left Panel)**
//
let VECTARA_API_KEY = null;
let CUSTOMER_ID = null;
let channel = "docs-pubnub-ai-response";
function getVectaraKey() {
   // Use cached key
   if (VECTARA_API_KEY && CUSTOMER_ID) {
       return new Promise(resolve => resolve(VECTARA_API_KEY));
   }
   // Fetch key from vault
   return vault.get("VECTARA_API_KEY").then(apikey => {
       return vault.get("CUSTOMER_ID").then(customer_id => {
            VECTARA_API_KEY = apikey;
            CUSTOMER_ID = customer_id;
           return new Promise(resolve => resolve(VECTARA_API_KEY));
       });
   });
}

//
// Import Modules
//
const xhr = require('xhr');
const vault = require('vault');
const pubnub = require('pubnub');

//
// Main
//
export default (request) => {
   // Input data for Vectara
   let message = request.message.text;
   let signalMessage = { message: { type: "typing_on" }, channel: channel };
   return pubnub.signal(signalMessage).then((_) => {
       return getVectaraKey().then(_ => {
           return vectara(message).then(response => {
               return pubnub.publish({
                   channel: channel,
                   message: {
                       id: "PubNubAI",
                       type: "default",
                       text: response
                   },
               }).then((publishResponse) => {
                   console.log(publishResponse);
                   message = { message: { type: "typing_off" }, channel: channel };
                   return pubnub.signal(message).then((signalOffResponse) => {
                       console.log(signalOffResponse);
                       return request.ok();
                   });
               }).catch((err) => {
                   console.error(err);
               });
           });
       });
   });
};

//
// API Call to Vectara asking the AI a question
//
async function vectara(question) {
   console.log("SENDING REQUEST TO VECTARA");
   const url = "https://api.vectara.io/v1/query";
   const body = JSON.stringify({
       "query": [
           {
           "query": question,
           "start": 0,
           "numResults": 10,
           "contextConfig": {
               "charsBefore": 0,
               "charsAfter": 0,
               "sentencesBefore": 2,
               "sentencesAfter": 2,
               "startTag": "<b>",
               "endTag": "</b>"
           },
           "corpusKey": [
               {
               "customerId": CUSTOMER_ID,
               "corpusId": 1,
               "semantics": "DEFAULT",
               "dim": [
                   {
                   "name": "string",
                   "weight": 0
                   }
               ],
               "lexicalInterpolationConfig": {
                   "lambda": 0.025
               }
               }
           ],
           "rerankingConfig": {
               "rerankerId": 272725717
           },
           "summary": [
               {
               "summarizerPromptName": "",
               "maxSummarizedResults": 5,
               "responseLang": "eng",
               "summarizerPromptId": 1,
               "debug": false,
               "responseChars": 0
               }
           ]
           }
       ]
   });

   const http_options = {
       'method': 'POST',
       'timeout': 20000,
       'headers': {
           'Content-Type': 'application/json',
           'customer-id': CUSTOMER_ID,
           'x-api-key': VECTARA_API_KEY
        },
       'body': body
   };

   xhr.timeout = 100000;

   // Send API Request to OpenAI GPT Model
   const response = await xhr.fetch(url, http_options).then(res => res.json());

   // Parse the response and get the summary
   const summary = response.responseSet[0].summary[0].text;

   return summary;
}
```

Verbinden der PubNub Function mit Ihrer UI
------------------------------------------

Um die PubNub-Funktion mit einer Benutzeroberfläche zu verbinden, folgen Sie dem oben definierten Code und verwenden Sie eines der vielen [SDKs](https://www.pubnub.com/docs/sdks) die PubNub zur Verfügung stellt. [Veröffentlichen/Abonnieren](https://www.pubnub.com/docs/sdks/javascript/api-reference/publish-and-subscribe) in den Kanal `pubnub-docs-ai` und warten Sie, bis die Vectara-Abfrage nach der Verwendung der obigen PubNub-Funktion beendet ist. Verbinden eines [Tippen-Indikator](https://www.pubnub.com/docs/chat/sdks/messages/typing) um auf dem Kanal `pubnub-docs-ai` nach PubNub-Signalen zu lauschen, kann der Benutzer sehen, wann der PubNub Knowledge-Bot denkt, was die Benutzererfahrung verbessert.

Der Code für die Anbindung der PubNub-Funktion in React:

```js
const pubnub = new PubNub({
   publishKey: process.env.NEXT_PUBLIC_PUBLISH_KEY!,
   subscribeKey: process.env.NEXT_PUBLIC_SUBSCRIBE_KEY!,
   userId: "You",
 });

 const publishChannel = "docs-pubnub-ai";

 const sendMessage = (message: string) => {
   if (message) {
     pubnub.publish({
         channel: publishChannel, message: {
           text: message
       }});
   }
 };
```

Eine Zusammenfassung
--------------------

Die Verwendung von PubNub-Funktionen zusammen mit einer beliebigen Vektordatenbank oder einem Vektorspeicher ist ein sehr schneller und produktionsreifer Weg, um Ihren eigenen AI Knowledge Bot zu erstellen. Sie können nicht nur Vectara auf diese Weise nutzen, sondern auch Pinecone, Weaviate oder jede andere produktive Vektordatenbank. Mit PubNub Functions ist es einfach zu hosten und zu kontrollieren, wie und wann die Nachricht gesendet wird, um die Funktionalität Ihrer Vektordatenbank zu verbessern.

Registrieren Sie sich für unser [Admin-Dashboard](https://admin.pubnub.com/#/register) um Ihr PubNub Keyset zu konfigurieren. Sehen Sie sich auch die Anzahl der [Anleitungen](https://www.pubnub.com/tutorials/) und [Blogs](https://www.pubnub.com/blog/) die wir für Ihren spezifischen [Anwendungsfall](https://www.pubnub.com/use-case/).

Wie kann PubNub Ihnen helfen?
=============================

Dieser Artikel wurde ursprünglich auf [PubNub.com](https://www.pubnub.com/blog/build-chatbot-with-custom-knowledge-base/) veröffentlicht.

Unsere Plattform unterstützt Entwickler bei der Erstellung, Bereitstellung und Verwaltung von Echtzeit-Interaktivität für Webanwendungen, mobile Anwendungen und IoT-Geräte.

Die Grundlage unserer Plattform ist das größte und am besten skalierbare Echtzeit-Edge-Messaging-Netzwerk der Branche. Mit über 15 Points-of-Presence weltweit, die 800 Millionen monatlich aktive Nutzer unterstützen, und einer Zuverlässigkeit von 99,999 % müssen Sie sich keine Sorgen über Ausfälle, Gleichzeitigkeitsgrenzen oder Latenzprobleme aufgrund von Verkehrsspitzen machen.

PubNub erleben
--------------

Sehen Sie sich die [Live Tour](https://www.pubnub.com/tour/introduction/) an, um in weniger als 5 Minuten die grundlegenden Konzepte hinter jeder PubNub-gestützten App zu verstehen

Einrichten
----------

Melden Sie sich für einen [PubNub-Account](https://admin.pubnub.com/signup/) an und erhalten Sie sofort kostenlosen Zugang zu den PubNub-Schlüsseln

Beginnen Sie
------------

Mit den [PubNub-Dokumenten](https://www.pubnub.com/docs) können Sie sofort loslegen, unabhängig von Ihrem Anwendungsfall oder [SDK](https://www.pubnub.com/docs)