Como usar modelos de chat do Comando Cohere

Importante

Os itens marcados (versão prévia) neste artigo estão atualmente em versão prévia pública. Essa versão prévia é fornecida sem um contrato de nível de serviço e não recomendamos isso para cargas de trabalho de produção. Alguns recursos podem não ter suporte ou podem ter restrição de recursos. Para obter mais informações, consulte Termos de Uso Complementares de Versões Prévias do Microsoft Azure.

Neste artigo, você aprenderá sobre os modelos de chat do Comando Cohere e como usá-los. A família de modelos Cohere inclui vários modelos otimizados para diferentes casos de uso, incluindo preenchimentos de chat, inserções e reclassificação. Os modelos do Cohere são otimizados para vários casos de uso que incluem raciocínio, resumo e resposta às perguntas.

Importante

Os modelos que estão em versão prévia são marcados como versão prévia em seus cartões de modelo no catálogo de modelos.

Modelos de chat do Comando Cohere

Os modelos de chat do Comando Cohere incluem os seguintes modelos:

Comando Cohere R+ 08-2024

O Comando R+ 08-2024 é um grande modelo de linguagem generativo e otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

É recomendável usar o Comando R+ 08-2024 para os fluxos de trabalho que se baseiam na funcionalidade de geração aumentada de recuperação complexa (RAG), no uso de ferramentas de várias etapas (agentes) e em saídas estruturadas.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus-08-2024

Comando Cohere R 08-2024

O Comando R 08-2024 é um grande modelo de linguagem otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-08-2024

Comando Cohere R+

O Comando R+ é um modelo de linguagem grande generativo otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Recomendamos usar o Comando R+ para os fluxos de trabalho que se baseiam na funcionalidade complexa de RAG (geração aumentada de recuperação) e no uso de ferramentas de várias etapas (agentes).

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus

Comando Cohere R

O Comando R é um modelo de linguagem grande otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R dá suporte a um comprimento de contexto de 128 K.

O Comando R é ótimo para tarefas de uso de RAG (geração aumentada de recuperação) mais simples e de uma única etapa. Também é ótimo para uso em aplicativos em que o preço é uma questão central.

Os seguintes modelos estão disponíveis:

• Cohere-command-r

Dica

Além disso, o Cohere dá suporte ao uso de uma API personalizada para usar com recursos específicos do modelo. Para usar a API específica do provedor de modelos, verifique a documentação do Cohere ou veja a seção de exemplos de inferência para exemplo de código.

Pré-requisitos

Para usar modelos de chat do Comando Cohere com o Estúdio de IA do Azure, você precisa dos seguintes pré-requisitos:

Uma implantação de modelo

Implantação em APIs sem servidor

Os modelos de chat do Comando Cohere podem ser implantados em pontos de extremidade de API sem servidor com cobrança de pagamento conforme o uso. Esse tipo de implantação fornece uma maneira de consumir modelos como uma API sem hospedá-los em sua assinatura, ao mesmo tempo que mantém a segurança empresarial e a conformidade que as organizações precisam.

A implantação em um ponto de extremidade de API sem servidor não exige o uso de cotas da sua assinatura. Se ainda não estiver implantado, use o Estúdio de IA do Azure, o SDK do Azure Machine Learning para Python, a CLI do Azure ou os modelos do ARM para implantar o modelo como uma API sem servidor.

Como implantar o modelo em pontos de extremidade de API sem servidor

O pacote de inferência instalado

Você pode consumir previsões desse modelo usando o pacote azure-ai-inference com Python. Para instalar esse pacote, você precisa atender aos seguintes pré-requisitos:

• Python 3.8 ou posterior instalado, incluindo o pip.
• O URL do ponto de extremidade. Para criar a biblioteca de clientes, você precisa transmitir o URL do ponto de extremidade. O URL do ponto de extremidade tem o formulário https://your-host-name.your-azure-region.inference.ai.azure.com, em que your-host-name é o nome de host exclusivo da implantação do modelo e your-azure-region é a região do Azure em que o modelo é implantado (por exemplo, eastus2).
• Dependendo da sua preferência de autenticação e implantação de modelos, você precisará de uma chave para autenticação no serviço ou de credenciais do Microsoft Entra ID. A chave é uma cadeia de caracteres de 32 caracteres.

Depois de atender aos pré-requisitos, instale o pacote de inferência da IA do Azure com o seguinte comando:

pip install azure-ai-inference

Saiba mais sobre o Pacote de inferência da IA do Azure e referências.

Trabalhar com conclusões de chat

Nesta seção, você usa a API de inferência de modelo da IA do Azure com um modelo de conclusões para chat.

Dica

A API de inferência do modelo de IA do Azure permite conversar com a maioria dos modelos implantados no Estúdio de IA do Azure com o mesmo código e estrutura, incluindo modelos de chat do Comando Cohere.

Criar um cliente para consumir o modelo

Primeiro, crie o cliente para consumir o modelo. O código a seguir usa um URL de ponto de extremidade e uma chave que são armazenados em variáveis ​​de ambiente.

import os
from azure.ai.inference import ChatCompletionsClient
from azure.core.credentials import AzureKeyCredential

client = ChatCompletionsClient(
    endpoint=os.environ["AZURE_INFERENCE_ENDPOINT"],
    credential=AzureKeyCredential(os.environ["AZURE_INFERENCE_CREDENTIAL"]),
)

Como obter os recursos do modelo

A rota /info retorna informações sobre o modelo que é implantado no ponto de extremidade. Retorne as informações do modelo chamando o seguinte método:

model_info = client.get_model_info()

A resposta é a seguinte:

print("Model name:", model_info.model_name)
print("Model type:", model_info.model_type)
print("Model provider name:", model_info.model_provider_name)

Model name: Cohere-command-r-plus-08-2024
Model type: chat-completions
Model provider name: Cohere

Como criar uma solicitação de conclusão de chat

O exemplo a seguir mostra como criar uma solicitação básica de conclusões de chat para o modelo.

from azure.ai.inference.models import SystemMessage, UserMessage

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
)

A resposta é semelhante ao seguinte e é possível observar as estatísticas de uso do modelo:

print("Response:", response.choices[0].message.content)
print("Model:", response.model)
print("Usage:")
print("\tPrompt tokens:", response.usage.prompt_tokens)
print("\tTotal tokens:", response.usage.total_tokens)
print("\tCompletion tokens:", response.usage.completion_tokens)

Response: As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.
Model: Cohere-command-r-plus-08-2024
Usage: 
  Prompt tokens: 19
  Total tokens: 91
  Completion tokens: 72

Inspecione a seção usage na resposta para conferir o número de tokens usados para a solicitação, o número total de tokens gerados e o número de tokens usados para a conclusão.

Como transmitir conteúdos

Por padrão, a API de conclusões retorna todo o conteúdo gerado em uma única resposta. Ao gerar conclusões longas, você pode precisar aguardar a resposta por muitos segundos.

É possível transmitir o conteúdo para recebê-lo à medida que ele é gerado. Ao transmitir o conteúdo, é possível começar a processar a conclusão à medida que ele se torna disponível. Esse modo retorna um objeto que transmite de volta a resposta na forma de eventos somente de dados enviados pelo servidor. Extraia partes do campo delta, em vez do campo de mensagem.

result = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    temperature=0,
    top_p=1,
    max_tokens=2048,
    stream=True,
)

Para transmitir conclusões, defina stream=True ao chamar o modelo.

Para exibir a saída, defina uma função auxiliar a fim de imprimir a transmissão.

def print_stream(result):
    """
    Prints the chat completion with streaming.
    """
    import time
    for update in result:
        if update.choices:
            print(update.choices[0].delta.content, end="")

É possível observar como o streaming gera conteúdos:

print_stream(result)

Como explorar outros parâmetros com suporte do cliente de inferência

Confira outros parâmetros que podem ser especificados no cliente de inferência. Para obter uma lista completa de todos os parâmetros com suporte e sua documentação correspondente, consulte Referência de API de Inferência do Modelo de IA do Azure.

from azure.ai.inference.models import ChatCompletionsResponseFormatText

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    presence_penalty=0.1,
    frequency_penalty=0.8,
    max_tokens=2048,
    stop=["<|endoftext|>"],
    temperature=0,
    top_p=1,
    response_format={ "type": ChatCompletionsResponseFormatText() },
)

