Cohere Command R e modelli Command R+

Per inviare richieste di inferenza a modelli Cohere Command R e Cohere Command R+ con InvokeModel o InvokeModelWithResponseStream (streaming), è necessario l’ID modello da utilizzare. Per ottenere l’ID modello, consulta Modelli di fondazione supportati in Amazon Bedrock.

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.

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_history: 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 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_queries_only: 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_tokens: 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.

Predefinito	Minimo	Massimo
0,3	0	1

p: Top P. Utilizza un valore più basso per ignorare le opzioni meno probabili.

Predefinito	Minimo	Massimo
0,75	0.01	0,99

k: Top K. Specifica il numero di scelte di token utilizzate dal modello per generare il token successivo.

Predefinito	Minimo	Massimo
0	0	500

prompt_truncation: 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_penalty: 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.

Predefinito	Minimo	Massimo
0	0	1

presence_penalty: 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.

Predefinito	Minimo	Massimo
0	0	1

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_prompt: 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 (senzatool_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 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.

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) nella documentazione di Cohere.
tools_results: 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 utilizzatool_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 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_sequences: elenco di sequenze di arresto. Dopo una sequenza di arresto, il modello smette di generare altri token.
raw_prompting: 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_id: identificatore univoco per il completamento della chat
text: risposta del modello all’input del messaggio di chat.
generation_id: 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_ids: 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_reason: 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_toxic: impossibile completare la generazione a causa di nostri filtri dei contenuti.
- error_limit: impossibile completare la generazione perché è stato raggiunto il limite di contesto del modello.
- error: impossibile completare la generazione a causa di un errore.
- user_cancel: impossibile completare la generazione perché è stata interrotta dall’utente.
- max_tokens: 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_calls: elenco di strumenti appropriati per le chiamate. Restituito solo se viene specificato il campo di input tools.

Per ulteriori informazioni, consulta 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.

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()

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Cohere Embed v3

Modelli DeepSeek