Cohere Command R+: una guida completa passo dopo passo

Vuoi ampliare le tue conoscenze di AI con un progetto pratico? In questo tutorial esploreremo Cohere Command R+, inclusi i modi per accedervi online e in locale. Vedremo anche le funzionalità chiave della Cohere Python API e costruiremo un progetto di AI usando LangChain e Tavily.

La parte più interessante inizia con il progetto. Se conosci già i modelli Cohere e le loro funzionalità, passa pure direttamente alla sezione del progetto. Lì imparerai a creare un agente AI che usa più strumenti in sequenza per completare un'attività.

Se sei alle prime armi con l'AI e vuoi approfondire l'argomento, valuta di seguire il percorso AI Fundamentals. Otterrai conoscenze operative sui temi più popolari dell'AI, come ChatGPT, Large Language Models (LLM), generative AI e altro ancora.

Che cos'è Cohere Command R+?

Command R+ è l'ultimo LLM di punta di Cohere. Il modello eccelle nelle interazioni conversazionali e nei task a lungo contesto. È particolarmente ottimizzato per workflow complessi di Retrieval Augmented Generation (RAG) e l'uso di strumenti multi-step, rendendolo uno strumento potente per applicazioni su scala enterprise.

Immagine dell'autore

Funzionalità chiave di Cohere Command R+

Ecco alcune delle funzionalità più rilevanti del modello Command R+.

• Contesto più lungo: il modello svolge task linguistici con qualità e affidabilità superiori rispetto ai modelli precedenti, con una lunghezza di contesto fino a 128k token e un output massimo di 4k token.
• Capacità multilingue: Command R+ è stato addestrato su un ampio corpus di testi in più lingue, il che gli consente di svolgere vari task di generazione di testo. È ottimizzato per inglese, francese, spagnolo, italiano, tedesco e altre lingue. 
• Capacità cross-lingua: il modello può eseguire task cross-lingua, come traduzione o risposta a domande.
• Retrieval Augmented Generation: non hai bisogno di LangChain o altri framework di AI per eseguire RAG con Command R+. Ti basta fornire documenti aggiuntivi alla funzione di chat e il modello genererà risposte contestualizzate con citazioni della fonte. 
• Uso di strumenti multi-step: collega il modello a uno strumento di motore di ricerca o crea il tuo tool per connetterti a database e API. Questo permette al modello di comunicare con più fonti esterne e generare risposte aggiornate e pertinenti alla query.  

Per approfondire i modelli Cohere, leggi il Tutorial Cohere API: primi passi con i modelli Cohere.

Come accedere a Cohere Command R+

Esistono diversi modi per accedere ai modelli Cohere, la maggior parte dei quali è gratuita. 

Puoi usare il playground LLM online oppure scaricare il modello in locale e utilizzarlo con un'app di chat. Inoltre, puoi accedervi anche tramite la Cohere API. Vediamo ciascuno di questi metodi.

Uso di Cohere Command R+ online

Il modo più semplice per accedere a Cohere Command R+ online è tramite il sito HuggingChat. Non ha limitazioni e puoi anche connetterlo con sei strumenti disponibili per attività diverse, come generazione di immagini o ricerca su internet.

1. Vai al sito https://huggingface.co/chat/.

2. Nel pannello di sinistra, clicca sul pulsante “Models” per accedere al menu dei modelli, quindi seleziona il modello “c4ai-command-r-plus”.

Directory dei modelli in Hugging Chat. Fonte immagine: HuggingChat

3. Inizia a scrivere la query e otterrai una risposta rapida e molto accurata.

Prompt in Hugging Chat. Fonte immagine: HuggingChat

Uso di Cohere Command R+ in locale

Puoi usare Command R+ in locale in due modi: scaricando il modello sulla tua macchina oppure fornendo una chiave API all'app di chat Jan. 

Esploriamo la seconda opzione.

1. Scarica e installa Jan dal sito https://jan.ai/.

2. Vai all'hub dei modelli cliccando il pulsante con la finestra nel pannello di sinistra.

Directory dei modelli nell'app Jan

3. Per accedere al modello Command R+, digita “pmysl/c4ai-command-r-plus-GGUF ” nella barra di ricerca dell'hub dei modelli.