Caso queira passar um parâmetro que não está na lista de parâmetros com suporte, poderá passá-lo para o modelo subjacente usando parâmetros extras. Consulte Passar parâmetros adicionais para o modelo.

Criar saídas JSON

Os modelos de chat do Comando Cohere podem criar saídas JSON. Defina response_format como json_object para habilitar o modo JSON e garantir que a mensagem gerada pelo modelo seja JSON válida. Você também deve instruir o modelo a produzir JSON por conta própria por meio de um sistema ou mensagem de usuário. Além disso, o conteúdo da mensagem poderá ser parcialmente cortado se finish_reason="length", o que indica que a geração excedeu max_tokens ou que a conversa excedeu o comprimento máximo do contexto.

from azure.ai.inference.models import ChatCompletionsResponseFormatJSON

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant that always generate responses in JSON format, using."
                      " the following format: { ""answer"": ""response"" }."),
        UserMessage(content="How many languages are in the world?"),
    ],
    response_format={ "type": ChatCompletionsResponseFormatJSON() }
)

Passar parâmetros adicionais para o modelo

A API de inferência de modelo da IA do Azure permite transmitir parâmetros extras ao modelo. O exemplo de código a seguir mostra como transmitir o parâmetro extra logprobs ao modelo.

Antes de transmitir parâmetros extras à API de inferência de modelo da IA do Azure, verifique se o modelo dá suporte a esses parâmetros. Quando a solicitação é feita ao modelo subjacente, o cabeçalho extra-parameters é transmitido a ele com o valor pass-through. Esse valor indica que o ponto de extremidade deve transmitir os parâmetros extras ao modelo. O uso de parâmetros extras com o modelo não garante que ele possa realmente lidar com eles. Leia a documentação do modelo para entender quais parâmetros adicionais têm suporte.

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="How many languages are in the world?"),
    ],
    model_extras={
        "logprobs": True
    }
)

Usar ferramentas

Os modelos de chat do Comando Cohere dão suporte ao uso de ferramentas, que podem ser um recurso extraordinário quando você precisa descarregar tarefas específicas do modelo de linguagem e, em vez disso, dependem de um sistema mais determinístico ou até mesmo de um modelo de linguagem diferente. A API de Inferência de Modelo de IA do Azure permite que você defina ferramentas da seguinte maneira.

O exemplo de código a seguir cria uma definição de ferramenta que é capaz de analisar informações de pré-lançamento de duas cidades diferentes.

from azure.ai.inference.models import FunctionDefinition, ChatCompletionsFunctionToolDefinition

flight_info = ChatCompletionsFunctionToolDefinition(
    function=FunctionDefinition(
        name="get_flight_info",
        description="Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
        parameters={
            "type": "object",
            "properties": {
                "origin_city": {
                    "type": "string",
                    "description": "The name of the city where the flight originates",
                },
                "destination_city": {
                    "type": "string",
                    "description": "The flight destination city",
                },
            },
            "required": ["origin_city", "destination_city"],
        },
    )
)

tools = [flight_info]

Neste exemplo, a saída da função é que não há voos disponíveis para a rota selecionada, mas o usuário deve considerar pegar um trem.

def get_flight_info(loc_origin: str, loc_destination: str):
    return { 
        "info": f"There are no flights available from {loc_origin} to {loc_destination}. You should take a train, specially if it helps to reduce CO2 emissions."
    }

Observação

O Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus e Cohere Command-r exigem que as respostas de uma ferramenta sejam um conteúdo JSON válido formatado como uma cadeia de caracteres. Ao construir mensagens do tipo Ferramenta, verifique se a resposta é uma cadeia de caracteres JSON válida.

Solicite ao modelo para reservar voos com a ajuda desta função:

messages = [
    SystemMessage(
        content="You are a helpful assistant that help users to find information about traveling, how to get"
                " to places and the different transportations options. You care about the environment and you"
                " always have that in mind when answering inqueries.",
    ),
    UserMessage(
        content="When is the next flight from Miami to Seattle?",
    ),
]

response = client.complete(
    messages=messages, tools=tools, tool_choice="auto"
)

Você pode inspecionar a resposta para descobrir se uma ferramenta precisa ser chamada. Inspecione o motivo de término para determinar se a ferramenta deve ser chamada. Lembre-se de que vários tipos de ferramentas podem ser indicados. Este exemplo demonstra uma ferramenta do tipo function.

response_message = response.choices[0].message
tool_calls = response_message.tool_calls

print("Finish reason:", response.choices[0].finish_reason)
print("Tool call:", tool_calls)

Para continuar, adicione esta mensagem ao histórico de chats:

messages.append(
    response_message
)

Agora, é hora de chamar a função apropriada para lidar com a chamada de ferramenta. O trecho de código a seguir itera em todas as chamadas de ferramenta indicadas na resposta e chama a função correspondente com os parâmetros apropriados. A resposta também é adicionada ao histórico de chats.

import json
from azure.ai.inference.models import ToolMessage

for tool_call in tool_calls:

    # Get the tool details:

    function_name = tool_call.function.name
    function_args = json.loads(tool_call.function.arguments.replace("\'", "\""))
    tool_call_id = tool_call.id

    print(f"Calling function `{function_name}` with arguments {function_args}")

    # Call the function defined above using `locals()`, which returns the list of all functions 
    # available in the scope as a dictionary. Notice that this is just done as a simple way to get
    # the function callable from its string name. Then we can call it with the corresponding
    # arguments.

    callable_func = locals()[function_name]
    function_response = callable_func(**function_args)

    print("->", function_response)

    # Once we have a response from the function and its arguments, we can append a new message to the chat 
    # history. Notice how we are telling to the model that this chat message came from a tool:

    messages.append(
        ToolMessage(
            tool_call_id=tool_call_id,
            content=json.dumps(function_response)
        )
    )

Veja a resposta do modelo:

response = client.complete(
    messages=messages,
    tools=tools,
)

Aplicar segurança de conteúdo

A API de inferência de modelo da IA do Azure dá suporte à Segurança de Conteúdo de IA do Azure. Ao usar implantações com a Segurança de Conteúdo de IA do Azure habilitada, as entradas e saídas são transmitidas por um conjunto de modelos de classificação que detectam e impedem a saída de usar conteúdos nocivos. O sistema de filtragem de conteúdo (versão prévia) detecta e toma medidas em categorias específicas de conteúdo potencialmente prejudicial tanto em prompts de entrada quanto em conclusões de saída.

O exemplo a seguir mostra como lidar com eventos quando o modelo detecta conteúdo nocivo na solicitação de entrada e a Segurança de Conteúdo está habilitada.

from azure.ai.inference.models import AssistantMessage, UserMessage, SystemMessage

try:
    response = client.complete(
        messages=[
            SystemMessage(content="You are an AI assistant that helps people find information."),
            UserMessage(content="Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."),
        ]
    )

    print(response.choices[0].message.content)

except HttpResponseError as ex:
    if ex.status_code == 400:
        response = ex.response.json()
        if isinstance(response, dict) and "error" in response:
            print(f"Your request triggered an {response['error']['code']} error:\n\t {response['error']['message']}")
        else:
            raise
    raise

Dica

Para saber como definir e controlar as configurações da Segurança de Conteúdo de IA do Azure, consulte a Documentação da Segurança de Conteúdo de IA do Azure.

Modelos de chat do Comando Cohere

Os modelos de chat do Comando Cohere incluem os seguintes modelos:

Comando Cohere R+ 08-2024

O Comando R+ 08-2024 é um grande modelo de linguagem generativo e otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

É recomendável usar o Comando R+ 08-2024 para os fluxos de trabalho que se baseiam na funcionalidade de geração aumentada de recuperação complexa (RAG), no uso de ferramentas de várias etapas (agentes) e em saídas estruturadas.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus-08-2024

Comando Cohere R 08-2024

O Comando R 08-2024 é um grande modelo de linguagem otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-08-2024

Comando Cohere R+

O Comando R+ é um modelo de linguagem grande generativo otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Recomendamos usar o Comando R+ para os fluxos de trabalho que se baseiam na funcionalidade complexa de RAG (geração aumentada de recuperação) e no uso de ferramentas de várias etapas (agentes).

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus

Comando Cohere R

O Comando R é um modelo de linguagem grande otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R dá suporte a um comprimento de contexto de 128 K.

O Comando R é ótimo para tarefas de uso de RAG (geração aumentada de recuperação) mais simples e de uma única etapa. Também é ótimo para uso em aplicativos em que o preço é uma questão central.

