As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Cohere Comando R and Command R\+ Modelos da
Você faz solicitações de inferência Cohere Command R e Cohere Command R\+ modelos com [InvokeModel](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html)ou [InvokeModelWithResponseStream](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModelWithResponseStream.html)(streaming). É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulte [Modelos de base compatíveis no Amazon Bedrock](models-supported.md).
**dica**
Para aplicações de conversação, é recomendável usar a API Converse. A API Converse oferece um conjunto unificado de parâmetros que funcionam em todos os modelos que permitem mensagens. Para obter mais informações, consulte [Inferência usando a API Converse](conversation-inference.md).
**Topics**
+ [Solicitação e reposta](#model-parameters-cohere-command-request-response)
+ [Exemplo de código](#api-inference-examples-cohere-command-r)
## Solicitação e reposta
------
#### [ Request ]
Os modelos Command da Cohere têm os parâmetros de inferência a seguir.
```
{
"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
}
```
Veja a seguir os parâmetros necessários.
+ **message**: (obrigatório) entrada de texto para o modelo responder.
Veja a seguir os parâmetros opcionais.
+ **chat\_history**: uma lista de mensagens anteriores entre o usuário e o modelo, com o objetivo de oferecer contexto conversacional ao modelo para responder à mensagem do usuário.
Estes campos são obrigatórios.
+ `role`: o perfil da mensagem. Os valores válidos são tokens `USER` ou `CHATBOT`.
+ `message`: o conteúdo do texto da mensagem.
Este é um JSON de exemplo para o 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**: uma lista de textos que o modelo pode citar para gerar uma resposta mais precisa. Cada documento é um dicionário de string-string. A geração resultante inclui citações que fazem referência a alguns desses documentos. É recomendável manter a contagem total de palavras das strings no dicionário abaixo de 300. Um campo `_excludes` (matriz de strings) pode ser fornecido para omitir a exibição de alguns pares de chave-valor no modelo. Para obter mais informações, consulte [Document Mode guide](https://docs.cohere.com/docs/retrieval-augmented-generation-rag#document-mode) na documentação da Cohere.
Este é um JSON de exemplo para o 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**: assume `false` como padrão. Quando `true`, a resposta só conterá uma lista de consultas de pesquisa geradas, mas nenhuma pesquisa ocorrerá e nenhuma resposta do modelo para a `message` do usuário será gerada.
+ **preamble**: substitui o preâmbulo padrão para geração das consultas de pesquisa. Não tem efeito sobre as gerações de uso de ferramentas.
+ **max\_tokens**: o número máximo de tokens que o modelo deve gerar como parte da resposta. A definição de um valor baixo pode acarretar gerações incompletas. A definição de `max_tokens` pode acarretar gerações incompletas ou inexistentes quando usado com os campos `tools` ou `documents`.
+ **temperature**: use um valor menor para reduzir a aleatoriedade na resposta. A randomização pode ser maximizada ainda mais aumentando o valor do parâmetro `p`.
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **P**: Top P. Use um valor menor para ignorar opções menos prováveis.
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **k**: Top K. Especifique o número de opções de token que o modelo usa para gerar o próximo token.
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **prompt\_truncation**: assume `OFF` como padrão. Determina como o prompt é construído. Com `prompt_truncation` definido como `AUTO_PRESERVE_ORDER`, alguns elementos de `chat_history` e `documents` serão descartados para construir um prompt que se encaixe no limite de comprimento do contexto do modelo. Durante esse processo, a ordem dos documentos e o histórico do chat serão preservados. Com `prompt_truncation` definido como `OFF`, nenhum elemento será descartado.
+ **frequency\_penalty**: usado para reduzir a repetitividade dos tokens gerados. Quanto maior for o valor, mais forte será a penalidade aplicada aos tokens presentes anteriormente, proporcional a quantas vezes eles já apareceram no prompt ou na geração anterior.
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **presence\_penalty**: usado para reduzir a repetitividade dos tokens gerados. Semelhante a `frequency_penalty`, exceto por essa penalidade ser aplicada igualmente a todos os tokens que já apareceram, independentemente das frequências exatas.
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/bedrock/latest/userguide/model-parameters-cohere-command-r-plus.html)
+ **seed**: se especificado, o backend fará o possível para amostrar tokens de maneira determinística, de modo que solicitações repetidas com a semente e os parâmetros iguais retornem o mesmo resultado. No entanto, o determinismo não pode ser totalmente garantido.
+ **return\_prompt**: especifique `true` para retornar o prompt completo que foi enviado ao modelo. O valor padrão é `false`. Na resposta, o prompt no campo `prompt`.
+ **tools**: uma lista de ferramentas (funções) disponíveis que o modelo pode sugerir fazendo uma invocação antes de produzir uma resposta de texto. Quando `tools` for passado (sem `tool_results`), o campo `text` na resposta será `""` e o campo `tool_calls` na resposta será preenchido com uma lista de chamadas de ferramenta que precisam ser feitas. Se nenhuma chamada precisar ser feita, a matriz `tool_calls` permanecerá vazia.
Para obter mais informações, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) na documentação da Cohere.
**dica**
É recomendável usar a API Converse para integrar o uso de ferramentas à aplicação. Para obter mais informações, consulte [Use uma ferramenta para concluir uma resposta do modelo do Amazon Bedrock](tool-use.md).
Este é um JSON de exemplo para o 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
}
}
}
]
```
Para obter mais informações, consulte [Uso da Single-Step ferramenta (chamada de função)](https://docs.cohere.com/docs/tool-use) na Cohere documentação.
+ **tools\_results**: uma lista de resultados das ferramentas de invocação recomendadas pelo modelo no turno de chat anterior. Os resultados são usados para produzir uma resposta textual e são referidos em citações. Durante o uso de `tool_results`, `tools` também deve ser passado. Cada `tool_result` contém informações sobre como foi invocado, bem como uma lista de saídas em forma de dicionários. A lógica de citação exclusiva e refinada do Cohere exige que a saída seja uma lista. Se a saída for apenas um item, como `{"status": 200}`, você ainda deverá envolvê-la em uma lista.
Para obter mais informações, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) na documentação da Cohere.
Este é um JSON de exemplo para o campo `tools_results`.
```
[
{
"call": {
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
},
"outputs": [
{
"song": "Elemental Hotel"
}
]
}
]
```
+ **stop\_sequences**: uma lista de sequências de parada. Depois que uma sequência de parada for detectada, o modelo deixará de gerar mais tokens.
+ **raw\_prompting**: especifique `true` para enviar `message` do usuário ao modelo sem nenhum pré-processamento; do contrário, falso.
------
#### [ Response ]
A resposta tem os campos possíveis a seguir:
```
{
"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**: identificador exclusivo para conclusão do chat
+ **text**: a resposta do modelo para entrada da mensagem de chat.
+ **generation\_id**: identificador exclusivo para conclusão do chat, usado com o endpoint de feedback na plataforma da Cohere.
+ **citations**: uma matriz de citações em linha e metadados associados para a resposta gerada. Contém os seguintes campos:
+ **start**: o índice no qual a citação começa, começando em 0.
+ **end**: o índice após o qual a citação termina, começando em 0.
+ **text**: o texto ao qual a citação pertence.
+ **document\_ids**: uma matriz de IDs de documento que correspondem aos documentos citados para o texto.
+ **prompt**: o prompt completo que foi enviado ao modelo. Especifique o campo `return_prompt` para retorná-lo.
+ **finish\_reason**: o motivo pelo qual o modelo deixou de gerar saída. Pode ser qualquer um dos seguintes:
+ **complete**: a conclusão atingiu o final do token de geração; verifique se esse é o motivo final do melhor desempenho.
+ **error\_toxic**: não foi possível concluir a geração por causa de nossos filtros de conteúdo.
+ **error\_limit**: não foi possível concluir a geração porque o limite de contexto do modelo foi atingido.
+ **error**: não foi possível concluir a geração por causa de um erro.
+ **user\_cancel**: não foi possível concluir a geração porque ela foi interrompida pelo usuário.
+ **max\_tokens**: não foi possível concluir a geração porque o usuário especificou um limite `max_tokens` na solicitação e esse limite foi atingido. Isso talvez não acarrete o melhor desempenho.
+ **tool\_calls**: uma lista de ferramentas indicadas para chamadas. Só retornado caso você especifique o campo de entrada `tools`.
Para obter mais informações, consulte [Tool Use](https://docs.cohere.com/docs/tool-use) na documentação da Cohere.
**dica**
É recomendável usar a API Converse para integrar o uso de ferramentas à aplicação. Para obter mais informações, consulte [Use uma ferramenta para concluir uma resposta do modelo do Amazon Bedrock](tool-use.md).
Este é um JSON de exemplo para o campo `tool_calls`.
```
[
{
"name": "top_song",
"parameters": {
"sign": "WZPZ"
}
}
]
```
+ **meta**: dados de uso da API (só existem para streaming).
+ `api_version`: a versão da API. A versão está no campo `version`.
+ `billed_units`: as unidades faturadas. Os valores possíveis são:
+ `input_tokens`: o número dos tokens de entrada faturados.
+ `output_tokens`: o número dos tokens de saída faturados.
------
## Exemplo de código
Este exemplo mostra como chamar o modelo *Command R da Cohere*.
```
# 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()
```