Cohere Command R+ : tutoriel complet pas à pas

Vous cherchez à développer vos connaissances en IA avec un projet concret ? Dans ce tutoriel, nous allons explorer Cohere Command R+, y compris comment y accéder en ligne et en local. Nous plongerons aussi dans les fonctionnalités clés de l’API Python Cohere et créerons un projet d’IA avec LangChain et Tavily.

La partie la plus enthousiasmante commence avec le projet. Si vous connaissez déjà les modèles Cohere et leurs capacités, vous pouvez passer directement à la section projet. Vous y apprendrez à construire un agent IA qui enchaîne plusieurs outils pour accomplir une tâche.

Si vous débutez en IA et souhaitez en savoir plus sur le domaine, envisagez le parcours AI Fundamentals. Vous y acquerrez des connaissances actionnables sur des sujets phares comme ChatGPT, les grands modèles de langage (LLM), l’IA générative, et plus encore.

Qu’est‑ce que Cohere Command R+ ?

Command R+ est le dernier LLM de Cohere, à l’état de l’art. Le modèle excelle dans les échanges conversationnels et les tâches à long contexte. Il est particulièrement optimisé pour les workflows complexes de Retrieval Augmented Generation (RAG) et l’utilisation d’outils en plusieurs étapes, ce qui en fait un puissant atout pour des applications à l’échelle entreprise.

Image de l’auteur

Fonctionnalités clés de Cohere Command R+

Voici quelques‑unes des fonctionnalités les plus pertinentes du modèle Command R+.

• Contexte étendu : le modèle réalise des tâches de langage avec une qualité supérieure et plus de fiabilité que les versions précédentes, grâce à une longueur de contexte allant jusqu’à 128 k tokens et une sortie maximale de 4 k tokens.
• Capacités multilingues : Command R+ a été entraîné sur un corpus varié dans de multiples langues, ce qui lui permet d’effectuer divers travaux de génération de texte. Il est optimisé pour l’anglais, le français, l’espagnol, l’italien, l’allemand, et d’autres langues. 
• Capacités interlinguistiques : le modèle gère des tâches interlingues, comme la traduction ou la réponse à des questions.
• Retrieval augmented generation : vous n’avez pas besoin de LangChain ou d’un autre framework IA pour faire du RAG avec Command R+. Il suffit de fournir des documents additionnels à la fonction de chat ; elle génère alors des réponses contextualisées avec des citations de sources. 
• Usage d’outils en plusieurs étapes : connectez le modèle à un outil de moteur de recherche ou créez votre propre outil pour interagir avec des bases de données et des API. Le modèle peut ainsi consulter plusieurs sources externes et fournir des réponses à jour et pertinentes.  

Pour approfondir votre compréhension des modèles Cohere, ne manquez pas le Cohere API Tutorial : Getting Started With Cohere Models.

Comment accéder à Cohere Command R+

Il existe plusieurs façons d’accéder aux modèles Cohere, la plupart gratuites. 

Vous pouvez utiliser le playground LLM en ligne ou télécharger le modèle en local et l’utiliser avec une application de chat. Vous pouvez également y accéder via l’API Cohere. Passons en revue chaque méthode.

Utiliser Cohere Command R+ en ligne

La manière la plus simple d’accéder à Cohere Command R+ en ligne est via le site HuggingChat. Il ne comporte pas de limitations, et vous pouvez le connecter à six outils disponibles pour différentes tâches, comme la génération d’images ou la recherche sur Internet.

1. Rendez‑vous sur https://huggingface.co/chat/.

2. Dans le panneau de gauche, cliquez sur « Models » pour ouvrir le menu des modèles, puis sélectionnez « c4ai-command-r-plus ».

Répertoire des modèles dans Hugging Chat. Source : HuggingChat

3. Saisissez votre requête : la réponse sera rapide et très précise.

Saisie de prompts dans Hugging Chat. Source : HuggingChat

Utiliser Cohere Command R+ en local

Vous pouvez utiliser Command R+ en local de deux manières : en téléchargeant le modèle sur votre machine ou en fournissant une clé API à l’application de chat Jan. 

