Construire un chatbot LLM avec une base de connaissances personnalisée
Published: 2024-02-01 21:24:39

Avec toute l'attention que ces LLM et ChatGPT ont reçue, un nouveau principe émerge : "Garbage in, garbage out". Lorsque l'on utilise GPT-4 ou GPT-3.5, ou tout autre grand modèle linguistique, ce concept s'applique à deux endroits [Ingénierie des messages-guides](https://en.wikipedia.org/wiki/Prompt_engineering#:~:text=Prompt%20engineering%20(also%20known%20as,of%20it%20being%20explicitly%20given.) et [Mise au point](https://en.wikipedia.org/wiki/Fine-tuning_(deep_learning)). Nous devons également tenir compte de la date à laquelle ces modèles ont été formés afin de vérifier l'ancienneté ou la nouveauté des données qu'ils nous fournissent.

La plupart des entreprises se trouvent aujourd'hui dans des sources de données d'entreprise - à l'intérieur d'un pare-feu ou à l'extérieur et non dans le domaine public de l'internet. Si nous pouvons exploiter les LLM sur ces données, de nouvelles possibilités apparaissent.

Cet article traite de la création d'un chatbot avec une base de connaissances personnalisée en 30 minutes pour que votre IA réponde à des questions sur vos données.

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

Conditions préalables à la création d'un chatbot de connaissance
----------------------------------------------------------------

Nous devons tenir compte de la quantité de données dont nous disposons pour créer une base de connaissances personnalisée. Dans ce blog, nous allons créer un assistant en utilisant la documentation PubNub. Il y a beaucoup de documentation, nous devrions donc envisager d'utiliser un service de production tel que [Vectara](https://vectara.com/), [Pinecone](https://www.pinecone.io/)ou [Weaviate](https://weaviate.io/) pour gérer nos encastrements vectoriels. Vous pouvez utiliser LangChain pour créer une base de données vectorielle locale pour de plus petites quantités de données. LangChain prend également en charge le mappage de vos embeddings personnalisés à vos modèles LLM par le biais d'une recherche sémantique ou de similarité.

Pour ce blog, nous allons configurer une base de données vectorielle sur Vectara, car elle offre une solution simple de glisser-déposer pour toutes les données de votre entreprise. La meilleure façon d'interagir avec Vectara est d'utiliser les fonctions de [PubNub Functions](https://www.pubnub.com/docs/general/serverless/functions/overview#:~:text=PubNub%20provides%20Functions%20to%20capture,filter%2C%20and%20even%20aggregate%20data.)qui fournit un conteneur JavaScript sans serveur qui s'exécute chaque fois qu'un événement prédéfini se produit. Vous aurez la possibilité de personnaliser le moment où la fonction s'exécute et est déclenchée, ce qui vous permettra d'ajuster le fonctionnement de votre AI Knowledge Bot.

Vectara utilisera votre ensemble de données pour indexer vos données en plusieurs embeddings. Lorsque vous passez un texte ou une entrée utilisateur, Vectara lance une recherche sémantique sur vos données et résume les résultats qu'il a trouvés, fournissant une réponse à votre question en utilisant vos données personnalisées. Vous obtiendrez ainsi les informations pertinentes dont vous avez besoin. Vectara supporte plusieurs types de fichiers tels que TXT, HTML, PDF et Word. Rassemblez tous les documents que vous souhaitez télécharger et ajoutez-les à un dossier individuel.

### Comment configurer Vectara

L'installation de Vectara se fait comme suit :

1.  [S'inscrire](https://console.vectara.com/login) ou connectez-vous à Vectara
    
2.  Une fois sur le tableau de bord, cliquez sur `Créer un corpus`.
    
3.  Une fois que vous avez donné un nom et une description au corpus, sous l'en-tête `Data Ingestion`, faites glisser et déposez les fichiers dont vous voulez que votre LLM ait connaissance dans la section `Upload Files`. Une fois vos fichiers téléchargés, vous pouvez vérifier l'ID de votre corpus en haut de la page web car vous en aurez besoin pour la requête que nous sommes sur le point d'écrire.
    
4.  Cliquez sur votre courriel dans le coin supérieur droit et enregistrez votre `identifiant client` pour plus tard.
    
5.  Sélectionnez `Clés API` et créez une clé API pour votre corpus en sélectionnant votre corpus dans le menu déroulant. Enregistrez votre clé API pour plus tard.
    

### Architecture de haut niveau

L'architecture sera structurée comme suit :

1.  L'application de chat utilisera PubNub pour envoyer et recevoir des messages
    
2.  Une fonction PubNub écoutera ces messages sur un canal spécifique
    
3.  Un signal PubNub sera déclenché pour indiquer à l'utilisateur que l'IA réfléchit et qu'elle a terminé.
    
4.  Le message sera ensuite transmis à Vectara en utilisant l'API Rest de Vectara.
    
5.  La fonction PubNub analysera un des nombreux résultats de la réponse de Vectara.
    
6.  La réponse sera ensuite publiée sur un canal associé à votre chatbot.
    

Configuration de votre fonction PubNub
--------------------------------------

1.  Naviguez vers le [tableau de bord administratif](https://admin.pubnub.com/)
    
2.  Sélectionnez `Fonctions` dans le menu de gauche et cliquez sur le jeu de clés approprié que vous souhaitez utiliser.
    
3.  Sélectionnez `+ Créer un module` et entrez un nom de module et une description
    
4.  Sélectionnez le module que vous venez de créer et cliquez sur `+ Créer une fonction`
    
5.  Donnez un nom à la fonction, par exemple `Vectara Query`, et sélectionnez `After Publish ou Fire` dans le menu déroulant. Cette fonction se déclenchera après la publication du message sur le canal approprié, dans ce cas, `docs-pubnub-ai` .
    
6.  Définissez le nom du canal sur `docs-pubnub-ai`.
    
7.  Cliquez sur `Mes secrets` et créez un secret appelé `VECTARA_API_KEY` et `CUSTOMER_ID`.
    

Voici le code pour interroger la base de données Vectara à partir d'une fonction PubNub
---------------------------------------------------------------------------------------

Le code de la fonction PubNub est défini comme suit :

```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;
}
```

Connecter la fonction PubNub à votre interface utilisateur
----------------------------------------------------------

Pour connecter la fonction PubNub à une interface utilisateur en suivant le code défini ci-dessus en utilisant l'un des nombreux [SDK](https://www.pubnub.com/docs/sdks) que PubNub fournit. [Publier/s'abonner](https://www.pubnub.com/docs/sdks/javascript/api-reference/publish-and-subscribe) au canal `pubnub-docs-ai` et attendez que la requête Vectara se termine après avoir utilisé la fonction PubNub ci-dessus. Connexion d'un [Indicateur de frappe](https://www.pubnub.com/docs/chat/sdks/messages/typing) pour écouter les signaux PubNub sur le canal `pubnub-docs-ai` permettra à l'utilisateur de voir quand le PubNub Knowledge bot réfléchit, ajoutant une expérience plus fluide pour l'utilisateur final.

Le code pour connecter la fonction PubNub dans 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
       }});
   }
 };
