Tutoriel Chroma : Améliorez votre chatbot avec le modèle Claude d'Anth

Introduction

Le modèle Claude d'Anthropic dévoilé : Débloquer des capacités uniques

Anthropic, une entreprise mondiale d'IA de premier plan, présente le modèle révolutionnaire Claude. De Notion à Quora, les grands acteurs de la technologie exploitent sa polyvalence dans les conversations, le traitement de texte et même le codage. Mais qu'est-ce qui distingue Claude ? Plongez dans ce tutoriel distinctif explorant les fonctionnalités remarquables qui font de Claude un modèle à part.

La puissance de ChromaDB et des embeddings

Découvrez le rôle essentiel des embeddings dans le traitement du langage naturel et l'apprentissage automatique. Apprenez comment ces représentations vectorielles capturent le sens sémantique, permettant des recherches textuelles basées sur la similarité. Explorez ChromaDB, une base de données d'embeddings open-source, et sa capacité à stocker et interroger des embeddings à l'aide de représentations de documents. Plongez dans cette discussion éclairante sur le monde dynamique des embeddings et de ChromaDB.

Prérequis

Connaissances de base en Python
Accès à l'API Claude d'Anthropic
Accès à l'API OpenAI (pour la fonction d'embedding)
Une base de données Chroma configurée

Aperçu

Initialisation du projet
Configuration des bibliothèques requises
Écriture des fichiers du projet
Test du chatbot de base sans conscience du contexte
Utilisation de la grande fenêtre de contexte de Claude
Test du chatbot avec conscience du contexte
Fournir des informations contextuelles à Claude
Évaluation du chatbot amélioré (contexte supplémentaire fourni)
Création d'une base de connaissances pour Claude
Test de la forme finale de Claude (améliorée par la base de connaissances)
Discussion

Initialisation du projet

Très bien, retroussons nos manches et commençons à coder ! D'abord, nous devons initialiser le projet. Nous allons l'appeler chroma-claude cette fois. Alors, ouvrez votre terminal préféré, accédez à votre répertoire de code ou de projet préféré et créez un nouveau répertoire pour chroma-claude. Voici comment faire :

Ensuite, nous allons créer un nouvel environnement virtuel pour ce projet. Si vous vous demandez pourquoi, eh bien, un environnement virtuel nous aide à garder les dépendances de notre projet séparées de notre environnement Python global. Cette isolation est un véritable sauveur lorsque vous jonglez avec plusieurs projets ayant des dépendances différentes.

Mais ce n'est pas le seul avantage d'un environnement virtuel ! Cela rend également plus facile le suivi des bibliothèques spécifiques et des versions que nous utilisons. Nous le faisons en 'faisant un gel' dans un fichier requirements.txt, qui est un enregistrement pratique de toutes les dépendances dont votre projet a besoin pour fonctionner.

Allons-y et configurons cet environnement virtuel !

Pour créer un nouvel environnement virtuel, nous utiliserons la commande suivante dans notre terminal :

python3 -m venv env

Une fois que nous avons créé l'environnement, nous devons l'activer. Cette étape est légèrement différente selon que vous utilisez Windows ou un système basé sur Unix (comme Linux ou MacOS). Voici comment procéder :

Si vous êtes sous Windows, vous utiliseriez la commande suivante dans votre terminal :
```
.\env\Scripts\activate
```
Si vous êtes sous Linux ou MacOS, la commande ressemblera à ceci :
```
source env/bin/activate
```

Après avoir exécuté la commande appropriée, vous devriez voir le nom de votre environnement (env, dans ce cas) apparaître entre parenthèses au début de votre invite de terminal. Cela signifie que l'environnement est activé et prêt à fonctionner ! Voici à quoi cela devrait ressembler :

Super travail ! Vous avez configuré et activé votre environnement virtuel.

Configuration des bibliothèques requises

Ensuite, nous devons installer toutes les bibliothèques requises. Si vous avez lu mes autres tutoriels sur Chroma et les modèles OpenAI, vous trouverez notre processus d'installation assez familier. Cependant, cette fois, nous allons également installer la bibliothèque anthropique.

Voici un rapide aperçu des bibliothèques que nous allons utiliser :

chromadb : Nous l'utiliserons pour stocker et interroger les embeddings.
anthropic : Cela est nécessaire pour interagir avec le modèle Claude d'Anthropic.
halo : Cette bibliothèque fournit de chouettes indicateurs de chargement qui s'affichent en attendant les requêtes.