Explorons la seconde option.

1. Téléchargez et installez Jan depuis le site https://jan.ai/.

2. Ouvrez le hub de modèles en cliquant sur le bouton Windows dans le panneau de gauche.

Répertoire des modèles dans l’application Jan

3. Pour accéder au modèle Command R+, tapez « pmysl/c4ai-command-r-plus-GGUF » dans la barre de recherche du hub des modèles.

• Notez qu’il vous faut plus de 30 Go de RAM pour télécharger le modèle Command R+.

4. Téléchargez et commencez à utiliser la version « Q4_K_M » du modèle (environ 31,24 Go).

Import du modèle depuis Hugging Face 

Utiliser Cohere Command R+ via l’API

Une autre façon d’utiliser le modèle Command R+ en local consiste à connecter l’API Cohere à l’application Jan. 

1. Accédez au site https://coral.cohere.com/ et connectez‑vous. 

2. Allez dans le « Dashboard ».

3. Dans le panneau de gauche, cliquez sur « API keys », puis faites défiler et cliquez sur « + Create Trial key ».

Génération de la clé d’essai API Cohere. Source : cohere.com

4. Après avoir généré la clé API Cohere, collez‑la dans la section « Model Provider ». Vous trouverez ce menu dans « Settings », rubrique « Cohere ».

Ajout de la clé API Cohere dans l’application Jan

5. Sélectionnez le modèle Command R+ via le menu « Thread » et, dans le panneau de droite, choisissez le modèle approprié.

Sélection du modèle dans l’application Jan

6. Commencez à soumettre vos prompts en veillant à activer « Stream ».

Utilisation de Cohere Command R plus dans l’application Jan

Premiers pas avec l’API Python Cohere

Dans cette section, vous apprendrez à configurer et utiliser l’API Python pour générer des réponses.

1. Installez le package Python Cohere avec pip.

pip install coherePropulsé par

2. Générez une nouvelle clé API Cohere. Vous pouvez suivre les étapes de la section « Utiliser Cohere Command R+ via l’API ».

Génération de la clé d’essai API Cohere. Source : cohere.com

3. Nous utiliserons DataLab de DataCamp comme environnement de développement. Pour configurer des variables d’environnement dans DataLab, suivez ces étapes :

1. 1. Allez sur DataLab et créez un nouveau notebook. Vous pouvez commencer gratuitement.
   2. Une fois le notebook créé, vous pouvez le renommer comme vous le souhaitez.
   3. Accédez à l’onglet « Environment », choisissez « Environment variables » puis cliquez sur « + Add » pour ajouter de nouvelles variables.
   4. Ajoutez une variable nommée « COHERE_API_KEY » et collez votre nouvelle clé API Cohere comme valeur. Comme nom de set, vous pouvez saisir « Cohere ».

 Ajout de variables d’environnement dans DataLab

4. Pour activer la variable d’environnement dans DataLab de DataCamp, ouvrez le menu des variables, cliquez sur les trois points à côté de « Cohere » puis sur « Connect ».

Connexion de la variable d’environnement Cohere dans DataLab

5. Dans votre notebook, initialisez ensuite le client Cohere en fournissant la clé API. Pour cela, importez la bibliothèque Cohere et créez un objet client avec votre clé.

import os
import cohere

cohere_api_key = os.environ["COHERE_API_KEY"]
co = cohere.Client(api_key=cohere_api_key)Propulsé par

6. Pour générer une réponse avec la fonction .chat(), indiquez le model et le message.

response = co.chat(
  model="command-r-plus",
  message="Please help me write an email to the angry boss, who thinks I made the changes to the data pipeline but didn't. It was James."
)

print(response.text) Propulsé par

Réponse du modèle à la requête fournie

La génération est à la fois rapide et très pertinente !

Dans la section suivante, nous explorerons diverses fonctionnalités de l’API Python Cohere. 

Explorer les fonctionnalités clés de l’API Python Command R+