Os seguintes modelos estão disponíveis:

• Cohere-command-r

Dica

Além disso, o Cohere dá suporte ao uso de uma API personalizada para usar com recursos específicos do modelo. Para usar a API específica do provedor de modelos, verifique a documentação do Cohere ou veja a seção de exemplos de inferência para exemplo de código.

Pré-requisitos

Para usar modelos de chat do Comando Cohere com o Estúdio de IA do Azure, você precisa dos seguintes pré-requisitos:

Uma implantação de modelo

Implantação em APIs sem servidor

Os modelos de chat do Comando Cohere podem ser implantados em pontos de extremidade de API sem servidor com cobrança de pagamento conforme o uso. Esse tipo de implantação fornece uma maneira de consumir modelos como uma API sem hospedá-los em sua assinatura, ao mesmo tempo que mantém a segurança empresarial e a conformidade que as organizações precisam.

A implantação em um ponto de extremidade de API sem servidor não exige o uso de cotas da sua assinatura. Se ainda não estiver implantado, use o Estúdio de IA do Azure, o SDK do Azure Machine Learning para Python, a CLI do Azure ou os modelos do ARM para implantar o modelo como uma API sem servidor.

Como implantar o modelo em pontos de extremidade de API sem servidor

O pacote de inferência instalado

Você pode consumir previsões desse modelo usando o pacote @azure-rest/ai-inference de npm. Para instalar esse pacote, você precisa atender aos seguintes pré-requisitos:

• Versões LTS de Node.js com npm.
• O URL do ponto de extremidade. Para criar a biblioteca de clientes, você precisa transmitir o URL do ponto de extremidade. O URL do ponto de extremidade tem o formulário https://your-host-name.your-azure-region.inference.ai.azure.com, em que your-host-name é o nome de host exclusivo da implantação do modelo e your-azure-region é a região do Azure em que o modelo é implantado (por exemplo, eastus2).
• Dependendo da sua preferência de autenticação e implantação de modelos, você precisará de uma chave para autenticação no serviço ou de credenciais do Microsoft Entra ID. A chave é uma cadeia de caracteres de 32 caracteres.

Depois de atender a esses pré-requisitos, instale a biblioteca de inferência do Azure para JavaScript com o seguinte comando:

npm install @azure-rest/ai-inference

Como trabalhar com conclusões de chat

Nesta seção, você usa a API de inferência de modelo da IA do Azure com um modelo de conclusões para chat.

Dica

A API de inferência do modelo de IA do Azure permite conversar com a maioria dos modelos implantados no Estúdio de IA do Azure com o mesmo código e estrutura, incluindo modelos de chat do Comando Cohere.

Criar um cliente para consumir o modelo

Primeiro, crie o cliente para consumir o modelo. O código a seguir usa um URL de ponto de extremidade e uma chave que são armazenados em variáveis ​​de ambiente.

import ModelClient from "@azure-rest/ai-inference";
import { isUnexpected } from "@azure-rest/ai-inference";
import { AzureKeyCredential } from "@azure/core-auth";

const client = new ModelClient(
    process.env.AZURE_INFERENCE_ENDPOINT, 
    new AzureKeyCredential(process.env.AZURE_INFERENCE_CREDENTIAL)
);

Como obter os recursos do modelo

A rota /info retorna informações sobre o modelo que é implantado no ponto de extremidade. Retorne as informações do modelo chamando o seguinte método:

var model_info = await client.path("/info").get()

A resposta é a seguinte:

console.log("Model name: ", model_info.body.model_name)
console.log("Model type: ", model_info.body.model_type)
console.log("Model provider name: ", model_info.body.model_provider_name)

Model name: Cohere-command-r-plus-08-2024
Model type: chat-completions
Model provider name: Cohere

Como criar uma solicitação de conclusão de chat

O exemplo a seguir mostra como criar uma solicitação básica de conclusões de chat para o modelo.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
    }
});

A resposta é semelhante ao seguinte e é possível observar as estatísticas de uso do modelo:

if (isUnexpected(response)) {
    throw response.body.error;
}

console.log("Response: ", response.body.choices[0].message.content);
console.log("Model: ", response.body.model);
console.log("Usage:");
console.log("\tPrompt tokens:", response.body.usage.prompt_tokens);
console.log("\tTotal tokens:", response.body.usage.total_tokens);
console.log("\tCompletion tokens:", response.body.usage.completion_tokens);

Response: As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.
Model: Cohere-command-r-plus-08-2024
Usage: 
  Prompt tokens: 19
  Total tokens: 91
  Completion tokens: 72

Inspecione a seção usage na resposta para conferir o número de tokens usados para a solicitação, o número total de tokens gerados e o número de tokens usados para a conclusão.

Como transmitir conteúdos

Por padrão, a API de conclusões retorna todo o conteúdo gerado em uma única resposta. Ao gerar conclusões longas, você pode precisar aguardar a resposta por muitos segundos.

É possível transmitir o conteúdo para recebê-lo à medida que ele é gerado. Ao transmitir o conteúdo, é possível começar a processar a conclusão à medida que ele se torna disponível. Esse modo retorna um objeto que transmite de volta a resposta na forma de eventos somente de dados enviados pelo servidor. Extraia partes do campo delta, em vez do campo de mensagem.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
    }
}).asNodeStream();

Para transmitir conclusões, use .asNodeStream() ao chamar o modelo.

É possível observar como o streaming gera conteúdos:

var stream = response.body;
if (!stream) {
    stream.destroy();
    throw new Error(`Failed to get chat completions with status: ${response.status}`);
}

if (response.status !== "200") {
    throw new Error(`Failed to get chat completions: ${response.body.error}`);
}

var sses = createSseStream(stream);

for await (const event of sses) {
    if (event.data === "[DONE]") {
        return;
    }
    for (const choice of (JSON.parse(event.data)).choices) {
        console.log(choice.delta?.content ?? "");
    }
}

Como explorar outros parâmetros com suporte do cliente de inferência

Confira outros parâmetros que podem ser especificados no cliente de inferência. Para obter uma lista completa de todos os parâmetros com suporte e sua documentação correspondente, consulte Referência de API de Inferência do Modelo de IA do Azure.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        presence_penalty: "0.1",
        frequency_penalty: "0.8",
        max_tokens: 2048,
        stop: ["<|endoftext|>"],
        temperature: 0,
        top_p: 1,
        response_format: { type: "text" },
    }
});

Caso queira passar um parâmetro que não está na lista de parâmetros com suporte, poderá passá-lo para o modelo subjacente usando parâmetros extras. Consulte Passar parâmetros adicionais para o modelo.

Criar saídas JSON

Os modelos de chat do Comando Cohere podem criar saídas JSON. Defina response_format como json_object para habilitar o modo JSON e garantir que a mensagem gerada pelo modelo seja JSON válida. Você também deve instruir o modelo a produzir JSON por conta própria por meio de um sistema ou mensagem de usuário. Além disso, o conteúdo da mensagem poderá ser parcialmente cortado se finish_reason="length", o que indica que a geração excedeu max_tokens ou que a conversa excedeu o comprimento máximo do contexto.

var messages = [
    { role: "system", content: "You are a helpful assistant that always generate responses in JSON format, using."
        + " the following format: { \"answer\": \"response\" }." },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        response_format: { type: "json_object" }
    }
});

Passar parâmetros adicionais para o modelo

A API de inferência de modelo da IA do Azure permite transmitir parâmetros extras ao modelo. O exemplo de código a seguir mostra como transmitir o parâmetro extra logprobs ao modelo.

Antes de transmitir parâmetros extras à API de inferência de modelo da IA do Azure, verifique se o modelo dá suporte a esses parâmetros. Quando a solicitação é feita ao modelo subjacente, o cabeçalho extra-parameters é transmitido a ele com o valor pass-through. Esse valor indica que o ponto de extremidade deve transmitir os parâmetros extras ao modelo. O uso de parâmetros extras com o modelo não garante que ele possa realmente lidar com eles. Leia a documentação do modelo para entender quais parâmetros adicionais têm suporte.

var messages = [
    { role: "system", content: "You are a helpful assistant" },
    { role: "user", content: "How many languages are in the world?" },
];

var response = await client.path("/chat/completions").post({
    headers: {
        "extra-params": "pass-through"
    },
    body: {
        messages: messages,
        logprobs: true
    }
});