Commençons à installer ces bibliothèques. J'utiliserai pip3 pour l'installation. Si vous êtes plus à l'aise avec pip, n'hésitez pas à passer à cela.

pip install chromadb anthropic halo

Écrire les fichiers du projet

Il est temps de replonger dans la partie codage ! Assurez-vous que nous sommes toujours dans notre répertoire de projet. Ouvrez votre IDE ou éditeur de code préféré et créez un nouveau fichier, appelons-le main.py. Ce sera le seul fichier Python dont nous aurons besoin pour ce projet.

Étape 1 : Importer les bibliothèques nécessaires

Commencez par importer les bibliothèques nécessaires. Celles-ci incluent dotenv pour charger des variables d'environnement, os pour des opérations au niveau système, anthropique pour interagir avec le modèle Claude, pprint pour une impression soignée et halo pour afficher un indicateur de chargement.

Étape 2 : Charger les variables d'environnement

Chargez les variables d'environnement à partir de votre fichier .env. C'est ici que vous stockez des données sensibles comme votre clé API Anthropic.

Étape 3 : Définir la fonction de génération de réponse

Définissez une fonction appelée generate_response() qui prend en entrée des messages et renvoie une réponse générée par le modèle. À l'intérieur de cette fonction, vous initialisez d'abord un indicateur de chargement qui s'exécute pendant que le modèle génère une réponse.

Étape 4 : Créer un client Anthropic et envoyer une requête de complétion

Ensuite, créez un client Anthropic en utilisant votre clé API et utilisez-le pour envoyer une requête de complétion au modèle Claude. La requête inclut vos messages d'entrée, le nom du modèle et les séquences d'arrêt pour signaler la fin d'un tour de conversation.

Étape 5 : Arrêter le spinner et imprimer la requête et la réponse

Une fois la réponse reçue, arrêtez l'indicateur de chargement. Imprimez à la console à la fois la requête et la réponse à des fins de débogage. Ensuite, renvoyez la réponse.

Étape 6 : Définir la fonction principale

Définissez la fonction principale. C'est ici que vous démarrez une boucle continue pour obtenir l'entrée de l'utilisateur et générer des réponses.

Étape 7 : Préparer l'invite et gérer la commande 'quit'

À l'intérieur de la boucle, vous préparez d'abord l'invite pour le modèle Claude en concaténant le texte d'entrée de l'utilisateur avec les marqueurs de conversation nécessaires. Vous gérez également la commande "quit" : si l'utilisateur tape "quit", vous sortez de la boucle pour arrêter la discussion.

Étape 8 : Générer une réponse et l'imprimer

Ensuite, vous appelez la fonction generate_response() avec les messages préparés pour générer une réponse du modèle Claude. Une fois la réponse reçue, vous l'imprimez à la console, avec le préfixe "Claude:" pour indiquer la réponse du chatbot.

Étape 9 : Exécuter la fonction principale

Enfin, vous incluez une déclaration conditionnelle pour vous assurer que la fonction principale ne s'exécute que si le script est exécuté directement (et non importé en tant que module).

Chatbot de base (sans conscience du contexte)

Si vous avez suivi les étapes correctement, votre script complet main.py devrait ressembler à ceci :

...

Ce script permettra une interaction de base avec le chatbot basé sur le modèle Claude, cependant, il ne conserve pas le contexte entre les entrées de l'utilisateur. Cela signifie que chaque entrée est traitée comme une conversation distincte, et le modèle ne se souvient pas des entrées précédentes.

.env

Rappelez-vous de la partie où nous chargeons des variables à partir de l'environnement avec la fonction load_dotenv() ? C'est ici que la fonction prend les variables et leurs valeurs. Créons le fichier et écrivons les variables et leurs valeurs comme suit :

CLAUDE_KEY=your_api_key_here

Veuillez noter que le fichier .env contient des informations sensibles, et donc vous devez garder ce fichier dans un endroit sûr, ne partagez jamais ces valeurs, en particulier la CLAUDE_KEY, qui doit rester secrète.

requirements.txt

Enfin, bien que cette partie soit optionnelle, il est considéré comme une bonne pratique d'enregistrer notre liste de dépendances dans un fichier appelé requirements.txt. Cela permet à d'autres développeurs d'installer facilement les bibliothèques requises avec une simple commande.

