CohereCommand Re Command R+ modelos

Você faz solicitações de inferência Cohere Command R e Cohere Command R+ modelos com InvokeModelou InvokeModelWithResponseStream (streaming). É necessário o ID do modelo que deseja usar. Para obter o ID do modelo, consulteIDs de modelo Amazon Bedrock.

dica

Para aplicativos de conversação, recomendamos que você use a API Converse. A API Converse fornece um conjunto unificado de parâmetros que funcionam em todos os modelos que oferecem suporte a mensagens. Para ter mais informações, consulte Use a API Converse.

Solicitação e reposta

Request

Os Cohere Command modelos têm os seguintes parâmetros de inferência.


{
    "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.

mensagem — (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 fornecer ao modelo um contexto de conversação para responder à mensagem do usuário.

Os campos a seguir são obrigatórios.
- role— O papel da mensagem. Os valores válidos são USER ouCHATBOT. tokens.
- message— Conteúdo de texto da mensagem.
Veja a seguir um exemplo de JSON 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"}
]
```
documentos — Uma lista de textos que o modelo pode citar para gerar uma resposta mais precisa. Cada documento é um dicionário de cadeias de caracteres. A geração resultante inclui citações que fazem referência a alguns desses documentos. Recomendamos que você mantenha a contagem total de palavras das sequências de caracteres no dicionário em menos de 300 palavras. Um _excludes campo (matriz de cadeias de caracteres) pode ser fornecido opcionalmente para omitir a exibição de alguns pares de valores-chave no modelo. Para obter mais informações, consulte o guia do Modo Documento na Cohere documentação.

Veja a seguir um exemplo de JSON para o documents campo.
```
"documents": [
{"title": "Tall penguins", "snippet": "Emperor penguins are the tallest."},
{"title": "Penguin habitats", "snippet": "Emperor penguins only live in Antarctica."}
]
```
search_queries_only — O padrão é. false Quandotrue, a resposta conterá apenas uma lista de consultas de pesquisa geradas, mas nenhuma pesquisa ocorrerá e nenhuma resposta do modelo para a do usuário message será gerada.
preâmbulo — Substitui o preâmbulo padrão para geração de consultas de pesquisa. Não tem efeito nas gerações de uso de ferramentas.
max_tokens — O número máximo de tokens que o modelo deve gerar como parte da resposta. Observe que definir um valor baixo pode resultar em gerações incompletas. A configuração max_tokens pode resultar em gerações incompletas ou inexistentes quando usada com os documents campos tools ou.

temperatura — Use um valor menor para diminuir a aleatoriedade na resposta. A aleatoriedade pode ser maximizada ainda mais aumentando o valor do p parâmetro.

Padrão	Mínimo	Máximo
0.3	0	1

p — Top P. Use um valor menor para ignorar as opções menos prováveis.

Padrão	Mínimo	Máximo
0.75	0,01	0,99

k — Top K. Especifique o número de opções de token que o modelo usa para gerar o próximo token.

Padrão	Mínimo	Máximo
0	0	500

prompt_truncation — O padrão é. OFF Determina como o prompt é construído. Com prompt_truncation definido comoAUTO_PRESERVE_ORDER, alguns elementos de chat_history e documents serão eliminados para criar 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 bate-papo serão preservados. Com prompt_truncation `definido comoOFF, nenhum elemento será descartado.

frequency_penalty — Usado para reduzir a repetitividade dos tokens gerados. Quanto maior o valor, mais forte é a penalidade aplicada aos tokens presentes anteriormente, proporcional a quantas vezes eles já apareceram no prompt ou na geração anterior.

Padrão	Mínimo	Máximo
0	0	1

presence_penalty — Usado para reduzir a repetitividade dos tokens gerados. Semelhante afrequency_penalty, exceto que essa penalidade é aplicada igualmente a todos os tokens que já apareceram, independentemente de suas frequências exatas.

Padrão	Mínimo	Máximo
0	0	1

seed — Se especificado, o back-end fará o possível para amostrar tokens de forma determinística, de forma que solicitações repetidas com a mesma semente e parâmetros retornem o mesmo resultado. No entanto, o determinismo não pode ser totalmente garantido.
return_prompt — Especifique true para retornar a solicitação completa que foi enviada ao modelo. O valor padrão é false. Na resposta, o prompt no prompt campo.
ferramentas — Uma lista de ferramentas (funções) disponíveis que o modelo pode sugerir invocar antes de produzir uma resposta de texto. Quando tools for passado (semtool_results), o text campo na resposta será "" e o tool_calls campo na resposta será preenchido com uma lista de chamadas de ferramentas que precisam ser feitas. Se nenhuma chamada precisar ser feita, a tool_calls matriz ficará vazia.

Para obter mais informações, consulte Uso de ferramentas na Cohere documentação.

dica
Recomendamos que você use a API Converse para integrar o uso da ferramenta ao seu aplicativo. Para ter mais informações, consulte Uso da ferramenta (chamada de função).

Veja a seguir um exemplo de JSON para o tools campo.
```
[
    {
        "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 ferramenta em uma única etapa (chamada de função) na Cohere documentação.
tools_results — Uma lista dos resultados das ferramentas de invocação recomendadas pelo modelo no turno de bate-papo anterior. Os resultados são usados para produzir uma resposta em texto e são referenciados nas citações. Ao usartool_results, também tools deve ser passado. Cada um tool_result contém informações sobre como foi invocado, bem como uma lista de saídas na forma de dicionários. A lógica de citação exclusiva e refinada do Cohere exige que a saída seja uma lista. Caso a saída seja apenas um item, por exemplo{"status": 200}, você ainda deve envolvê-la em uma lista.

Para obter mais informações, consulte Uso de ferramentas na Cohere documentação.

Veja a seguir um exemplo de JSON para o tools_results campo.
```
[
    {
        "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 é detectada, o modelo para de gerar mais tokens.
raw_prompting — Especifique true para enviar o usuário ao modelo sem nenhum message pré-processamento, caso 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 bate-papo
texto — A resposta do modelo à entrada da mensagem de bate-papo.
generation_id — Identificador exclusivo para conclusão do bate-papo, usado com o endpoint de feedback na plataforma da Cohere.
citações — 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.
- texto — O texto ao qual a citação pertence.
- document_ids — Uma matriz de IDs de documentos que correspondem aos documentos citados para o texto.
prompt — O prompt completo que foi enviado ao modelo. Especifique o return_prompt campo para retornar esse campo.
finish_reason — O motivo pelo qual o modelo parou de gerar saída. Pode ser qualquer um dos seguintes:
- completo — A conclusão atingiu o final do token de geração, certifique-se de que esse seja o motivo final para o melhor desempenho.
- error_toxic — A geração não pôde ser concluída devido aos nossos filtros de conteúdo.
- error_limit — A geração não pôde ser concluída porque o limite de contexto do modelo foi atingido.
- error — A geração não pôde ser concluída devido a um erro.
- user_cancel — A geração não pôde ser concluída porque foi interrompida pelo usuário.
- max_tokens — A geração não pôde ser concluída porque o usuário especificou um max_tokens limite na solicitação e esse limite foi atingido. Pode não resultar em melhor desempenho.
tool_calls — Uma lista de ferramentas apropriadas para chamadas. Retornado somente se você especificar o campo tools de entrada.

Para obter mais informações, consulte Uso de ferramentas na Cohere documentação.

dica
Recomendamos que você use a API Converse para integrar o uso da ferramenta ao seu aplicativo. Para ter mais informações, consulte Uso da ferramenta (chamada de função).

Veja a seguir um exemplo de JSON para o tool_calls campo.
```
[
        {
            "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á em version campo.
- billed_units— As unidades faturadas. Os valores possíveis são:
  - input_tokens— O número de tokens de entrada que foram cobrados.
  - output_tokens— O número de tokens de saída que foram cobrados.

Exemplo de código

Este exemplo mostra como chamar o CohereCommand Rmodelo.


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

CohereEmbedmodelos

MetaLlamamodelos