• Nota: dovresti avere più di 30 GB di RAM nel tuo sistema per scaricare il modello Command R+.

4. Scarica e inizia a usare la versione “Q4_K_M” del modello, che pesa circa 31,24 GB.

Importazione del modello da Hugging Face 

Uso di Cohere Command R+ tramite API

Un altro modo per usare il modello Command R+ in locale è connettere la Cohere API all'app Jan. 

1. Vai su https://coral.cohere.com/ ed effettua l'accesso. 

2. Vai alla “Dashboard”.

3. Nel pannello di sinistra, clicca sul pulsante “API keys”, quindi scorri in basso e clicca su “+ Create Trail key.”

Generazione della trial API key di Cohere. Fonte: cohere.com

4. Dopo aver generato la chiave API di Cohere, incollala nella sezione “Model Provider”. Puoi accedere a questo menu andando su “Settings” e cercando “Cohere”.

Aggiunta della chiave Cohere API nell'app Jan

5. Seleziona il modello Command R+ andando nel menu “Thread” e, nel pannello di destra, scegli il modello adatto.

Selezione del modello nell'app Jan

6. Inizia a fare prompt e assicurati di usarlo con “Stream” abilitato.

Uso di Cohere Command R plus nell'app Jan

Primi passi con la Cohere Python API

In questa sezione imparerai a configurare e usare la Python API per generare la risposta.

1. Installa il pacchetto Python Cohere usando pip.

pip install cohere

2. Genera una nuova chiave API Cohere. Puoi seguire i passaggi nella sezione “Uso di Cohere Command R+ tramite API”.

Generazione della trial API key di Cohere. Fonte immagine: cohere.com

3. Useremo DataLab di DataCamp come ambiente di sviluppo. Per impostare le variabili d'ambiente in DataLab, segui questi passaggi:

1. 1. Vai su DataLab e crea un nuovo notebook. Puoi iniziare gratuitamente.
   2. Una volta creato il notebook, rinominalo come preferisci.
   3. Vai alla scheda “Environment”, seleziona “Environment variables” e clicca su “+ Add” per aggiungere nuove variabili d'ambiente.
   4. Aggiungi una nuova variabile d'ambiente chiamata “COHERE_API_KEY” e inserisci come valore la chiave API Cohere appena creata. Come nome del set, puoi inserire “Cohere”.

 Aggiunta di variabili d'ambiente in DataLab

4. Per attivare la variabile d'ambiente in DataLab di DataCamp, vai al menu delle variabili d'ambiente, clicca sui tre puntini accanto a “Cohere” e poi su “Connect”.

Connessione della variabile d'ambiente Cohere in DataLab

5. Ora, nel tuo notebook, inizializza il client Cohere fornendo la chiave API. Puoi farlo importando la libreria Cohere e creando un oggetto client con la tua chiave API.

import os
import cohere

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

6. Per generare una risposta usando la funzione .chat() fornisci il model name e il 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) 

Risposta del modello alla query fornita

La generazione della risposta dovrebbe essere rapida e altamente pertinente! 

Nella prossima sezione, esploreremo varie funzionalità della Cohere Python API. 

Esplorare le funzionalità chiave della Command R+ Python API

Ora esploreremo la Cohere Python API per generare risposte con cronologia, fare streaming delle risposte e ottenere output prevedibili. Eseguiremo anche RAG, convertiremo testo in embedding e faremo fine-tuning del modello su un dataset personalizzato.

Generazione di testo

Nella sezione precedente abbiamo visto come generare risposte usando una semplice funzione .chat(). Ora forniremo argomenti extra come system prompt (preamble), chat_history, max_tokens e 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)

Risposta del modello con gli argomenti aggiuntivi

In base agli argomenti aggiuntivi, il modello ha modificato la risposta.

Streaming

Possiamo anche fare lo streaming della risposta usando la funzione .chat_stream(). Questa funzione consente di generare risposte in tempo reale, producendo token man mano che sono disponibili, migliorando la percezione di velocità del modello.

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="")

Il modello restituisce token in tempo reale

Output prevedibile

L'output prevedibile è una caratteristica unica di Cohere. Impostando l'argomento seed, possiamo fare in modo che il modello generi la stessa risposta allo stesso prompt.