Pour créer le fichier requirements.txt, accédez à l'environnement virtuel de votre projet où toutes les dépendances nécessaires sont installées et exécutez :

pip freeze > requirements.txt

Ensuite, quiconque souhaite exécuter votre projet pourra installer toutes les dépendances requises en utilisant cette commande :

pip install -r requirements.txt

Cette commande est généralement exécutée par quelqu'un qui veut installer ou exécuter votre projet. Il est conseillé de l'inclure dans la documentation de votre projet, sous une section sur la façon d'installer ou d'exécuter votre projet.

Tester le chatbot de base sans conscience du contexte

Maintenant, testons notre première itération du chatbot Claude ! Bien que cette version de base devrait bien fonctionner, elle manque de 'connaissance du contexte' - un terme utilisé pour décrire la capacité d'un chatbot à se souvenir et à se référer aux parties antérieures de la conversation. Cela signifie qu'après chaque réponse, notre bot oubliera ce que l'utilisateur a dit précédemment.

Pour tester le chatbot, exécutez le script main.py avec la commande python ou python3 dans votre terminal :

python main.py

Si tout a été configuré correctement, le terminal devrait afficher une invite d'entrée, vous invitant à entrer un message. Essayez de taper quelque chose et appuyez sur entrée. Vous verrez un indicateur de chargement apparaître pendant que le bot génère une réponse.

Après quelques secondes, le terminal affichera la réponse du bot.

Maintenant, essayez de poser une question de suivi au bot basée sur sa réponse précédente. Vous remarquerez que Claude ne se souvient pas du contexte du message précédent.

Souvenez-vous que si vous rencontrez des problèmes lors de l'exécution du script, vérifiez le message d'erreur dans le terminal et essayez de résoudre le problème en conséquence.

Utiliser la grande fenêtre de contexte de Claude

Nous utilisons donc un modèle avec une fenêtre de contexte vraiment grande. Ce serait une tragédie de ne l'utiliser que pour une conversation dont il oublie immédiatement les détails. Modifions un peu notre code. Cette fois, notre code doit capturer à la fois le chat précédent et l'entrée actuelle de l'utilisateur.

Ce nouveau bloc introduit une variable messages en dehors de la boucle principale. Cette variable contiendra l'historique complet de la conversation et sera mise à jour en continu tout au long de la discussion.

Ici, plutôt que de simplement attribuer l'entrée actuelle de l'utilisateur à la variable messages, vous l'ajoutez maintenant. Cela garantit que la variable messages maintient un enregistrement de toutes les entrées de l'utilisateur.

Dans ce nouveau bloc, après avoir généré une réponse de Claude, vous ajoutez la réponse de Claude à la variable messages. Cela permet de garder une trace tant des entrées de l'utilisateur que des réponses de Claude dans la variable messages, donnant à Claude accès à l'historique complet de la conversation.

Enfin, pour accueillir les grands historiques de conversation que la variable messages pourrait contenir, vous avez augmenté max_tokens_to_sample de 300 à 1200. Cela indique à Claude de considérer jusqu'à 1200 tokens lors de la génération d'une réponse, ce qui est particulièrement important lorsqu'il s'agit de conversations plus longues. Cependant, notez que si une conversation dépasse la fenêtre de contexte du modèle de 1200 tokens, les parties plus anciennes de la conversation seront tronquées ou ignorées, ce qui peut entraîner une perte de contexte.

Maintenant, examinons notre code mis à jour :

...

Tester le chatbot avec conscience du contexte

Dans cette section, nous allons mettre notre chatbot conscient du contexte à l'épreuve. En particulier, nous allons demander à Claude ce qu'il sait sur le jeu vidéo Dota2, et en particulier sur le dernier patch, "Nouvelle Frontière".

Tout semble fonctionner correctement. Maintenant, posons une deuxième question : "Que sais-tu sur le dernier patch, Nouvelle Frontière ?" Claude, malgré le fait qu'il s'agisse d'un chatbot avancé, avoue ne pas avoir de connaissance spécifique sur le dernier patch. Cela est dû à la date de coupure de l'entraînement du modèle, qui s'est achevé fin 2021. Dans un scénario plus optimal, Claude fournirait tout de même des informations pertinentes, bien que peut-être obsolètes. Dans un scénario moins souhaitable, Claude pourrait générer ce qui semble être des informations précises, mais qui est en réalité incorrectes, un phénomène connu sous le nom d'"hallucination". Il est crucial d'être conscient de ces limitations et d'exercer de la prudence lorsque vous interrogez le modèle sur des événements ou des informations postérieures à son entraînement.