Nous allons maintenant explorer l’API Python Cohere pour générer des réponses avec historique, diffuser les réponses en streaming et obtenir des sorties prédictibles. Nous effectuerons aussi du RAG, convertirons du texte en embeddings et affinerons le modèle sur un jeu de données personnalisé.

Génération de texte

Dans la section précédente, nous avons vu comment générer des réponses avec un simple .chat(). Nous allons maintenant lui passer des arguments supplémentaires : prompt système (preamble), chat_history, max_tokens et temperature.

response = co.chat(
    model="command-r-plus",
    preamble="You are a happy chatbot that puts a positive spin on everything.",
    chat_history=[
       {"role": "USER", "text": "Hey, my name is Abid!"},
       {"role": "CHATBOT", "text": "Hey Abid! How can I help you today?"},
    ],
    message="I can't swim?",
    max_tokens=150,
    temperature=0.7
)

print(response.text)Propulsé par

Réponse du modèle avec les arguments supplémentaires

Grâce à ces paramètres additionnels, le modèle a adapté sa réponse.

Streaming

Nous pouvons aussi diffuser la réponse en temps réel avec la fonction .chat_stream(). Elle génère des tokens au fil de l’eau, ce qui améliore la sensation de rapidité.

response = co.chat_stream(
    model="command-r-plus",
    message="Tell me something interesting about the galaxy?"
)

for event in response:
    if event.event_type == "text-generation":
      print(event.text, end="")
    elif event.event_type == "stream-end":
      print(event.finish_reason, end="")Propulsé par

Le modèle renvoie les tokens en temps réel

Sortie prédictible

La sortie prédictible est une fonctionnalité unique de Cohere. En définissant l’argument seed, on peut faire en sorte que le modèle génère la même réponse pour un même prompt.

Généralement, si vous posez deux fois la même question à un LLM, vous obtenez une réponse différente. En fixant le seed, vous garantissez des résultats cohérents et reproductibles, comme pour tout modèle de machine learning.

Dans l’exemple suivant, en fixant seed à 55, vous obtiendrez toujours « Matilda » en réponse.

res = co.chat(model="command-r", message="say a random name", seed=55)
print(res.text)Propulsé par

Sure! I will pick a random name for you. How about "Matilda"?Propulsé par

Pour vérifier, nous avons reposé exactement la même question avec le même seed. 

res = co.chat(model="command-r", message="say a random name", seed=55)
print(res.text)Propulsé par

Sure! I will pick a random name for you. How about "Matilda"?Propulsé par

Et le résultat est identique !

Retrieval augmented generation (RAG)

L’API Cohere propose une fonction intégrée pour réaliser du RAG. Il suffit de passer un argument documents à la fonction .chat(). Lors d’une question, elle effectue une recherche de similarité dans ces documents pour produire des réponses contextualisées.

Nous utiliserons des documents de recherche sur les anime comme exemple. Le format doit suivre l’exemple ci‑dessous : chaque document comporte les clés title et snippet.

anime = [
    {
        "title": "Naruto Popularity Analysis",
        "snippet": "Naruto's global success: massive manga sales, top anime ratings, extensive merchandise, and a dedicated fanbase. The series' impact on anime culture and its influence on subsequent shonen series is undeniable."
    },
    {
        "title": "One Piece Popularity Analysis",
        "snippet": "One Piece's record-breaking manga sales and its status as a long-running anime phenomenon highlight its popularity. The series' captivating story and characters have made it a staple in the anime community."
    },
    {
        "title": "Attack on Titan Popularity Analysis",
        "snippet": "Attack on Titan's intense storyline and high-quality animation have garnered a massive following. Its success in both manga and anime formats demonstrates its widespread appeal."
    },
    {
        "title": "My Hero Academia Popularity Analysis",
        "snippet": "My Hero Academia's rapid rise to fame is marked by its engaging characters and compelling plot. The series has achieved impressive manga sales and anime viewership."
    }
]
Propulsé par

Pour obtenir des réponses précises et contextuelles, nous passons les documents anime à l’argument documents de la fonction .chat().