Usar ferramentas

Os modelos de chat do Comando Cohere dão suporte ao uso de ferramentas, que podem ser um recurso extraordinário quando você precisa descarregar tarefas específicas do modelo de linguagem e, em vez disso, dependem de um sistema mais determinístico ou até mesmo de um modelo de linguagem diferente. A API de Inferência de Modelo de IA do Azure permite que você defina ferramentas da seguinte maneira.

O exemplo de código a seguir cria uma definição de ferramenta que é capaz de analisar informações de pré-lançamento de duas cidades diferentes.

const flight_info = {
    name: "get_flight_info",
    description: "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
    parameters: {
        type: "object",
        properties: {
            origin_city: {
                type: "string",
                description: "The name of the city where the flight originates",
            },
            destination_city: {
                type: "string",
                description: "The flight destination city",
            },
        },
        required: ["origin_city", "destination_city"],
    },
}

const tools = [
    {
        type: "function",
        function: flight_info,
    },
];

Neste exemplo, a saída da função é que não há voos disponíveis para a rota selecionada, mas o usuário deve considerar pegar um trem.

function get_flight_info(loc_origin, loc_destination) {
    return {
        info: "There are no flights available from " + loc_origin + " to " + loc_destination + ". You should take a train, specially if it helps to reduce CO2 emissions."
    }
}

Observação

O Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus e Cohere Command-r exigem que as respostas de uma ferramenta sejam um conteúdo JSON válido formatado como uma cadeia de caracteres. Ao construir mensagens do tipo Ferramenta, verifique se a resposta é uma cadeia de caracteres JSON válida.

Solicite ao modelo para reservar voos com a ajuda desta função:

var result = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        tools: tools,
        tool_choice: "auto"
    }
});

Você pode inspecionar a resposta para descobrir se uma ferramenta precisa ser chamada. Inspecione o motivo de término para determinar se a ferramenta deve ser chamada. Lembre-se de que vários tipos de ferramentas podem ser indicados. Este exemplo demonstra uma ferramenta do tipo function.

const response_message = response.body.choices[0].message;
const tool_calls = response_message.tool_calls;

console.log("Finish reason: " + response.body.choices[0].finish_reason);
console.log("Tool call: " + tool_calls);

Para continuar, adicione esta mensagem ao histórico de chats:

messages.push(response_message);

Agora, é hora de chamar a função apropriada para lidar com a chamada de ferramenta. O trecho de código a seguir itera em todas as chamadas de ferramenta indicadas na resposta e chama a função correspondente com os parâmetros apropriados. A resposta também é adicionada ao histórico de chats.

function applyToolCall({ function: call, id }) {
    // Get the tool details:
    const tool_params = JSON.parse(call.arguments);
    console.log("Calling function " + call.name + " with arguments " + tool_params);

    // Call the function defined above using `window`, which returns the list of all functions 
    // available in the scope as a dictionary. Notice that this is just done as a simple way to get
    // the function callable from its string name. Then we can call it with the corresponding
    // arguments.
    const function_response = tool_params.map(window[call.name]);
    console.log("-> " + function_response);

    return function_response
}

for (const tool_call of tool_calls) {
    var tool_response = tool_call.apply(applyToolCall);

    messages.push(
        {
            role: "tool",
            tool_call_id: tool_call.id,
            content: tool_response
        }
    );
}

Veja a resposta do modelo:

var result = await client.path("/chat/completions").post({
    body: {
        messages: messages,
        tools: tools,
    }
});

Aplicar segurança de conteúdo

A API de inferência de modelo da IA do Azure dá suporte à Segurança de Conteúdo de IA do Azure. Ao usar implantações com a Segurança de Conteúdo de IA do Azure habilitada, as entradas e saídas são transmitidas por um conjunto de modelos de classificação que detectam e impedem a saída de usar conteúdos nocivos. O sistema de filtragem de conteúdo (versão prévia) detecta e toma medidas em categorias específicas de conteúdo potencialmente prejudicial tanto em prompts de entrada quanto em conclusões de saída.

O exemplo a seguir mostra como lidar com eventos quando o modelo detecta conteúdo nocivo na solicitação de entrada e a Segurança de Conteúdo está habilitada.

try {
    var messages = [
        { role: "system", content: "You are an AI assistant that helps people find information." },
        { role: "user", content: "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills." },
    ];

    var response = await client.path("/chat/completions").post({
        body: {
            messages: messages,
        }
    });

    console.log(response.body.choices[0].message.content);
}
catch (error) {
    if (error.status_code == 400) {
        var response = JSON.parse(error.response._content);
        if (response.error) {
            console.log(`Your request triggered an ${response.error.code} error:\n\t ${response.error.message}`);
        }
        else
        {
            throw error;
        }
    }
}

Dica

Para saber como definir e controlar as configurações da Segurança de Conteúdo de IA do Azure, consulte a Documentação da Segurança de Conteúdo de IA do Azure.

Modelos de chat do Comando Cohere

Os modelos de chat do Comando Cohere incluem os seguintes modelos:

Comando Cohere R+ 08-2024

O Comando R+ 08-2024 é um grande modelo de linguagem generativo e otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

É recomendável usar o Comando R+ 08-2024 para os fluxos de trabalho que se baseiam na funcionalidade de geração aumentada de recuperação complexa (RAG), no uso de ferramentas de várias etapas (agentes) e em saídas estruturadas.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus-08-2024

Comando Cohere R 08-2024

O Comando R 08-2024 é um grande modelo de linguagem otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-08-2024

Comando Cohere R+

O Comando R+ é um modelo de linguagem grande generativo otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Recomendamos usar o Comando R+ para os fluxos de trabalho que se baseiam na funcionalidade complexa de RAG (geração aumentada de recuperação) e no uso de ferramentas de várias etapas (agentes).

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus

Comando Cohere R

O Comando R é um modelo de linguagem grande otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R dá suporte a um comprimento de contexto de 128 K.

O Comando R é ótimo para tarefas de uso de RAG (geração aumentada de recuperação) mais simples e de uma única etapa. Também é ótimo para uso em aplicativos em que o preço é uma questão central.

Os seguintes modelos estão disponíveis:

• Cohere-command-r

Dica

Além disso, o Cohere dá suporte ao uso de uma API personalizada para usar com recursos específicos do modelo. Para usar a API específica do provedor de modelos, verifique a documentação do Cohere ou veja a seção de exemplos de inferência para exemplo de código.

Pré-requisitos

Para usar modelos de chat do Comando Cohere com o Estúdio de IA do Azure, você precisa dos seguintes pré-requisitos:

Uma implantação de modelo

Implantação em APIs sem servidor

Os modelos de chat do Comando Cohere podem ser implantados em pontos de extremidade de API sem servidor com cobrança de pagamento conforme o uso. Esse tipo de implantação fornece uma maneira de consumir modelos como uma API sem hospedá-los em sua assinatura, ao mesmo tempo que mantém a segurança empresarial e a conformidade que as organizações precisam.

A implantação em um ponto de extremidade de API sem servidor não exige o uso de cotas da sua assinatura. Se ainda não estiver implantado, use o Estúdio de IA do Azure, o SDK do Azure Machine Learning para Python, a CLI do Azure ou os modelos do ARM para implantar o modelo como uma API sem servidor.

Como implantar o modelo em pontos de extremidade de API sem servidor

O pacote de inferência instalado

Você pode consumir as previsões desse modelo usando o pacote Azure.AI.Inference do NuGet. Para instalar esse pacote, você precisa atender aos seguintes pré-requisitos:

• O URL do ponto de extremidade. Para criar a biblioteca de clientes, você precisa transmitir o URL do ponto de extremidade. O URL do ponto de extremidade tem o formulário https://your-host-name.your-azure-region.inference.ai.azure.com, em que your-host-name é o nome de host exclusivo da implantação do modelo e your-azure-region é a região do Azure em que o modelo é implantado (por exemplo, eastus2).
• Dependendo da sua preferência de autenticação e implantação de modelos, você precisará de uma chave para autenticação no serviço ou de credenciais do Microsoft Entra ID. A chave é uma cadeia de caracteres de 32 caracteres.

Depois de atender a esses pré-requisitos, instale a biblioteca de inferência da IA do Azure com o seguinte comando:

dotnet add package Azure.AI.Inference --prerelease