Alors, comment pouvons-nous contourner cette limitation et doter Claude d'informations plus récentes ? Eh bien, dans le cadre de ce tutoriel, nous allons fournir à Claude des matériaux d'apprentissage supplémentaires manuellement, en copiant et collant les données dans des fichiers texte, que nous pourrons ensuite lire à l'aide de la fonctionnalité intégrée de Python. Bien que nous ne fassions pas techniquement apprendre à Claude au sens conventionnel, nous fournissons des données fraîches qu'il peut utiliser pour générer des réponses plus à jour. Approfondissons cela dans la section suivante.

Fournir des informations contextuelles à Claude

Pour tester le plein potentiel de Claude, nous devons lui fournir suffisamment de données pertinentes au contexte. Pour ce tutoriel, j'ai copié du texte provenant de sites wiki, comme celui d'IGN discutant du patch "Nouvelles Frontières". Ce texte est enregistré dans un fichier nommé patch_notes.txt. Commençons par lire ce fichier dans notre fonction principale.

Nous lisons le fichier texte et utilisons son contenu pour former le message initial pour Claude. Ce message fournira à Claude le contexte concernant le patch de Dota2, auquel il pourra se référer en répondant à des questions connexes. Cette méthode ne fait pas techniquement apprendre à Claude "de nouvelles informations", mais elle aide à générer des réponses précises pour cette interaction spécifique.

Nous ajoutons également un compteur de tokens près de la fin de la fonction main(). Cela nous aide à surveiller le nombre total de tokens utilisés dans la conversation, garantissant que nous ne dépassons pas la limite maximale de tokens du modèle. Voici à quoi ressemble notre code mis à jour :

...

Évaluation du chatbot amélioré (contexte supplémentaire fourni)

Mise à l'épreuve de notre chatbot amélioré ! D'abord, nous allons lui demander des informations générales concernant le dernier patch de Dota2, "Nouvelles Frontières".

Impressionnant, Claude énumère maintenant tous les changements majeurs introduits par le patch avec une précision remarquable. Cependant, il est à noter que le compteur de tokens a déjà atteint 5298. Cela nous rappelle que des réponses approfondies et un historique de conversation étendu peuvent rapidement consommer des tokens.

Pour évaluer davantage la compréhension de Claude du contexte fourni, nous allons lui poser une question au sujet des "Tormentors". Cette question peut être considérée comme un prélude à la connaissance contextuelle de Claude. Pour un auditeur non informé, "Tormentors" peut évoquer des images de créatures cruelles et menaçantes, alors que dans Dota2, il s'agit en réalité de cubes flottants inoffensifs.

Claude a brillamment réussi le test ! Il est fascinant de constater à quel point des incitations appropriées, couplées à des contextes supplémentaires, peuvent améliorer considérablement la précision des réponses de Claude.

Bâtir une base de connaissances pour Claude

L'objectif de bâtir une base de connaissances pour Claude est de l'équiper d'une vaste gamme de données auxquelles il peut se référer lors de la génération de réponses. Cela lui permet de fournir des réponses plus précises et conscientes du contexte, même lorsqu'il s'agit de données complexes et diverses, comme les dernières notes de mise à jour de Dota2.

Pour y parvenir, nous allons utiliser la base de données Chroma comme notre base de connaissances. Ainsi, nous pouvons décomposer les données en morceaux plus petits et les stocker dans la base de données. C'est plus efficace que de fournir l'ensemble des données à Claude chaque fois que nous communiquons avec lui. Pour décomposer les données en morceaux plus petits, nous allons utiliser la bibliothèque tiktoken.

Tout d'abord, installons tiktoken et chromadb, et mettons à jour notre fichier requirements.txt :

pip install tiktoken chromadb

Ensuite, nous allons apporter quelques modifications à notre script pour permettre la fonctionnalité de la base de données Chroma :

Tout d'abord, nous importons toutes les bibliothèques requises :

from chromadb import Client
import tiktoken # <- obtenir la bibliothèque tiktoken

Maintenant, créons une fonction create_chunks pour diviser notre texte volumineux en morceaux plus petits. Cette fonction renverra les morceaux de texte successifs :