```

En résumé
---------

L'utilisation des fonctions PubNub avec n'importe quelle base de données vectorielle ou magasin de vecteurs est un moyen très rapide et prêt à la production pour créer votre propre robot de connaissance IA. Vous pouvez non seulement utiliser Vectara de cette façon, mais aussi Pinecone, Weaviate ou toute autre base de données vectorielle de production. Avec les fonctions PubNub, il est facile d'héberger et de contrôler comment le message est envoyé et quand il est envoyé pour améliorer la fonctionnalité de vos bases de données vectorielles.

Inscrivez-vous à notre [tableau de bord d'administration](https://admin.pubnub.com/#/register) pour commencer à configurer votre jeu de clés PubNub. Consultez également le nombre de [tutoriels](https://www.pubnub.com/tutorials/) et de [blogs](https://www.pubnub.com/blog/) que nous avons pour votre [cas d'utilisation](https://www.pubnub.com/use-case/).

Comment PubNub peut-il vous aider ?
===================================

Cet article a été publié à l'origine sur [PubNub.com](https://www.pubnub.com/blog/build-chatbot-with-custom-knowledge-base/)

Notre plateforme aide les développeurs à construire, livrer et gérer l'interactivité en temps réel pour les applications web, les applications mobiles et les appareils IoT.

La base de notre plateforme est le réseau de messagerie en temps réel le plus grand et le plus évolutif de l'industrie. Avec plus de 15 points de présence dans le monde, 800 millions d'utilisateurs actifs mensuels et une fiabilité de 99,999 %, vous n'aurez jamais à vous soucier des pannes, des limites de concurrence ou des problèmes de latence causés par les pics de trafic.

Découvrez PubNub
----------------

Découvrez le [Live Tour](https://www.pubnub.com/tour/introduction/) pour comprendre les concepts essentiels de chaque application alimentée par PubNub en moins de 5 minutes.

S'installer
-----------

Créez un [compte PubNub](https://admin.pubnub.com/signup/) pour un accès immédiat et gratuit aux clés PubNub.

Commencer
---------

La [documentation PubNub](https://www.pubnub.com/docs) vous permettra de démarrer, quel que soit votre cas d'utilisation ou votre [SDK](https://www.pubnub.com/docs).