response = co.chat(
    model="command-r-plus",
    message="Which Anime series have most engaging characters?",
    documents=anime,
)

print(response.text) Propulsé par

Some anime series with engaging characters include My Hero Academia and One Piece.Propulsé par

Comme vous le voyez, le modèle exploite les documents pour produire des réponses très exactes.

Si vous souhaitez savoir ce qui se passe en coulisses et comment la réponse est générée, vous pouvez simplement afficher tout l’objet response avec ses métadonnées.

responsePropulsé par

Observez la partie ChatCitation et comment la fonction .chat() de Cohere a utilisé des extraits des documents pour générer la réponse. 

Nous pouvons aussi connecter des outils et connecteurs à la fonction .chat(). Dans l’exemple suivant, nous relions un moteur de recherche Internet pour fournir une réponse actualisée.

response = co.chat(
    model="command-r-plus",
    message="Which Anime series have most engaging characters?",
    connectors=[{"id": "web-search"}],
)

print(response.text) Propulsé par

Here are some Anime series with engaging characters:
- Jujutsu Kaisen
- One Piece
- Naruto
- Dragon Ball Z
- Bleach
- Death Note
- Fullmetal Alchemist: Brotherhood
- Demon Slayer: Kimetsu no Yaiba
- Attack on Titan
- Mob Psycho 100
- Trigun
- My Hero Academia
- Cowboy Bebop
- Komi Can't Communicate
- Spy X FamilyPropulsé par

Ici, le modèle recherche l’information sur Internet, puis intègre ce contexte pour générer un résultat à jour et fiable.

Pour en savoir plus sur la force des LLM avec des mécanismes de recherche d’information efficaces, consultez le tutoriel Boost LLM Accuracy with Retrieval Augmented Generation (RAG) and Reranking.

Embeddings

Les embeddings de texte sont des représentations numériques qui capturent le sens sémantique, permettant des recherches de similarité et des analyses efficaces sur des données textuelles. 

Avec la fonction .embed() de Cohere, nous pouvons convertir du texte en vecteurs d’embedding pour des requêtes de recherche. Il suffit d’indiquer le nom du model, la liste de texts, l’input_type et les embedding_types.

texts = [ 'I love you', 'I hate you', 'Who are you?']  

response = co.embed(
  model='embed-english-v3.0',
  texts=texts, 
  input_type='search_query',
  embedding_types=['float']) 


embeddings = response.embeddings.float # All text embeddings 
print(embeddings[2][:5]) 
Propulsé par

[-0.00459671, -0.010803223, -0.048339844, -0.012306213, -0.019134521]Propulsé par

Cohere permet également de convertir des textes en plusieurs langues en embeddings. Pour cela, remplacez le modèle d’embedding par « embed-multilingual-v3.0 » et définissez l’input_type sur « classification ».

texts = [  
   'I love you', 'Te quiero', 'Ich liebe dich',  
   'Ti amo', 'Я тебя люблю', ' 我爱你 ',  
   '愛してる', 'أحبك', 'मैं तुमसे प्यार करता हूँ'  
]  

response = co.embed(
  model='embed-multilingual-v3.0',
  texts=texts, 
  input_type='classification',
  embedding_types=['float']) 

embeddings = response.embeddings.float # All text embeddings 
print(embeddings[2][:5]) Propulsé par

[-0.011756897, 0.0116119385, -0.005115509, 0.011657715, -0.001660347]Propulsé par

Fine‑tuning

Comme avec l’API OpenAI, l’API Cohere permet d’affiner le modèle sur un jeu de données personnalisé. Pour cela, on téléverse les données puis on lance la fonction de fine‑tuning. C’est aussi simple que ça. 

Pour notre exemple, nous allons générer deux jeux de données avec le modèle ChatGPT (GPT‑4o). Suivez le format JSONL indiqué ci‑dessous.

À partir des données générées, créez les fichiers JSONL « positive_bot_train » et « positive_bot_eval », puis indiquez leur emplacement à la fonction .datasets.create(). La fonction requiert également le name du dataset et le type de fine‑tuning.