Também é possível realizar a autenticação com o Microsoft Entra ID (antigo Azure Active Directory). Para usar os provedores de credenciais fornecidos com o SDK do Azure, instale o pacote Azure.Identity:

dotnet add package Azure.Identity

Importe os seguintes namespaces:

using Azure;
using Azure.Identity;
using Azure.AI.Inference;

Esse exemplo também usa os seguintes namespaces, mas você nem sempre precisará deles:

using System.Text.Json;
using System.Text.Json.Serialization;
using System.Reflection;

Como trabalhar com conclusões de chat

Nesta seção, você usa a API de inferência de modelo da IA do Azure com um modelo de conclusões para chat.

Dica

A API de inferência do modelo de IA do Azure permite conversar com a maioria dos modelos implantados no Estúdio de IA do Azure com o mesmo código e estrutura, incluindo modelos de chat do Comando Cohere.

Criar um cliente para consumir o modelo

Primeiro, crie o cliente para consumir o modelo. O código a seguir usa um URL de ponto de extremidade e uma chave que são armazenados em variáveis ​​de ambiente.

ChatCompletionsClient client = new ChatCompletionsClient(
    new Uri(Environment.GetEnvironmentVariable("AZURE_INFERENCE_ENDPOINT")),
    new AzureKeyCredential(Environment.GetEnvironmentVariable("AZURE_INFERENCE_CREDENTIAL"))
);

Como obter os recursos do modelo

A rota /info retorna informações sobre o modelo que é implantado no ponto de extremidade. Retorne as informações do modelo chamando o seguinte método:

Response<ModelInfo> modelInfo = client.GetModelInfo();

A resposta é a seguinte:

Console.WriteLine($"Model name: {modelInfo.Value.ModelName}");
Console.WriteLine($"Model type: {modelInfo.Value.ModelType}");
Console.WriteLine($"Model provider name: {modelInfo.Value.ModelProviderName}");

Model name: Cohere-command-r-plus-08-2024
Model type: chat-completions
Model provider name: Cohere

Como criar uma solicitação de conclusão de chat

O exemplo a seguir mostra como criar uma solicitação básica de conclusões de chat para o modelo.

ChatCompletionsOptions requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
};

Response<ChatCompletions> response = client.Complete(requestOptions);

A resposta é semelhante ao seguinte e é possível observar as estatísticas de uso do modelo:

Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");
Console.WriteLine($"Model: {response.Value.Model}");
Console.WriteLine("Usage:");
Console.WriteLine($"\tPrompt tokens: {response.Value.Usage.PromptTokens}");
Console.WriteLine($"\tTotal tokens: {response.Value.Usage.TotalTokens}");
Console.WriteLine($"\tCompletion tokens: {response.Value.Usage.CompletionTokens}");

Response: As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.
Model: Cohere-command-r-plus-08-2024
Usage: 
  Prompt tokens: 19
  Total tokens: 91
  Completion tokens: 72

Inspecione a seção usage na resposta para conferir o número de tokens usados para a solicitação, o número total de tokens gerados e o número de tokens usados para a conclusão.

Como transmitir conteúdos

Por padrão, a API de conclusões retorna todo o conteúdo gerado em uma única resposta. Ao gerar conclusões longas, você pode precisar aguardar a resposta por muitos segundos.

É possível transmitir o conteúdo para recebê-lo à medida que ele é gerado. Ao transmitir o conteúdo, é possível começar a processar a conclusão à medida que ele se torna disponível. Esse modo retorna um objeto que transmite de volta a resposta na forma de eventos somente de dados enviados pelo servidor. Extraia partes do campo delta, em vez do campo de mensagem.

static async Task StreamMessageAsync(ChatCompletionsClient client)
{
    ChatCompletionsOptions requestOptions = new ChatCompletionsOptions()
    {
        Messages = {
            new ChatRequestSystemMessage("You are a helpful assistant."),
            new ChatRequestUserMessage("How many languages are in the world? Write an essay about it.")
        },
        MaxTokens=4096
    };

    StreamingResponse<StreamingChatCompletionsUpdate> streamResponse = await client.CompleteStreamingAsync(requestOptions);

    await PrintStream(streamResponse);
}

Para transmitir conclusões, use o método CompleteStreamingAsync ao chamar o modelo. Observe que, neste exemplo, a chamada é encapsulada em um método assíncrono.

Para exibir a saída, defina um método assíncrono a fim de imprimir o fluxo no console.

static async Task PrintStream(StreamingResponse<StreamingChatCompletionsUpdate> response)
{
    await foreach (StreamingChatCompletionsUpdate chatUpdate in response)
    {
        if (chatUpdate.Role.HasValue)
        {
            Console.Write($"{chatUpdate.Role.Value.ToString().ToUpperInvariant()}: ");
        }
        if (!string.IsNullOrEmpty(chatUpdate.ContentUpdate))
        {
            Console.Write(chatUpdate.ContentUpdate);
        }
    }
}

É possível observar como o streaming gera conteúdos:

StreamMessageAsync(client).GetAwaiter().GetResult();

Como explorar outros parâmetros com suporte do cliente de inferência

Confira outros parâmetros que podem ser especificados no cliente de inferência. Para obter uma lista completa de todos os parâmetros com suporte e sua documentação correspondente, consulte Referência de API de Inferência do Modelo de IA do Azure.

requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
    PresencePenalty = 0.1f,
    FrequencyPenalty = 0.8f,
    MaxTokens = 2048,
    StopSequences = { "<|endoftext|>" },
    Temperature = 0,
    NucleusSamplingFactor = 1,
    ResponseFormat = new ChatCompletionsResponseFormatText()
};

response = client.Complete(requestOptions);
Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");

Caso queira passar um parâmetro que não está na lista de parâmetros com suporte, poderá passá-lo para o modelo subjacente usando parâmetros extras. Consulte Passar parâmetros adicionais para o modelo.

Criar saídas JSON

Os modelos de chat do Comando Cohere podem criar saídas JSON. Defina response_format como json_object para habilitar o modo JSON e garantir que a mensagem gerada pelo modelo seja JSON válida. Você também deve instruir o modelo a produzir JSON por conta própria por meio de um sistema ou mensagem de usuário. Além disso, o conteúdo da mensagem poderá ser parcialmente cortado se finish_reason="length", o que indica que a geração excedeu max_tokens ou que a conversa excedeu o comprimento máximo do contexto.

requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage(
            "You are a helpful assistant that always generate responses in JSON format, " +
            "using. the following format: { \"answer\": \"response\" }."
        ),
        new ChatRequestUserMessage(
            "How many languages are in the world?"
        )
    },
    ResponseFormat = new ChatCompletionsResponseFormatJSON()
};

response = client.Complete(requestOptions);
Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");

Passar parâmetros adicionais para o modelo

A API de inferência de modelo da IA do Azure permite transmitir parâmetros extras ao modelo. O exemplo de código a seguir mostra como transmitir o parâmetro extra logprobs ao modelo.

Antes de transmitir parâmetros extras à API de inferência de modelo da IA do Azure, verifique se o modelo dá suporte a esses parâmetros. Quando a solicitação é feita ao modelo subjacente, o cabeçalho extra-parameters é transmitido a ele com o valor pass-through. Esse valor indica que o ponto de extremidade deve transmitir os parâmetros extras ao modelo. O uso de parâmetros extras com o modelo não garante que ele possa realmente lidar com eles. Leia a documentação do modelo para entender quais parâmetros adicionais têm suporte.

requestOptions = new ChatCompletionsOptions()
{
    Messages = {
        new ChatRequestSystemMessage("You are a helpful assistant."),
        new ChatRequestUserMessage("How many languages are in the world?")
    },
    AdditionalProperties = { { "logprobs", BinaryData.FromString("true") } },
};

response = client.Complete(requestOptions, extraParams: ExtraParameters.PassThrough);
Console.WriteLine($"Response: {response.Value.Choices[0].Message.Content}");

Usar ferramentas

Os modelos de chat do Comando Cohere dão suporte ao uso de ferramentas, que podem ser um recurso extraordinário quando você precisa descarregar tarefas específicas do modelo de linguagem e, em vez disso, dependem de um sistema mais determinístico ou até mesmo de um modelo de linguagem diferente. A API de Inferência de Modelo de IA do Azure permite que você defina ferramentas da seguinte maneira.

O exemplo de código a seguir cria uma definição de ferramenta que é capaz de analisar informações de pré-lançamento de duas cidades diferentes.