def create_chunks(text, max_length=512):
    return [text[i:i+max_length] for i in range(0, len(text), max_length)]

Dans la fonction principale, nous initialisons le tokenizer, segmentons les notes de patch et créons une nouvelle collection Chroma. Chaque morceau de texte est ensuite ajouté à la collection en tant que document séparé :

def main():
    ...
    chunks = create_chunks(patch_notes)
    for chunk in chunks:
        chroma_collection.add_document(chunk)
    ...

Lors de la conversation avec l'utilisateur, nous interrogeons la collection Chroma pour obtenir les 20 documents les plus pertinents par rapport à l'entrée de l'utilisateur. Les résultats de cette requête sont ensuite ajoutés au contexte pour Claude, améliorant ainsi ses réponses :

def main():
    ...
    relevant_docs = chroma_collection.query(user_input, top_k=20)
    context = "".join(relevant_docs) + previous_context
    response = generate_response(context)
    ...

Tester la forme finale de Claude (améliorée par la base de connaissances)

Nous sommes enfin arrivés au moment de vérité ! Ce tutoriel a peut-être été un peu plus long que d'habitude, mais il est essentiel pour démontrer la grande fenêtre de contexte de Claude et la puissance de la base de données Chroma pour améliorer la base de connaissances de Claude. Alors, mettons notre Claude amélioré à l'épreuve !

Dans le premier test, je vais demander à Claude de lister les trois mises à jour de jeu les plus significatives dans le dernier patch de Dota 2.

Claude a identifié avec brio les trois mises à jour les plus décisives : la carte étendue avec 40 % de terrain en plus, la refonte de la black king bar, et le nouveau type d'attribut de héros : Universel. Rappelez-vous, nous n'avons pas fourni à Claude l'ensemble des notes de patch d'un seul coup. Au lieu de cela, il s'appuie sur la puissance de sa base de connaissances améliorée pour récupérer ces informations pertinentes.

Pour le prochain défi, je vais demander à Claude d'expliquer ce que sont les Tormentors dans le dernier patch, comme si j'allais entrer dans une partie sans rien savoir.

Claude fournit un aperçu général des Tormentors mais manque certains détails importants. Par exemple, il fait référence à "plusieurs Tormentors" alors que seulement deux apparaissent à des emplacements spécifiques sur l'ensemble de la carte. Cela souligne la nécessité de mettre continuellement à jour la base de connaissances avec des données plus précises pour aider Claude à fournir des analyses plus exactes et utiles.

Ces tests démontrent le potentiel des modèles d'IA tels que Claude lorsqu'ils sont associés à une base de connaissances riche et continuellement mise à jour. Ils montrent également la nature continue du développement de l'IA - à mesure que nous alimentons nos modèles avec des données plus pertinentes et meilleures, leurs réponses deviennent de plus en plus précises et nuancées.

Conclusion : Libérer la puissance du modèle Claude d'Anthropic et de l'intégration Chroma

Dans ce tutoriel anthropique complet, nous avons exploré les extraordinaires capacités du modèle Claude d'Anthropic et de la base de données Chroma. Le modèle Claude, avec sa vaste fenêtre de contexte, a été instrumental dans le développement d'un chatbot capable de lire et de comprendre d'énormes données textuelles, fournissant une analyse détaillée sur les mises à jour de Dota 2. La base de données Chroma a encore amplifié cette capacité, permettant la création d'une base de connaissances plus efficace et évolutive, tout en conservant l'utilisation des tokens dans ce processus.

Bien que nous ayons réalisé un succès notable, ce tutoriel d'application anthropique a également mis en évidence des domaines potentiels d'amélioration. Par exemple, affiner la compréhension de notre modèle des éléments de jeu spécifiques, tels que les Tormentors dans Dota 2, et mettre continuellement à jour et à élargir la base de connaissances afin d'assurer la précision du chatbot.

Le potentiel de ce que nous pouvons construire ensuite avec la combinaison Claude + Chroma est véritablement stupéfiant. Qu'il s'agisse d'un chatbot pour une analyse approfondie des stratégies de jeu, d'un assistant virtuel expert dans une large gamme de sujets, ou d'un outil puissant pour aider les chercheurs à donner sens à d'énormes quantités de données - les possibilités ne sont limitées que par notre imagination, et oui, notre espace disque !

Tutoriel Chroma : Améliorez votre chatbot avec le modèle Claude d'Anthropic