my_dataset = co.datasets.create(
  name="Happy assistant",
  type="chat-finetune-input",
  data=open("./data/positive_bot_train.jsonl", "rb"),
  eval_data=open("./data/positive_bot_eval.jsonl", "rb")
)

result = co.wait(my_dataset)
print(result)Propulsé par

Comme on le voit, la fonction a validé le dataset et l’a téléversé sur le stockage cloud de Cohere.

Il ne reste plus qu’à transmettre le name du modèle, le base_type et le dataset_id à la fonction .finetuning.create_finetuned_model(), qui lancera le fine‑tuning dans le cloud. 

from cohere.finetuning import FinetunedModel, Settings, BaseModel

# start training a custom model using the dataset
finetuned_model = co.finetuning.create_finetuned_model(
  request=FinetunedModel(
    name="happy-chat-bot-model",
    settings=Settings(
      base_model=BaseModel(
        base_type="BASE_TYPE_CHAT",
      ),
      dataset_id=my_dataset.id,
    ),
  ),
)Propulsé par

Pour suivre la progression du fine‑tuning, rendez‑vous sur le tableau de bord Cohere et cliquez sur « Fine‑tuning » dans le panneau de gauche. 

Statut du fine‑tuning. Source : Models | Cohere

Le fine‑tuning et la génération du rapport d’évaluation peuvent prendre quelques minutes.

Résultats du fine‑tuning. Source : Fine-tuned Model - happy-chat-bot-model | Cohere

Une fois le modèle affiné, vous obtenez une vue d’ensemble des résultats. Comme on le voit ci‑dessus, la précision du modèle est assez faible. Pourquoi ? Nous ne lui avons fourni qu’un dataset de deux lignes. Pour améliorer la précision, utilisez des données réelles d’au moins 1 000 lignes.

Pour accéder à notre modèle affiné, nous pouvons passer son ID à la fonction .chat(), avec un preamble, un message et max_tokens.

Vous trouverez l’ID du modèle dans le dashboard : « Fine‑tuning », puis « YOUR MODELS », et copiez l’ID depuis la liste.

response = co.chat(
    model="8f34d596-b94e-4395-afad-1db35b2b0b53-ft",
    preamble="You are a happy chatbot that puts a positive spin on everything.",
    message="I burned my finger while barbecuing.",
    max_tokens=100
)

print(response.text)
Propulsé par

Ouch! That doesn't sound fun, but it's great that you're taking time to relax and enjoy some delicious grilled foods. Barbecuing is a wonderful way to spend time with friends and family, and it's an excellent opportunity to savor the little things in life. Remember to take care of your burn; it's a small price to pay for a fun day making delicious memories!Propulsé par

La réponse générée est plutôt convaincante !

Créer un projet IA avec Command R+

Nous allons maintenant construire un agent IA multi‑étapes en utilisant l’écosystème LangChain et le modèle Cohere Command R+.

Cette application IA partira de la requête de l’utilisateur pour chercher sur le web via l’API Tavily, puis générera du code Python. Elle utilisera ensuite Python REPL pour exécuter le code et renvoyer la visualisation demandée.

1. Installation des packages Python

Commençons par installer tous les packages nécessaires. Vous pouvez le faire dans un notebook DataLab.

%pip install --quiet langchain langchain_cohere langchain_experimentalPropulsé par

2. Configuration du modèle de chat Cohere

Nous utilisons ensuite l’API Python LangChain pour créer un client de chat en fournissant la clé API Cohere créée plus tôt. Nous utiliserons Command R+ comme modèle de langage de l’agent IA. 

import os
from langchain_cohere.chat_models import ChatCohere

cohere_api_key = os.environ["COHERE_API_KEY"]
chat = ChatCohere(model="command-r-plus", temperature=0.7, api_key=cohere_api_key)Propulsé par

3. Configuration de Tavily pour la recherche Internet

Inscrivez‑vous sur Tavily et copiez votre clé API. Tavily est une API de recherche Internet pour LLM et pipelines RAG.