Di solito, quando poni due volte la stessa domanda a un LLM, riceverai una risposta diversa. Impostare il seed assicura risultati coerenti e riproducibili, come in qualsiasi modello di machine learning.

Nel seguente esempio, impostando l'argomento seed a 55, riceverai sempre "Matilda" come risposta.

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

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

Per testare la nostra teoria, abbiamo posto di nuovo al modello la stessa domanda con lo stesso seed. 

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

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

E ha prodotto lo stesso risultato!

Retrieval Augmented Generation (RAG)

La Cohere API offre una funzione integrata per eseguire il RAG. Dobbiamo solo fornire alla funzione .chat() un argomento documents. Alla domanda posta, eseguirà una ricerca di similarità sui documenti per generare risposte contestualizzate.

Useremo documenti di ricerca sugli anime come esempio. Il formato dei documenti dovrebbe essere simile all'esempio seguente. Ogni documento dovrebbe contenere le chiavi title e 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."
    }
]

Per generare risposte precise e contestuali, forniremo i documenti anime all'argomento documents nella funzione .chat().

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

print(response.text) 

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

Come vedi, il modello usa i documenti per generare risposte molto accurate.

Se vuoi capire cosa succede dietro le quinte e come il modello genera la risposta, puoi semplicemente stampare l'intero response con i metadati.

response

Nota la parte ChatCitation e come la funzione .chat() di Cohere abbia usato snippet dai documenti per generare la risposta. 

Possiamo anche collegare tool e connettori alla funzione .chat(). Nell'esempio seguente colleghiamo un motore di ricerca internet al modello per generare una risposta aggiornata.

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

print(response.text) 

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 Family

In questo caso, il modello cerca le informazioni su Internet e poi fornisce a se stesso il contesto per generare risultati aggiornati e accurati.

Puoi scoprire di più sui punti di forza degli LLM con meccanismi efficaci di information retrieval seguendo il tutorial Aumenta l'accuratezza degli LLM con Retrieval Augmented Generation (RAG) e Reranking.

Embedding

Gli embedding di testo sono rappresentazioni numeriche del testo che catturano il significato semantico, consentendo ricerche per similarità e analisi efficienti dei dati testuali. 

Con la funzione .embed() di Cohere, possiamo convertire il testo in vettori di embedding per le query di ricerca. Dobbiamo solo fornire alla funzione il nome del model, la lista di texts, input_type ed 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]) 

[-0.00459671, -0.010803223, -0.048339844, -0.012306213, -0.019134521]

Cohere ci consente anche di convertire in embedding testi in più lingue. Per farlo, dobbiamo cambiare il modello di embedding in “embed-multilingual-v3.0” e impostare input_type su “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]) 

[-0.011756897, 0.0116119385, -0.005115509, 0.011657715, -0.001660347]

Fine-tuning

Come con la OpenAI API, la Cohere API consente di fare fine-tuning del modello su un dataset personalizzato. Per farlo, carichiamo i dati ed eseguiamo la funzione di fine-tuning. È davvero semplice. 

Per il nostro esempio, genereremo due dataset personalizzati usando il modello ChatGPT (GPT-4o). Segui il formato del dataset mostrato sotto.

Usando i dati generati, crea i file JSONL “positive_bot_train” e “positive_bot_eval” e fornisci il percorso del file alla funzione .datasets.create(). La funzione richiede anche il name del dataset e il type di 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)

Come si vede, la funzione ha validato il dataset e lo ha caricato nello storage cloud di Cohere.

Ora dobbiamo solo fornire il name del modello, il base_type e il dataset_id alla funzione .finetuning.create_finetuned_model(), che avvierà il processo di fine-tuning nel 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,
    ),
  ),
)

Per visualizzare l'avanzamento del fine-tuning del modello, vai alla dashboard di Cohere e clicca su “Fine-tuning” nel pannello di sinistra. 

Stato del fine-tuning. Fonte: Models | Cohere

Possono volerci alcuni minuti per completare il fine-tuning del modello e generare il report di valutazione.

Risultati del fine-tuning. Fonte immagine: Fine-tuned Model - happy-chat-bot-model | Cohere

Una volta che il modello è stato fine-tunato, otteniamo una panoramica dei risultati. Come si vede nell'immagine sopra, l'accuratezza del modello è piuttosto bassa. Perché? Gli abbiamo fornito solo un dataset di due righe. Per migliorare l'accuratezza, prova a fornirgli dati reali di almeno 1000 righe.

