Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Cohere Command R e modelli Command R\$1
Per inviare richieste di inferenza a modelli Cohere Command R e Cohere Command R\$1 con [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html) o [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html) (streaming), è necessario l’ID modello da utilizzare. Per ottenere l’ID modello, consulta [Modelli di fondazione supportati in Amazon Bedrock](models-supported.md).
**Suggerimento**
Per le applicazioni conversazionali, consigliamo di utilizzare l’API Converse. L’API Converse fornisce un set unificato di parametri che funzionano su tutti i modelli che supportano i messaggi. Per ulteriori informazioni, consultate [Avvio di una conversazione con le operazioni dell’API Converse](conversation-inference.md).
**Topics**
+ [Richiesta e risposta](#model-parameters-cohere-command-request-response)
+ [Esempio di codice](#api-inference-examples-cohere-command-r)
## Richiesta e risposta
------
#### [ Request ]
I modelli Cohere Command hanno i seguenti parametri di inferenza.
```
{
"message": string,
"chat_history": [
{
"role":"USER or CHATBOT",
"message": string
}
],
"documents": [
{"title": string, "snippet": string},
],
"search_queries_only" : boolean,
"preamble" : string,
"max_tokens": int,
"temperature": float,
"p": float,
"k": float,
"prompt_truncation" : string,
"frequency_penalty" : float,
"presence_penalty" : float,
"seed" : int,
"return_prompt" : boolean,
"tools" : [
{
"name": string,
"description": string,
"parameter_definitions": {
"parameter name": {
"description": string,
"type": string,
"required": boolean
}
}
}
],
"tool_results" : [
{
"call": {
"name": string,
"parameters": {
"parameter name": string
}
},
"outputs": [
{
"text": string
}
]
}
],
"stop_sequences": [string],
"raw_prompting" : boolean
}
```
I seguenti parametri sono obbligatori.
+ **message**: (obbligatorio) input di testo a cui il modello deve rispondere.
I seguenti parametri sono facoltativi.
+ **chat\$1history**: elenco di messaggi precedenti tra l’utente e il modello, destinato a fornire al modello un contesto conversazionale per rispondere al messaggio dell’utente.
I seguenti campi sono obbligatori.
+ `role`: il ruolo del messaggio. I valori validi sono i token `USER` o `CHATBOT`.
+ `message`: contenuti di testo del messaggio.
Di seguito è riportato un esempio di JSON per il campo `chat_history`.
```
"chat_history": [
{"role": "USER", "message": "Who discovered gravity?"},
{"role": "CHATBOT", "message": "The man who is widely credited with discovering gravity is Sir Isaac Newton"}
]
```
+ **documents**: elenco di testi che il modello può citare per generare una risposta più accurata. Ogni documento è un dizionario di stringhe. La generazione risultante include citazioni che fanno riferimento ad alcuni di questi documenti. È consigliabile mantenere il numero totale di parole delle stringhe nel dizionario inferiore a 300. Facoltativamente è possibile specificare un campo `_excludes` (array di stringhe) per fare in modo che alcune coppie chiave-valore non vengano mostrate al modello. Per ulteriori informazioni sui documenti, consultare la guida [Document Mode](https://docs.cohere.com/docs/retrieval-augmented-generation-rag#document-mode) nella documentazione di Cohere.
Di seguito è riportato un esempio di JSON per il campo `documents`.
```
"documents": [
{"title": "Tall penguins", "snippet": "Emperor penguins are the tallest."},
{"title": "Penguin habitats", "snippet": "Emperor penguins only live in Antarctica."}
]
```
+ **search\$1queries\$1only**: `false` per impostazione predefinita. Se è `true`, la risposta contiene solo un elenco di query di ricerca generate, ma non viene effettuata alcuna ricerca né viene generata alcuna risposta dal modello al `message` dell’utente.
+ **preamble**: sostituisce il preambolo predefinito per la generazione delle query di ricerca. Non ha alcun effetto sulle generazioni di utilizzo degli strumenti.
+ **max\$1tokens**: numero massimo di token che il modello deve generare come parte della risposta. Tieni presente che l’impostazione di un valore basso può comportare generazioni incomplete. L’impostazione `max_tokens` può risultare in una generazione incompleta o assente se utilizzata con i campi `tools` o `documents`.
+ **temperature**: utilizza un valore più basso per ridurre la randomizzazione nella risposta. La randomizzazione può essere ulteriormente massimizzata aumentando il valore del parametro `p`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **p**: Top P. Utilizza un valore più basso per ignorare le opzioni meno probabili.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **k**: Top K. Specifica il numero di scelte di token utilizzate dal modello per generare il token successivo.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **prompt\$1truncation**: `OFF` per impostazione predefinita. Determina come viene creato il prompt. Con `prompt_truncation` impostato su `AUTO_PRESERVE_ORDER`, alcuni elementi di `chat_history` e `documents` verranno eliminati per creare un prompt che rientri nel limite di lunghezza del contesto del modello. Durante questo processo, l’ordine dei documenti e la cronologia delle chat verranno preservati. Con `prompt_truncation` `impostato su `OFF`, nessun elemento viene eliminato.
+ **frequency\$1penalty**: utilizzato per ridurre la ripetitività dei token generati. Più alto è il valore, più forte è la penalità applicata ai token presenti in precedenza, proporzionalmente al numero di volte in cui sono già apparsi nel prompt o nella generazione precedente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **presence\$1penalty**: utilizzato per ridurre la ripetitività dei token generati. Simile a `frequency_penalty`, tranne per il fatto che questa penalità viene applicata allo stesso modo a tutti i token che sono già apparsi, indipendentemente dalle loro frequenze esatte.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **seed**: se specificato, il backend fa del suo meglio per campionare i token in modo deterministico, in modo tale che le richieste ripetute con lo stesso seme e gli stessi parametri restituiscano lo stesso risultato. Tuttavia, il determinismo non può essere totalmente garantito.
+ **return\$1prompt**: specificare `true` per restituire il prompt completo inviato al modello. Il valore predefinito è `false`. Nella risposta, il prompt nel campo `prompt`.
+ **tools**: elenco di strumenti (funzioni) disponibili che il modello può suggerire di invocare prima di produrre una risposta in formato testo. Quando `tools` viene specificato (senza`tool_results`), il campo `text` nella risposta è `""` e il campo `tool_calls` nella risposta viene compilato con un elenco di chiamate allo strumento da effettuare. Se non è necessario effettuare chiamate, l’array `tool_calls` è vuoto.
Per ulteriori informazioni, consulta [Tool Use](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
**Suggerimento**
È consigliabile utilizzare l’API Converse per integrare l’utilizzo dello strumento nell’applicazione. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
Di seguito è riportato un esempio di JSON per il campo `tools`.
```
[
{
"name": "top_song",
"description": "Get the most popular song played on a radio station.",
"parameter_definitions": {
"sign": {
"description": "The call sign for the radio station for which you want the most popular song. Example calls signs are WZPZ and WKRP.",
"type": "str",
"required": true
}
}
}
]
```
Per ulteriori informazioni, consulta [Single-Step Tool Use (Function Calling)](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
+ **tools\$1results**: elenco di risultati derivanti dall’invocazione degli strumenti consigliati dal modello nel turno di chat precedente. I risultati vengono utilizzati per produrre una risposta in formato testo e sono menzionati nelle citazioni. Se si utilizza`tool_results`, è necessario specificare anche `tools`. Ogni `tool_result` contiene informazioni su come è stato invocato, oltre a un elenco di output sotto forma di dizionari. L’esclusiva logica di citazione granulare di Cohere richiede che l’output sia un elenco. Nel caso in cui l’output sia solo un elemento, ad esempio `{"status": 200}`, deve comunque essere inserirlo in un elenco.
Per ulteriori informazioni, consulta [Tool Use](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
Di seguito è riportato un esempio di JSON per il campo `tools_results`.
```
[
{
"call": {
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
},
"outputs": [
{
"song": "Elemental Hotel"
}
]
}
]
```
+ **stop\$1sequences**: elenco di sequenze di arresto. Dopo una sequenza di arresto, il modello smette di generare altri token.
+ **raw\$1prompting**: specificare `true` per inviare il `message` dell’utente al modello senza alcuna preelaborazione, altrimenti false.
------
#### [ Response ]
I possibili campi per la risposta sono:
```
{
"response_id": string,
"text": string,
"generation_id": string,
"citations": [
{
"start": int,
"end": int,
"text": "string",
"document_ids": [
"string"
]
}
],
"finish_reason": string,
"tool_calls": [
{
"name": string,
"parameters": {
"parameter name": string
}
}
],
{
"meta": {
"api_version": {
"version": string
},
"billed_units": {
"input_tokens": int,
"output_tokens": int
}
}
}
```
+ **response\$1id**: identificatore univoco per il completamento della chat
+ **text**: risposta del modello all’input del messaggio di chat.
+ **generation\$1id**: identificatore univoco per il completamento della chat, utilizzato con l’endpoint Feedback sulla piattaforma di Cohere.
+ **citations**: array di citazioni in linea e metadati associati per la risposta generata. Contiene i seguenti campi:
+ **start**: indice da cui inizia la citazione, a partire da 0.
+ **fine**: indice dopo il quale termina la citazione, a partire da 0.
+ **text**: testo a cui si riferisce la citazione.
+ **document\$1ids**: array di ID documento corrispondenti ai documenti citati per il testo.
+ **prompt**: prompt completo inviato al modello. Specificare il campo `return_prompt` campo per restituirlo.
+ **finish\$1reason**: motivo per cui il modello ha smesso di generare output. Può essere uno dei seguenti:
+ **complete**: la generazione ha raggiunto il limite massimo di token. Assicurarsi che sia il motivo della conclusione per ottenere le prestazioni migliori.
+ **error\$1toxic**: impossibile completare la generazione a causa di nostri filtri dei contenuti.
+ **error\$1limit**: impossibile completare la generazione perché è stato raggiunto il limite di contesto del modello.
+ **error**: impossibile completare la generazione a causa di un errore.
+ **user\$1cancel**: impossibile completare la generazione perché è stata interrotta dall’utente.
+ **max\$1tokens**: impossibile completare la generazione perché l’utente ha specificato un limite `max_tokens` nella richiesta e questo limite è stato raggiunto. Potrebbe non garantire le prestazioni migliori.
+ **tool\$1calls**: elenco di strumenti appropriati per le chiamate. Restituito solo se viene specificato il campo di input `tools`.
Per ulteriori informazioni, consulta [Tool Use](https://docs.cohere.com/docs/tool-use) nella documentazione di Cohere.
**Suggerimento**
È consigliabile utilizzare l’API Converse per integrare l’utilizzo dello strumento nell’applicazione. Per ulteriori informazioni, consulta [Utilizzo di uno strumento per completare una risposta al modello Amazon Bedrock](tool-use.md).
Di seguito è riportato un esempio di JSON per il campo `tool_calls`.
```
[
{
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
}
]
```
+ **meta**: dati sull’utilizzo dell’API (esistono solo per lo streaming).
+ `api_version`: versione dell’API. La versione è nel campo `version`.
+ `billed_units`: unità fatturate. I valori possibili sono:
+ `input_tokens`: numero di token di input fatturati.
+ `output_tokens`: numero di token di output fatturati.
------
## Esempio di codice
Questo esempio mostra come chiamare il modello *Cohere Command R*.
```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
Shows how to use the Cohere Command R model.
"""
import json
import logging
import boto3
from botocore.exceptions import ClientError
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
def generate_text(model_id, body):
"""
Generate text using a Cohere Command R model.
Args:
model_id (str): The model ID to use.
body (str) : The reqest body to use.
Returns:
dict: The response from the model.
"""
logger.info("Generating text with Cohere model %s", model_id)
bedrock = boto3.client(service_name='bedrock-runtime')
response = bedrock.invoke_model(
body=body,
modelId=model_id
)
logger.info(
"Successfully generated text with Cohere Command R model %s", model_id)
return response
def main():
"""
Entrypoint for Cohere example.
"""
logging.basicConfig(level=logging.INFO,
format="%(levelname)s: %(message)s")
model_id = 'cohere.command-r-v1:0'
chat_history = [
{"role": "USER", "message": "What is an interesting new role in AI if I don't have an ML background?"},
{"role": "CHATBOT", "message": "You could explore being a prompt engineer!"}
]
message = "What are some skills I should have?"
try:
body = json.dumps({
"message": message,
"chat_history": chat_history,
"max_tokens": 2000,
"temperature": 0.6,
"p": 0.5,
"k": 250
})
response = generate_text(model_id=model_id,
body=body)
response_body = json.loads(response.get('body').read())
response_chat_history = response_body.get('chat_history')
print('Chat history\n------------')
for response_message in response_chat_history:
if 'message' in response_message:
print(f"Role: {response_message['role']}")
print(f"Message: {response_message['message']}\n")
print("Generated text\n--------------")
print(f"Stop reason: {response_body['finish_reason']}")
print(f"Response text: \n{response_body['text']}")
except ClientError as err:
message = err.response["Error"]["Message"]
logger.error("A client error occurred: %s", message)
print("A client error occured: " +
format(message))
else:
print(f"Finished generating text with Cohere model {model_id}.")
if __name__ == "__main__":
main()
```