Génération de la clé API Tavily. Source : Tavily AI

Pour créer l’outil de recherche Internet, fournissez la clé API que vous venez de générer comme variable d’environnement dans DataLab. Puis mettez à jour le name, la description et le schéma d’arguments (args_schema).

from langchain_community.tools.tavily_search import TavilySearchResults

internet_search = TavilySearchResults(api_key=os.environ['TAVILY_API_KEY'])
internet_search.name = "internet_search"
internet_search.description = "Returns a list of relevant documents from the internet."

from langchain_core.pydantic_v1 import BaseModel, Field

class TavilySearchInput(BaseModel):
    query: str = Field(description="Internet query engine.")

internet_search.args_schema = TavilySearchInputPropulsé par

4. Configuration de Python REPL

Créer un outil Python REPL est simple : fournissez à la classe Tool un objet Python REPL, un name et une description, puis adaptez le schéma d’arguments comme ci‑dessous.

from langchain.agents import Tool
from langchain_experimental.utilities import PythonREPL

python_repl = PythonREPL()
repl_tool = Tool(
    name="python_repl",
    description="Executes python code and returns the result.",
    func=python_repl.run,
)
repl_tool.name = "python_interpreter"

class ToolInput(BaseModel):
    code: str = Field(description="Python code execution.")

repl_tool.args_schema = ToolInputPropulsé par

5. Création et exécution de l’agent IA

Nous allons maintenant tout assembler pour créer l’agent multi‑étapes avec la fonction .create_cohere_react_agent(), le client Cohere, les outils et le gabarit de prompt. Pour exécuter notre agent, nous utiliserons la classe AgentExecutor en lui passant l’agent et les outils.

from langchain.agents import AgentExecutor
from langchain_cohere.react_multi_hop.agent import create_cohere_react_agent
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template("{input}")

agent = create_cohere_react_agent(
    llm=chat,
    tools=[internet_search, repl_tool],
    prompt=prompt,
)

agent_executor = AgentExecutor(agent=agent, tools=[internet_search, repl_tool], verbose=True)Propulsé par

6. Tester l’agent

Il ne reste plus qu’à utiliser agent_executor pour générer une visualisation. Dans notre cas, nous demandons à l’agent de collecter les dernières données sur Internet et de créer un diagramme circulaire.

response = agent_executor.invoke({
    "input": "Create a pie chart of the top 5 most used programming languages in 2024.",
})Propulsé par

Diagramme circulaire des langages de programmation les plus utilisés, créé par le modèle Cohere. Image de l’auteur

Le résultat est bluffant ! Le graphique a été généré avec les données les plus récentes du web.

Si vous rencontrez des difficultés pour exécuter le code de ce tutoriel, consultez l’espace DataLab Cohere Command R+ Tutorial, qui contient le code source, les jeux de données et les sorties.

Comme avec LangChain, vous pouvez utiliser LlamaIndex pour construire un agent IA multi‑étapes. Pour démarrer avec LlamaIndex, regardez la vidéo Retrieval Augmented Generation with LlamaIndex.

Conclusion

Le marché de l’IA s’accélère de nouveau ; maîtriser de nouveaux outils et API vous aidera à bâtir de meilleurs systèmes et à muscler votre portfolio. De plus, cela simplifiera votre flux de travail, certains frameworks IA prenant en charge l’essentiel des tâches avec seulement quelques lignes de code.

Dans ce tutoriel, nous avons découvert le modèle Cohere Command R+ et comment y accéder via Hugging Face chat, l’application Jan et l’API. Nous avons aussi parcouru l’API Python et appris à affiner le modèle pour générer des réponses personnalisées. Pour conclure, nous avons construit un véritable agent IA qui prend les requêtes utilisateur, cherche les données les plus récentes sur Internet et génère des visualisations avec Python REPL.

Pour approfondir la puissance des LLM, la génération de contenu à partir de prompts, l’extraction d’information et la création d’un moteur de recherche sémantique, regardez notre session code‑along sur using Large Language Models with the Cohere API.