FunctionDefinition flightInfoFunction = new FunctionDefinition("getFlightInfo")
{
    Description = "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
    Parameters = BinaryData.FromObjectAsJson(new
    {
        Type = "object",
        Properties = new
        {
            origin_city = new
            {
                Type = "string",
                Description = "The name of the city where the flight originates"
            },
            destination_city = new
            {
                Type = "string",
                Description = "The flight destination city"
            }
        }
    },
        new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }
    )
};

ChatCompletionsFunctionToolDefinition getFlightTool = new ChatCompletionsFunctionToolDefinition(flightInfoFunction);

Neste exemplo, a saída da função é que não há voos disponíveis para a rota selecionada, mas o usuário deve considerar pegar um trem.

static string getFlightInfo(string loc_origin, string loc_destination)
{
    return JsonSerializer.Serialize(new
    {
        info = $"There are no flights available from {loc_origin} to {loc_destination}. You " +
        "should take a train, specially if it helps to reduce CO2 emissions."
    });
}

Observação

O Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus e Cohere Command-r exigem que as respostas de uma ferramenta sejam um conteúdo JSON válido formatado como uma cadeia de caracteres. Ao construir mensagens do tipo Ferramenta, verifique se a resposta é uma cadeia de caracteres JSON válida.

Solicite ao modelo para reservar voos com a ajuda desta função:

var chatHistory = new List<ChatRequestMessage>(){
        new ChatRequestSystemMessage(
            "You are a helpful assistant that help users to find information about traveling, " +
            "how to get to places and the different transportations options. You care about the" +
            "environment and you always have that in mind when answering inqueries."
        ),
        new ChatRequestUserMessage("When is the next flight from Miami to Seattle?")
    };

requestOptions = new ChatCompletionsOptions(chatHistory);
requestOptions.Tools.Add(getFlightTool);
requestOptions.ToolChoice = ChatCompletionsToolChoice.Auto;

response = client.Complete(requestOptions);

Você pode inspecionar a resposta para descobrir se uma ferramenta precisa ser chamada. Inspecione o motivo de término para determinar se a ferramenta deve ser chamada. Lembre-se de que vários tipos de ferramentas podem ser indicados. Este exemplo demonstra uma ferramenta do tipo function.

var responseMenssage = response.Value.Choices[0].Message;
var toolsCall = responseMenssage.ToolCalls;

Console.WriteLine($"Finish reason: {response.Value.Choices[0].FinishReason}");
Console.WriteLine($"Tool call: {toolsCall[0].Id}");

Para continuar, adicione esta mensagem ao histórico de chats:

requestOptions.Messages.Add(new ChatRequestAssistantMessage(response.Value.Choices[0].Message));

Agora, é hora de chamar a função apropriada para lidar com a chamada de ferramenta. O trecho de código a seguir itera em todas as chamadas de ferramenta indicadas na resposta e chama a função correspondente com os parâmetros apropriados. A resposta também é adicionada ao histórico de chats.

foreach (ChatCompletionsToolCall tool in toolsCall)
{
    if (tool is ChatCompletionsFunctionToolCall functionTool)
    {
        // Get the tool details:
        string callId = functionTool.Id;
        string toolName = functionTool.Name;
        string toolArgumentsString = functionTool.Arguments;
        Dictionary<string, object> toolArguments = JsonSerializer.Deserialize<Dictionary<string, object>>(toolArgumentsString);

        // Here you have to call the function defined. In this particular example we use 
        // reflection to find the method we definied before in an static class called 
        // `ChatCompletionsExamples`. Using reflection allows us to call a function 
        // by string name. Notice that this is just done for demonstration purposes as a 
        // simple way to get the function callable from its string name. Then we can call 
        // it with the corresponding arguments.

        var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
        string toolResponse = (string)typeof(ChatCompletionsExamples).GetMethod(toolName, flags).Invoke(null, toolArguments.Values.Cast<object>().ToArray());

        Console.WriteLine("->", toolResponse);
        requestOptions.Messages.Add(new ChatRequestToolMessage(toolResponse, callId));
    }
    else
        throw new Exception("Unsupported tool type");
}

Veja a resposta do modelo:

response = client.Complete(requestOptions);

Aplicar segurança de conteúdo

A API de inferência de modelo da IA do Azure dá suporte à Segurança de Conteúdo de IA do Azure. Ao usar implantações com a Segurança de Conteúdo de IA do Azure habilitada, as entradas e saídas são transmitidas por um conjunto de modelos de classificação que detectam e impedem a saída de usar conteúdos nocivos. O sistema de filtragem de conteúdo (versão prévia) detecta e toma medidas em categorias específicas de conteúdo potencialmente prejudicial tanto em prompts de entrada quanto em conclusões de saída.

O exemplo a seguir mostra como lidar com eventos quando o modelo detecta conteúdo nocivo na solicitação de entrada e a Segurança de Conteúdo está habilitada.

try
{
    requestOptions = new ChatCompletionsOptions()
    {
        Messages = {
            new ChatRequestSystemMessage("You are an AI assistant that helps people find information."),
            new ChatRequestUserMessage(
                "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."
            ),
        },
    };

    response = client.Complete(requestOptions);
    Console.WriteLine(response.Value.Choices[0].Message.Content);
}
catch (RequestFailedException ex)
{
    if (ex.ErrorCode == "content_filter")
    {
        Console.WriteLine($"Your query has trigger Azure Content Safety: {ex.Message}");
    }
    else
    {
        throw;
    }
}

Dica

Para saber como definir e controlar as configurações da Segurança de Conteúdo de IA do Azure, consulte a Documentação da Segurança de Conteúdo de IA do Azure.

Modelos de chat do Comando Cohere

Os modelos de chat do Comando Cohere incluem os seguintes modelos:

Comando Cohere R+ 08-2024

O Comando R+ 08-2024 é um grande modelo de linguagem generativo e otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

É recomendável usar o Comando R+ 08-2024 para os fluxos de trabalho que se baseiam na funcionalidade de geração aumentada de recuperação complexa (RAG), no uso de ferramentas de várias etapas (agentes) e em saídas estruturadas.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus-08-2024

Comando Cohere R 08-2024

O Comando R 08-2024 é um grande modelo de linguagem otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R 08-2024 é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R 08-2024 dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Os seguintes modelos estão disponíveis:

• Cohere-command-r-08-2024

Comando Cohere R+

O Comando R+ é um modelo de linguagem grande generativo otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R+ é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R+ dá suporte a um comprimento de contexto de 128 K.
• Entrada: somente texto.
• Saída: somente texto.

Recomendamos usar o Comando R+ para os fluxos de trabalho que se baseiam na funcionalidade complexa de RAG (geração aumentada de recuperação) e no uso de ferramentas de várias etapas (agentes).

Os seguintes modelos estão disponíveis:

• Cohere-command-r-plus

Comando Cohere R

O Comando R é um modelo de linguagem grande otimizado para vários casos de uso, incluindo raciocínio, resumo e resposta a perguntas.

• Arquitetura de modelo: o Comando R é um modelo de linguagem autorregressivo que usa uma arquitetura de transformador otimizada. Após o pré-treinamento, o modelo usa ajuste fino supervisionado (SFT) e treinamento de preferência para alinhar o comportamento do modelo às preferências humanas para ajuda e segurança.
• Idiomas abordados: o modelo é otimizado para ter um bom desempenho nos seguintes idiomas: inglês, francês, espanhol, italiano, alemão, português brasileiro, japonês, coreano, chinês simplificado e árabe.
• Os dados de pré-treinamento também incluíram os seguintes 13 idiomas: russo, polonês, turco, vietnamita, holandês, tcheco, indonésio, ucraniano, romeno, grego, hindi, hebraico e persa.
• Comprimento do contexto: o Comando R dá suporte a um comprimento de contexto de 128 K.

O Comando R é ótimo para tarefas de uso de RAG (geração aumentada de recuperação) mais simples e de uma única etapa. Também é ótimo para uso em aplicativos em que o preço é uma questão central.

Os seguintes modelos estão disponíveis:

• Cohere-command-r

Dica

Além disso, o Cohere dá suporte ao uso de uma API personalizada para usar com recursos específicos do modelo. Para usar a API específica do provedor de modelos, verifique a documentação do Cohere ou veja a seção de exemplos de inferência para exemplo de código.

Pré-requisitos

Para usar modelos de chat do Comando Cohere com o Estúdio de IA do Azure, você precisa dos seguintes pré-requisitos:

Uma implantação de modelo

Implantação em APIs sem servidor

Os modelos de chat do Comando Cohere podem ser implantados em pontos de extremidade de API sem servidor com cobrança de pagamento conforme o uso. Esse tipo de implantação fornece uma maneira de consumir modelos como uma API sem hospedá-los em sua assinatura, ao mesmo tempo que mantém a segurança empresarial e a conformidade que as organizações precisam.

A implantação em um ponto de extremidade de API sem servidor não exige o uso de cotas da sua assinatura. Se ainda não estiver implantado, use o Estúdio de IA do Azure, o SDK do Azure Machine Learning para Python, a CLI do Azure ou os modelos do ARM para implantar o modelo como uma API sem servidor.

Como implantar o modelo em pontos de extremidade de API sem servidor

Um cliente REST

Os modelos implantados com a API de inferência de modelo da IA do Azure podem ser consumidos com qualquer cliente REST. Para usar o cliente REST, você precisa atender a estes pré-requisitos:

• Para criar as solicitações, você precisa transmitir o URL do ponto de extremidade. O URL do ponto de extremidade tem o formulário https://your-host-name.your-azure-region.inference.ai.azure.com, em que your-host-name`` is your unique model deployment host name and your-azure-region é a região do Azure em que o modelo é implantado (por exemplo, eastus2).
• Dependendo da sua preferência de autenticação e implantação de modelos, você precisará de uma chave para autenticação no serviço ou de credenciais do Microsoft Entra ID. A chave é uma cadeia de caracteres de 32 caracteres.

Como trabalhar com conclusões de chat

Nesta seção, você usa a API de inferência de modelo da IA do Azure com um modelo de conclusões para chat.

Dica

A API de inferência do modelo de IA do Azure permite conversar com a maioria dos modelos implantados no Estúdio de IA do Azure com o mesmo código e estrutura, incluindo modelos de chat do Comando Cohere.

Criar um cliente para consumir o modelo

Primeiro, crie o cliente para consumir o modelo. O código a seguir usa um URL de ponto de extremidade e uma chave que são armazenados em variáveis ​​de ambiente.

Como obter os recursos do modelo

A rota /info retorna informações sobre o modelo que é implantado no ponto de extremidade. Retorne as informações do modelo chamando o seguinte método:

GET /info HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json

A resposta é a seguinte:

{
    "model_name": "Cohere-command-r-plus-08-2024",
    "model_type": "chat-completions",
    "model_provider_name": "Cohere"
}

Como criar uma solicitação de conclusão de chat

O exemplo a seguir mostra como criar uma solicitação básica de conclusões de chat para o modelo.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ]
}

A resposta é semelhante ao seguinte e é possível observar as estatísticas de uso do modelo:

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718726686,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.",
                "tool_calls": null
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 19,
        "total_tokens": 91,
        "completion_tokens": 72
    }
}

Inspecione a seção usage na resposta para conferir o número de tokens usados para a solicitação, o número total de tokens gerados e o número de tokens usados para a conclusão.

Como transmitir conteúdos

Por padrão, a API de conclusões retorna todo o conteúdo gerado em uma única resposta. Ao gerar conclusões longas, você pode precisar aguardar a resposta por muitos segundos.

É possível transmitir o conteúdo para recebê-lo à medida que ele é gerado. Ao transmitir o conteúdo, é possível começar a processar a conclusão à medida que ele se torna disponível. Esse modo retorna um objeto que transmite de volta a resposta na forma de eventos somente de dados enviados pelo servidor. Extraia partes do campo delta, em vez do campo de mensagem.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "stream": true,
    "temperature": 0,
    "top_p": 1,
    "max_tokens": 2048
}

É possível observar como o streaming gera conteúdos:

{
    "id": "23b54589eba14564ad8a2e6978775a39",
    "object": "chat.completion.chunk",
    "created": 1718726371,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "delta": {
                "role": "assistant",
                "content": ""
            },
            "finish_reason": null,
            "logprobs": null
        }
    ]
}

A última mensagem no fluxo tem finish_reason definido, o que indica o motivo da interrupção do processo de geração.

{
    "id": "23b54589eba14564ad8a2e6978775a39",
    "object": "chat.completion.chunk",
    "created": 1718726371,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "delta": {
                "content": ""
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 19,
        "total_tokens": 91,
        "completion_tokens": 72
    }
}

Como explorar outros parâmetros com suporte do cliente de inferência

Confira outros parâmetros que podem ser especificados no cliente de inferência. Para obter uma lista completa de todos os parâmetros com suporte e sua documentação correspondente, consulte Referência de API de Inferência do Modelo de IA do Azure.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "presence_penalty": 0.1,
    "frequency_penalty": 0.8,
    "max_tokens": 2048,
    "stop": ["<|endoftext|>"],
    "temperature" :0,
    "top_p": 1,
    "response_format": { "type": "text" }
}

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718726686,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "As of now, it's estimated that there are about 7,000 languages spoken around the world. However, this number can vary as some languages become extinct and new ones develop. It's also important to note that the number of speakers can greatly vary between languages, with some having millions of speakers and others only a few hundred.",
                "tool_calls": null
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 19,
        "total_tokens": 91,
        "completion_tokens": 72
    }
}

Caso queira passar um parâmetro que não está na lista de parâmetros com suporte, poderá passá-lo para o modelo subjacente usando parâmetros extras. Consulte Passar parâmetros adicionais para o modelo.

Criar saídas JSON

Os modelos de chat do Comando Cohere podem criar saídas JSON. Defina response_format como json_object para habilitar o modo JSON e garantir que a mensagem gerada pelo modelo seja JSON válida. Você também deve instruir o modelo a produzir JSON por conta própria por meio de um sistema ou mensagem de usuário. Além disso, o conteúdo da mensagem poderá ser parcialmente cortado se finish_reason="length", o que indica que a geração excedeu max_tokens ou que a conversa excedeu o comprimento máximo do contexto.

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant that always generate responses in JSON format, using the following format: { \"answer\": \"response\" }"
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "response_format": { "type": "json_object" }
}

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718727522,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "{\"answer\": \"There are approximately 7,117 living languages in the world today, according to the latest estimates. However, this number can vary as some languages become extinct and others are newly discovered or classified.\"}",
                "tool_calls": null
            },
            "finish_reason": "stop",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 39,
        "total_tokens": 87,
        "completion_tokens": 48
    }
}

Passar parâmetros adicionais para o modelo

A API de inferência de modelo da IA do Azure permite transmitir parâmetros extras ao modelo. O exemplo de código a seguir mostra como transmitir o parâmetro extra logprobs ao modelo.

Antes de transmitir parâmetros extras à API de inferência de modelo da IA do Azure, verifique se o modelo dá suporte a esses parâmetros. Quando a solicitação é feita ao modelo subjacente, o cabeçalho extra-parameters é transmitido a ele com o valor pass-through. Esse valor indica que o ponto de extremidade deve transmitir os parâmetros extras ao modelo. O uso de parâmetros extras com o modelo não garante que ele possa realmente lidar com eles. Leia a documentação do modelo para entender quais parâmetros adicionais têm suporte.

POST /chat/completions HTTP/1.1
Host: <ENDPOINT_URI>
Authorization: Bearer <TOKEN>
Content-Type: application/json
extra-parameters: pass-through

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user",
            "content": "How many languages are in the world?"
        }
    ],
    "logprobs": true
}

Usar ferramentas

Os modelos de chat do Comando Cohere dão suporte ao uso de ferramentas, que podem ser um recurso extraordinário quando você precisa descarregar tarefas específicas do modelo de linguagem e, em vez disso, dependem de um sistema mais determinístico ou até mesmo de um modelo de linguagem diferente. A API de Inferência de Modelo de IA do Azure permite que você defina ferramentas da seguinte maneira.

O exemplo de código a seguir cria uma definição de ferramenta que é capaz de analisar informações de pré-lançamento de duas cidades diferentes.

{
    "type": "function",
    "function": {
        "name": "get_flight_info",
        "description": "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
        "parameters": {
            "type": "object",
            "properties": {
                "origin_city": {
                    "type": "string",
                    "description": "The name of the city where the flight originates"
                },
                "destination_city": {
                    "type": "string",
                    "description": "The flight destination city"
                }
            },
            "required": [
                "origin_city",
                "destination_city"
            ]
        }
    }
}

