Cohere Command R e Command R+ modelos

Você faz solicitações de inferência para 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, consulteModelo Amazon Bedrock IDs.

dica

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

Solicitação e reposta

Request

A ferramenta Cohere Command os 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 JSON para o chat_history campo

  "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 de Documento no Cohere documentação.

  Veja a seguir um exemplo 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 no Cohere documentação.

  dica

  Recomendamos que você use o Converse API para integrar o uso da ferramenta ao seu aplicativo. Para obter mais informações, consulte Use uma ferramenta para concluir uma resposta do modelo Amazon Bedrock.

  Veja a seguir um exemplo 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) no 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 no Cohere documentação.

  Veja a seguir um exemplo 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 documentos IDs que corresponde 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 no Cohere documentação.

  dica

  Recomendamos que você use o Converse API para integrar o uso da ferramenta ao seu aplicativo. Para obter mais informações, consulte Use uma ferramenta para concluir uma resposta do modelo Amazon Bedrock.

  Veja a seguir um exemplo JSON para o tool_calls campo.

  [
          {
              "name": "top_song",
              "parameters": {
                  "sign": "WZPZ"
              }
          }
      ]
  

• meta — dados de API uso (só existem para streaming).

  • api_version— A API versão. 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 Cohere Command 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()