Per accedere al nostro modello fine-tunato, possiamo fornire l'ID del modello alla funzione .chat(), insieme a un preamble, un message e max_tokens.

Puoi trovare l'ID del modello andando sulla dashboard, selezionando l'opzione “Fine-tuning”, poi "YOUR MODELS", e copiando l'ID dall'elenco dei modelli fine-tunati.

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)

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!

La risposta generata non è affatto male!

Creare un progetto AI con Command R+

Ora costruiremo un AI Agent multi-step usando l'ecosistema LangChain e il modello Cohere Command R+.

Questa applicazione AI prenderà la query dell'utente per cercare sul web usando la Tavily API e generare il codice Python. Poi userà il Python REPL per eseguire il codice e restituire la visualizzazione richiesta dall'utente.

1. Installazione dei pacchetti Python

Per prima cosa, dobbiamo installare tutti i pacchetti Python necessari. Possiamo farlo in un notebook DataLab.

%pip install --quiet langchain langchain_cohere langchain_experimental

2. Configurazione del modello di chat Cohere

Poi usiamo la LangChain Python API per creare un client di chat fornendo la chiave API Cohere creata in precedenza. Useremo Command R+ come modello linguistico nell'agente AI. 

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)

3. Configurazione di Tavily per la ricerca su Internet

Registrati su Tavily e copia la tua chiave API. Tavily è un'API di ricerca internet per LLM e pipeline RAG.

Generazione della chiave API Tavily. Fonte immagine: Tavily AI

Per creare lo strumento di ricerca su internet, fornisci la chiave API appena generata come variabile d'ambiente in DataLab. Poi aggiorna name, description e 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 = TavilySearchInput

4. Configurazione del Python REPL

Creare uno strumento Python REPL è semplice: fornisci alla classe Tool un oggetto Python REPL, un name e una description, e modifica lo schema degli argomenti come mostrato sotto.

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 = ToolInput

5. Creazione ed esecuzione dell'agente AI

Ora combineremo tutto per creare l'agente AI multi-step usando la funzione .create_cohere_react_agent(), il client del modello Cohere, gli strumenti e il prompt template. Per eseguire il nostro agente AI useremo la classe AgentExecutor fornendole l'oggetto agente e gli strumenti.

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)

6. Test dell'agente

Poi, usa semplicemente agent_executor per generare una visualizzazione. Nel nostro caso, abbiamo chiesto all'agente AI di raccogliere i dati più recenti da internet e creare un grafico a torta.

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

Grafico a torta dei linguaggi di programmazione principali creato dal modello Cohere. Immagine dell'autore

Il risultato è fantastico! Ha generato con successo il grafico a torta usando i dati più recenti da internet.

Se riscontri problemi nell'esecuzione del codice menzionato in questo tutorial, controlla lo spazio di lavoro DataLab Cohere Command R+ Tutorial, che contiene il codice sorgente, il dataset e gli output.

Come con LangChain, puoi usare LlamaIndex per costruire un agente AI multi-step. Per iniziare con LlamaIndex, guarda il video Retrieval Augmented Generation con LlamaIndex.

Conclusione

Il mercato dell'AI si sta riscaldando di nuovo e imparare nuovi strumenti e API ti aiuterà a costruire sistemi di AI migliori e a rafforzare il tuo portfolio. Inoltre, semplificherà il tuo workflow, dato che alcuni framework di AI gestiscono gran parte delle attività richiedendo solo poche righe di codice.

In questo tutorial abbiamo conosciuto il modello Cohere Command R+ e come accedervi tramite Hugging Face chat, l'app Jan e l'API. Abbiamo anche visto la Python API e come fare fine-tuning del modello per generare risposte personalizzate. Per concludere, abbiamo costruito un vero agente AI che prende le query degli utenti, cerca su internet i dati più recenti e genera visualizzazioni usando il Python REPL.

Per saperne di più sulla potenza degli LLM, e su come generare contenuti da prompt, estrarre informazioni dai documenti e costruire un motore di ricerca semantico, guarda la nostra sessione code-along su uso dei Large Language Models con la Cohere API.