Neste exemplo, a saída da função é que não há voos disponíveis para a rota selecionada, mas o usuário deve considerar pegar um trem.

Observação

O Cohere-command-r-plus-08-2024, Cohere-command-r-08-2024, Cohere-command-r-plus e Cohere Command-r exigem que as respostas de uma ferramenta sejam um conteúdo JSON válido formatado como uma cadeia de caracteres. Ao construir mensagens do tipo Ferramenta, verifique se a resposta é uma cadeia de caracteres JSON válida.

Solicite ao modelo para reservar voos com a ajuda desta função:

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant that help users to find information about traveling, how to get to places and the different transportations options. You care about the environment and you always have that in mind when answering inqueries"
        },
        {
            "role": "user",
            "content": "When is the next flight from Miami to Seattle?"
        }
    ],
    "tool_choice": "auto",
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_flight_info",
                "description": "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "origin_city": {
                            "type": "string",
                            "description": "The name of the city where the flight originates"
                        },
                        "destination_city": {
                            "type": "string",
                            "description": "The flight destination city"
                        }
                    },
                    "required": [
                        "origin_city",
                        "destination_city"
                    ]
                }
            }
        }
    ]
}

Você pode inspecionar a resposta para descobrir se uma ferramenta precisa ser chamada. Inspecione o motivo de término para determinar se a ferramenta deve ser chamada. Lembre-se de que vários tipos de ferramentas podem ser indicados. Este exemplo demonstra uma ferramenta do tipo function.

{
    "id": "0a1234b5de6789f01gh2i345j6789klm",
    "object": "chat.completion",
    "created": 1718726007,
    "model": "Cohere-command-r-plus-08-2024",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "",
                "tool_calls": [
                    {
                        "id": "abc0dF1gh",
                        "type": "function",
                        "function": {
                            "name": "get_flight_info",
                            "arguments": "{\"origin_city\": \"Miami\", \"destination_city\": \"Seattle\"}",
                            "call_id": null
                        }
                    }
                ]
            },
            "finish_reason": "tool_calls",
            "logprobs": null
        }
    ],
    "usage": {
        "prompt_tokens": 190,
        "total_tokens": 226,
        "completion_tokens": 36
    }
}

Para continuar, adicione esta mensagem ao histórico de chats:

Agora, é hora de chamar a função apropriada para lidar com a chamada de ferramenta. O trecho de código a seguir itera em todas as chamadas de ferramenta indicadas na resposta e chama a função correspondente com os parâmetros apropriados. A resposta também é adicionada ao histórico de chats.

Veja a resposta do modelo:

{
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant that help users to find information about traveling, how to get to places and the different transportations options. You care about the environment and you always have that in mind when answering inqueries"
        },
        {
            "role": "user",
            "content": "When is the next flight from Miami to Seattle?"
        },
        {
            "role": "assistant",
            "content": "",
            "tool_calls": [
                {
                    "id": "abc0DeFgH",
                    "type": "function",
                    "function": {
                        "name": "get_flight_info",
                        "arguments": "{\"origin_city\": \"Miami\", \"destination_city\": \"Seattle\"}",
                        "call_id": null
                    }
                }
            ]
        },
        {
            "role": "tool",
            "content": "{ \"info\": \"There are no flights available from Miami to Seattle. You should take a train, specially if it helps to reduce CO2 emissions.\" }",
            "tool_call_id": "abc0DeFgH" 
        }
    ],
    "tool_choice": "auto",
    "tools": [
        {
            "type": "function",
            "function": {
            "name": "get_flight_info",
            "description": "Returns information about the next flight between two cities. This includes the name of the airline, flight number and the date and time of the next flight",
            "parameters":{
                "type": "object",
                "properties": {
                    "origin_city": {
                        "type": "string",
                        "description": "The name of the city where the flight originates"
                    },
                    "destination_city": {
                        "type": "string",
                        "description": "The flight destination city"
                    }
                },
                "required": ["origin_city", "destination_city"]
            }
            }
        }
    ]
}

Aplicar segurança de conteúdo

A API de inferência de modelo da IA do Azure dá suporte à Segurança de Conteúdo de IA do Azure. Ao usar implantações com a Segurança de Conteúdo de IA do Azure habilitada, as entradas e saídas são transmitidas por um conjunto de modelos de classificação que detectam e impedem a saída de usar conteúdos nocivos. O sistema de filtragem de conteúdo (versão prévia) detecta e toma medidas em categorias específicas de conteúdo potencialmente prejudicial tanto em prompts de entrada quanto em conclusões de saída.

O exemplo a seguir mostra como lidar com eventos quando o modelo detecta conteúdo nocivo na solicitação de entrada e a Segurança de Conteúdo está habilitada.

{
    "messages": [
        {
            "role": "system",
            "content": "You are an AI assistant that helps people find information."
        },
                {
            "role": "user",
            "content": "Chopping tomatoes and cutting them into cubes or wedges are great ways to practice your knife skills."
        }
    ]
}

{
    "error": {
        "message": "The response was filtered due to the prompt triggering Microsoft's content management policy. Please modify your prompt and retry.",
        "type": null,
        "param": "prompt",
        "code": "content_filter",
        "status": 400
    }
}

Dica

Para saber como definir e controlar as configurações da Segurança de Conteúdo de IA do Azure, consulte a Documentação da Segurança de Conteúdo de IA do Azure.

Mais exemplos de inferência

Para obter mais exemplos de como usar modelos do Cohere, confira os seguintes exemplos e tutoriais:

Descrição	Idioma	Amostra
Solicitações da Web	Bash	Command-R - Command-R+
Pacote de inferência de IA do Azure para JavaScript	JavaScript	Link
Pacote de inferência da IA do Azure para Python	Python	Link
SDK do OpenAI (experimental)	Python	Link
LangChain	Python	Link
SDK da Cohere	Python	Link
SDK do LiteLLM	Python	Link

Recuperação de Geração Aumentada (RAG) e exemplos de uso de ferramentas

Descrição	Pacotes	Amostra
Crie um índice de vetor local da Pesquisa de Similaridade de IA do Facebook (FAISS), usando as inserções do Cohere - Langchain	langchain, langchain_cohere	cohere_faiss_langchain_embed.ipynb
Use o Comando Cohere R/R+ para responder às perguntas dos dados no índice de vetores FAISS local - Langchain	langchain, langchain_cohere	command_faiss_langchain.ipynb
Use o Comando Cohere R/R+ para responder às perguntas dos dados no índice do vetor de pesquisa de IA - Langchain	langchain, langchain_cohere	cohere-aisearch-langchain-rag.ipynb
Use o Comando Cohere R/R+ para responder às perguntas dos dados no índice vetorial de pesquisa de IA - SDK do Cohere	cohere, azure_search_documents	cohere-aisearch-rag.ipynb
Comando R+ ferramenta/chamada de função, usando o LangChain	cohere, langchain, langchain_cohere	command_tools-langchain.ipynb

Considerações de custo e cota para modelos do Cohere implantados como pontos de extremidade de API sem servidor

A cota é gerenciada por implantação. Cada implantação tem um limite de taxa de 200.000 tokens por minuto e 1.000 solicitações de API por minuto. No entanto, atualmente, limitamos uma implantação por modelo e projeto. Entre em contato com o Suporte do Microsoft Azure se os limites de taxa atuais não forem suficientes para seus cenários.

Os modelos do Cohere implantados como uma API sem servidor são oferecidos pelo Cohere por meio do Azure Marketplace e integrados ao Estúdio de IA do Azure para uso. Você pode encontrar preços do Azure Marketplace ao implantar o modelo.

Sempre que um projeto se inscreve em determinada oferta do Azure Marketplace, um recurso é criado para acompanhar os custos associados ao consumo dele. O mesmo recurso é usado para acompanhar os custos associados à inferência. No entanto, vários medidores estão disponíveis para acompanhar cada cenário de modo independente.

Para obter mais informações sobre como acompanhar os custos, consulte Monitorar os custos dos modelos oferecidos por meio do Azure Marketplace.

Conteúdo relacionado

• API de Inferência do Modelo de IA do Azure
• Como implantar modelos como APIs sem servidor
• Como consumir pontos de extremidade de API sem servidor de um projeto ou hub diferente do Estúdio de IA do Azure
• Disponibilidade de região para modelos em pontos de extremidade de API sem servidor
• Como planejar e gerenciar custos (marketplace)