Come usare modelli di chat Cohere Command con lo studio di Azure Machine Learning

Modelli di chat Cohere Command

I modelli di chat Cohere Command includono i modelli seguenti:

Prerequisiti

Per usare i modelli di chat Cohere Command con Azure Machine Learning, sono necessari i prerequisiti seguenti:

Una distribuzione modello

Distribuzione in API serverless

È possibile distribuire i modelli di chat Cohere Command in endpoint API serverless con fatturazione con pagamento in base al consumo. Questo tipo di distribuzione consente di usare i modelli come le API senza ospitarli nella sottoscrizione, mantenendo al contempo la sicurezza e la conformità aziendali necessarie alle organizzazioni.

La distribuzione in un endpoint API serverless non richiede la quota dalla sottoscrizione. Se il modello non è già stato distribuito, usare studio di Azure Machine Learning, Azure Machine Learning SDK per Python, l'interfaccia della riga di comando di Azure o i modelli ARM per distribuire il modello come API serverless.

Pacchetto di inferenza installato

È possibile usare le stime di questo modello usando il pacchetto azure-ai-inference con Python. Per installare questo pacchetto, sono necessari i prerequisiti seguenti:

• Python 3.8 o versione successiva installata, incluso pip.
• URL dell'endpoint. Per costruire la libreria client, è necessario passare l'URL dell'endpoint. L'URL dell'endpoint ha il formato https://your-host-name.your-azure-region.inference.ai.azure.com, in cui your-host-name è il nome host della distribuzione del modello univoco e your-azure-region è l'area di Azure in cui viene distribuito il modello ( ad esempio eastus2).
• A seconda della distribuzione del modello e delle preferenze di autenticazione, è necessario disporre di una chiave per l'autenticazione nel servizio o delle credenziali di Microsoft Entra ID. La chiave è una stringa di 32 caratteri.

Dopo aver ottenuto questi prerequisiti, installare il pacchetto di inferenza di Intelligenza artificiale di Azure con il comando seguente:

pip install azure-ai-inference

Altre informazioni sul pacchetto di inferenza di Intelligenza artificiale di Azure.

Usare i completamenti della chat

In questa sezione si usa l'API di inferenza del modello di intelligenza artificiale di Azure con un modello di completamento della chat per la chat.

Creare un client per utilizzare il modello

Creare prima di tutto il client per utilizzare il modello. Il codice seguente usa un URL dell'endpoint e una chiave archiviati nelle variabili di 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"]),
)

Ottenere le funzionalità del modello

La route /info restituisce informazioni sul modello distribuito nell'endpoint. Restituire le informazioni del modello chiamando il metodo seguente:

model_info = client.get_model_info()

Il formato della risposta è il seguente:

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

Creare una richiesta di completamento della chat

L'esempio seguente illustra come creare una richiesta di completamento della chat di base per il modello.

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?"),
    ],
)

La risposta è la seguente, in cui è possibile visualizzare le statistiche di utilizzo del modello:

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

Prendere in esame la sezione usage nella risposta per visualizzare il numero di token usati per il prompt, il numero totale di token generati e il numero di token usati per il completamento.

Streaming dei contenuti

Per impostazione predefinita, l'API di completamento restituisce l'intero contenuto generato in una singola risposta. Se si generano completamenti lunghi, l'attesa della risposta può impiegare diversi secondi.

È possibile trasmettere in streaming i contenuti per ottenerli mentre sono generati. Lo streaming dei contenuti consente di avviare l'elaborazione del completamento man mano che i contenuti diventano disponibili. Questa modalità restituisce un oggetto che ritrasmette la risposta come eventi inviati dal server solo dati. Estrarre blocchi dal campo delta, anziché dal campo del messaggio.

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

Per trasmettere i completamenti, impostare stream=True quando si chiama il modello.

Per visualizzare l'output, definire una funzione helper per stampare il flusso.

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="")

È possibile visualizzare il modo in cui lo streaming genera contenuti:

print_stream(result)

Esplorare altri parametri supportati dal client di inferenza

Esplorare altri parametri che è possibile specificare nel client di inferenza. Per un elenco completo di tutti i parametri supportati e della relativa documentazione corrispondente, vedere Informazioni di riferimento sull'API di inferenza del modello di intelligenza artificiale di 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() },
)

Se si desidera passare un parametro non incluso nell'elenco dei parametri supportati, è possibile passarlo al modello sottostante usando parametri aggiuntivi. Vedere Passare parametri aggiuntivi al modello.

Creare output JSON

I modelli di chat Cohere Command possono creare output JSON. Impostare response_format su per json_object abilitare la modalità JSON e garantire che il messaggio generato dal modello sia output JSON valido. È anche necessario indicare al modello di produrre output JSON manualmente tramite un messaggio di sistema o utente. Inoltre, il contenuto del messaggio può essere parzialmente tagliato se finish_reason="length", che indica che la generazione ha superato max_tokens o che la conversazione ha superato la lunghezza massima del contesto.

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

Passare parametri aggiuntivi al modello

L'API di inferenza del modello di intelligenza artificiale di Azure consente di passare parametri aggiuntivi al modello. Nell'esempio di codice seguente viene illustrato come passare il parametro aggiuntivo logprobs al modello.

Prima di passare parametri aggiuntivi all'API di inferenza del modello di intelligenza artificiale di Azure, assicurarsi che il modello supporti tali parametri aggiuntivi. Quando la richiesta viene effettuata al modello sottostante, l'intestazione extra-parameters viene passata al modello con il valore pass-through. Questo valore indica all'endpoint di passare i parametri aggiuntivi al modello. L'uso di parametri aggiuntivi con il modello non garantisce che il suddetto possa gestirli effettivamente. Leggere la documentazione del modello per comprendere quali parametri aggiuntivi sono supportati.

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

Usare gli strumenti

I modelli di chat Cohere Command supportano l'uso di strumenti, che possono essere una risorsa straordinaria quando è necessario eseguire l'offload di attività specifiche dal modello linguistico e basarsi su un sistema più deterministico o persino su un modello linguistico diverso. L'API di inferenza del modello di intelligenza artificiale di Azure consente di definire gli strumenti nel modo seguente.

L'esempio di codice seguente crea una definizione dello strumento in grado di esaminare le informazioni sui voli da due città diverse.

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]

In questo esempio, l'output della funzione è che non sono disponibili voli per il percorso selezionato e l'utente deve prendere in considerazione di prendere un treno.

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

Richiedere al modello di prenotare i voli con l'aiuto di questa funzione:

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

È possibile esaminare la risposta per verificare se è necessario chiamare uno strumento. Esaminare il motivo di fine per determinare se è necessario chiamare lo strumento. Tenere presente che è possibile indicare più tipi di strumenti. In questo esempio viene illustrato uno strumento di 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)

Per continuare, aggiungere questo messaggio alla cronologia delle chat:

messages.append(
    response_message
)

A questo punto, è possibile chiamare la funzione appropriata per gestire la chiamata allo strumento. Il frammento di codice seguente esegue l'iterazione di tutte le chiamate dello strumento indicate nella risposta e chiama la funzione corrispondente con i parametri appropriati. La risposta viene aggiunta anche alla cronologia delle chat.

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

Visualizzare la risposta dal modello:

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

Applicare la sicurezza dei contenuti

L'API di inferenza del modello di Azure per intelligenza artificiale supporta Sicurezza dei contenuti di Azure AI. Quando si usano distribuzioni con sicurezza dei contenuti di Azure AI attivata, gli input e gli output passano attraverso un insieme di modelli di classificazione volti a rilevare e impedire l'output di contenuto dannoso. Il sistema di filtro del contenuto (anteprima) rileva e agisce su categorie specifiche di contenuto potenzialmente dannoso sia nelle richieste di input che nei completamenti di output.

Nell'esempio seguente viene illustrato come gestire gli eventi quando il modello rileva contenuti dannosi nella richiesta di input e la sicurezza dei contenuti è abilitata.

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

Modelli di chat Cohere Command

I modelli di chat Cohere Command includono i modelli seguenti:

Prerequisiti

Per usare i modelli di chat Cohere Command con Azure Machine Learning, sono necessari i prerequisiti seguenti:

Una distribuzione modello

Distribuzione in API serverless

È possibile distribuire i modelli di chat Cohere Command in endpoint API serverless con fatturazione con pagamento in base al consumo. Questo tipo di distribuzione consente di usare i modelli come le API senza ospitarli nella sottoscrizione, mantenendo al contempo la sicurezza e la conformità aziendali necessarie alle organizzazioni.

La distribuzione in un endpoint API serverless non richiede la quota dalla sottoscrizione. Se il modello non è già stato distribuito, usare studio di Azure Machine Learning, Azure Machine Learning SDK per Python, l'interfaccia della riga di comando di Azure o i modelli ARM per distribuire il modello come API serverless.

Pacchetto di inferenza installato

È possibile usare le stime di questo modello usando il pacchetto @azure-rest/ai-inference di npm. Per installare questo pacchetto, sono necessari i prerequisiti seguenti:

• Versioni LTS di Node.js con npm.
• URL dell'endpoint. Per costruire la libreria client, è necessario passare l'URL dell'endpoint. L'URL dell'endpoint ha il formato https://your-host-name.your-azure-region.inference.ai.azure.com, in cui your-host-name è il nome host della distribuzione del modello univoco e your-azure-region è l'area di Azure in cui viene distribuito il modello ( ad esempio eastus2).
• A seconda della distribuzione del modello e delle preferenze di autenticazione, è necessario disporre di una chiave per l'autenticazione nel servizio o delle credenziali di Microsoft Entra ID. La chiave è una stringa di 32 caratteri.

Dopo aver ottenuto questi prerequisiti, installare la libreria di inferenza di Azure per JavaScript con il comando seguente:

npm install @azure-rest/ai-inference

Usare i completamenti della chat

In questa sezione si usa l'API di inferenza del modello di intelligenza artificiale di Azure con un modello di completamento della chat per la chat.

Creare un client per utilizzare il modello

Creare prima di tutto il client per utilizzare il modello. Il codice seguente usa un URL dell'endpoint e una chiave archiviati nelle variabili di 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)
);

Ottenere le funzionalità del modello

La route /info restituisce informazioni sul modello distribuito nell'endpoint. Restituire le informazioni del modello chiamando il metodo seguente:

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

Il formato della risposta è il seguente:

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

Creare una richiesta di completamento della chat

L'esempio seguente illustra come creare una richiesta di completamento della chat di base per il modello.

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,
    }
});

La risposta è la seguente, in cui è possibile visualizzare le statistiche di utilizzo del modello:

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

Prendere in esame la sezione usage nella risposta per visualizzare il numero di token usati per il prompt, il numero totale di token generati e il numero di token usati per il completamento.

Streaming dei contenuti

Per impostazione predefinita, l'API di completamento restituisce l'intero contenuto generato in una singola risposta. Se si generano completamenti lunghi, l'attesa della risposta può impiegare diversi secondi.

È possibile trasmettere in streaming i contenuti per ottenerli mentre sono generati. Lo streaming dei contenuti consente di avviare l'elaborazione del completamento man mano che i contenuti diventano disponibili. Questa modalità restituisce un oggetto che ritrasmette la risposta come eventi inviati dal server solo dati. Estrarre blocchi dal campo delta, anziché dal campo del messaggio.

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

Per trasmettere i completamenti, usare .asNodeStream() quando si chiama il modello.

È possibile visualizzare il modo in cui lo streaming genera contenuti:

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 ?? "");
    }
}

Esplorare altri parametri supportati dal client di inferenza

Esplorare altri parametri che è possibile specificare nel client di inferenza. Per un elenco completo di tutti i parametri supportati e della relativa documentazione corrispondente, vedere Informazioni di riferimento sull'API di inferenza del modello di intelligenza artificiale di 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" },
    }
});

Se si desidera passare un parametro non incluso nell'elenco dei parametri supportati, è possibile passarlo al modello sottostante usando parametri aggiuntivi. Vedere Passare parametri aggiuntivi al modello.

Creare output JSON

I modelli di chat Cohere Command possono creare output JSON. Impostare response_format su per json_object abilitare la modalità JSON e garantire che il messaggio generato dal modello sia output JSON valido. È anche necessario indicare al modello di produrre output JSON manualmente tramite un messaggio di sistema o utente. Inoltre, il contenuto del messaggio può essere parzialmente tagliato se finish_reason="length", che indica che la generazione ha superato max_tokens o che la conversazione ha superato la lunghezza massima del contesto.

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" }
    }
});

Passare parametri aggiuntivi al modello

L'API di inferenza del modello di intelligenza artificiale di Azure consente di passare parametri aggiuntivi al modello. Nell'esempio di codice seguente viene illustrato come passare il parametro aggiuntivo logprobs al modello.

Prima di passare parametri aggiuntivi all'API di inferenza del modello di intelligenza artificiale di Azure, assicurarsi che il modello supporti tali parametri aggiuntivi. Quando la richiesta viene effettuata al modello sottostante, l'intestazione extra-parameters viene passata al modello con il valore pass-through. Questo valore indica all'endpoint di passare i parametri aggiuntivi al modello. L'uso di parametri aggiuntivi con il modello non garantisce che il suddetto possa gestirli effettivamente. Leggere la documentazione del modello per comprendere quali parametri aggiuntivi sono supportati.

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
    }
});

Usare gli strumenti

I modelli di chat Cohere Command supportano l'uso di strumenti, che possono essere una risorsa straordinaria quando è necessario eseguire l'offload di attività specifiche dal modello linguistico e basarsi su un sistema più deterministico o persino su un modello linguistico diverso. L'API di inferenza del modello di intelligenza artificiale di Azure consente di definire gli strumenti nel modo seguente.

L'esempio di codice seguente crea una definizione dello strumento in grado di esaminare le informazioni sui voli da due città diverse.

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,
    },
];

In questo esempio, l'output della funzione è che non sono disponibili voli per il percorso selezionato e l'utente deve prendere in considerazione di prendere un treno.

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

Richiedere al modello di prenotare i voli con l'aiuto di questa funzione:

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

È possibile esaminare la risposta per verificare se è necessario chiamare uno strumento. Esaminare il motivo di fine per determinare se è necessario chiamare lo strumento. Tenere presente che è possibile indicare più tipi di strumenti. In questo esempio viene illustrato uno strumento di 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);

Per continuare, aggiungere questo messaggio alla cronologia delle chat:

messages.push(response_message);

A questo punto, è possibile chiamare la funzione appropriata per gestire la chiamata allo strumento. Il frammento di codice seguente esegue l'iterazione di tutte le chiamate dello strumento indicate nella risposta e chiama la funzione corrispondente con i parametri appropriati. La risposta viene aggiunta anche alla cronologia delle chat.

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
        }
    );
}

Visualizzare la risposta dal modello:

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

Applicare la sicurezza dei contenuti

L'API di inferenza del modello di Azure per intelligenza artificiale supporta Sicurezza dei contenuti di Azure AI. Quando si usano distribuzioni con sicurezza dei contenuti di Azure AI attivata, gli input e gli output passano attraverso un insieme di modelli di classificazione volti a rilevare e impedire l'output di contenuto dannoso. Il sistema di filtro del contenuto (anteprima) rileva e agisce su categorie specifiche di contenuto potenzialmente dannoso sia nelle richieste di input che nei completamenti di output.

Nell'esempio seguente viene illustrato come gestire gli eventi quando il modello rileva contenuti dannosi nella richiesta di input e la sicurezza dei contenuti è abilitata.

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;
        }
    }
}

Modelli di chat Cohere Command

I modelli di chat Cohere Command includono i modelli seguenti:

Prerequisiti

Per usare i modelli di chat Cohere Command con Azure Machine Learning, sono necessari i prerequisiti seguenti:

Una distribuzione modello

Distribuzione in API serverless

È possibile distribuire i modelli di chat Cohere Command in endpoint API serverless con fatturazione con pagamento in base al consumo. Questo tipo di distribuzione consente di usare i modelli come le API senza ospitarli nella sottoscrizione, mantenendo al contempo la sicurezza e la conformità aziendali necessarie alle organizzazioni.

La distribuzione in un endpoint API serverless non richiede la quota dalla sottoscrizione. Se il modello non è già stato distribuito, usare studio di Azure Machine Learning, Azure Machine Learning SDK per Python, l'interfaccia della riga di comando di Azure o i modelli ARM per distribuire il modello come API serverless.

Pacchetto di inferenza installato

È possibile usare le stime di questo modello usando il pacchetto Azure.AI.Inference di NuGet. Per installare questo pacchetto, sono necessari i prerequisiti seguenti:

• URL dell'endpoint. Per costruire la libreria client, è necessario passare l'URL dell'endpoint. L'URL dell'endpoint ha il formato https://your-host-name.your-azure-region.inference.ai.azure.com, in cui your-host-name è il nome host della distribuzione del modello univoco e your-azure-region è l'area di Azure in cui viene distribuito il modello ( ad esempio eastus2).
• A seconda della distribuzione del modello e delle preferenze di autenticazione, è necessario disporre di una chiave per l'autenticazione nel servizio o delle credenziali di Microsoft Entra ID. La chiave è una stringa di 32 caratteri.

Dopo aver ottenuto questi prerequisiti, installare la libreria di inferenza di Intelligenza artificiale di Azure con il comando seguente:

dotnet add package Azure.AI.Inference --prerelease

È anche possibile eseguire l'autenticazione con Microsoft Entra ID (in precedenza Azure Active Directory). Per usare provider di credenziali forniti con Azure SDK, installare il pacchetto Azure.Identity:

dotnet add package Azure.Identity

Importare gli spazi dei nomi seguenti:

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

Questo esempio usa anche gli spazi dei nomi seguenti; tuttavia,non sempre i suddetti sono necessari:

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

Usare i completamenti della chat

In questa sezione si usa l'API di inferenza del modello di intelligenza artificiale di Azure con un modello di completamento della chat per la chat.

Creare un client per utilizzare il modello

Creare prima di tutto il client per utilizzare il modello. Il codice seguente usa un URL dell'endpoint e una chiave archiviati nelle variabili di ambiente.

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

Ottenere le funzionalità del modello

La route /info restituisce informazioni sul modello distribuito nell'endpoint. Restituire le informazioni del modello chiamando il metodo seguente:

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

Il formato della risposta è il seguente:

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

Creare una richiesta di completamento della chat

L'esempio seguente illustra come creare una richiesta di completamento della chat di base per il modello.

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

La risposta è la seguente, in cui è possibile visualizzare le statistiche di utilizzo del modello:

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

Prendere in esame la sezione usage nella risposta per visualizzare il numero di token usati per il prompt, il numero totale di token generati e il numero di token usati per il completamento.

Streaming dei contenuti

Per impostazione predefinita, l'API di completamento restituisce l'intero contenuto generato in una singola risposta. Se si generano completamenti lunghi, l'attesa della risposta può impiegare diversi secondi.

È possibile trasmettere in streaming i contenuti per ottenerli mentre sono generati. Lo streaming dei contenuti consente di avviare l'elaborazione del completamento man mano che i contenuti diventano disponibili. Questa modalità restituisce un oggetto che ritrasmette la risposta come eventi inviati dal server solo dati. Estrarre blocchi dal campo delta, anziché dal campo del messaggio.

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);
}

Per trasmettere i completamenti, usare il metodo CompleteStreamingAsync quando si chiama il modello. Si noti che in questo esempio la chiamata viene sottoposta a wrapping in un metodo asincrono.

Per visualizzare l'output, definire un metodo asincrono per stampare il flusso nella 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);
        }
    }
}

È possibile visualizzare il modo in cui lo streaming genera contenuti:

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

Esplorare altri parametri supportati dal client di inferenza

Esplorare altri parametri che è possibile specificare nel client di inferenza. Per un elenco completo di tutti i parametri supportati e della relativa documentazione corrispondente, vedere Informazioni di riferimento sull'API di inferenza del modello di intelligenza artificiale di 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}");

Se si desidera passare un parametro non incluso nell'elenco dei parametri supportati, è possibile passarlo al modello sottostante usando parametri aggiuntivi. Vedere Passare parametri aggiuntivi al modello.

Creare output JSON

I modelli di chat Cohere Command possono creare output JSON. Impostare response_format su per json_object abilitare la modalità JSON e garantire che il messaggio generato dal modello sia output JSON valido. È anche necessario indicare al modello di produrre output JSON manualmente tramite un messaggio di sistema o utente. Inoltre, il contenuto del messaggio può essere parzialmente tagliato se finish_reason="length", che indica che la generazione ha superato max_tokens o che la conversazione ha superato la lunghezza massima del contesto.

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}");

Passare parametri aggiuntivi al modello

L'API di inferenza del modello di intelligenza artificiale di Azure consente di passare parametri aggiuntivi al modello. Nell'esempio di codice seguente viene illustrato come passare il parametro aggiuntivo logprobs al modello.

Prima di passare parametri aggiuntivi all'API di inferenza del modello di intelligenza artificiale di Azure, assicurarsi che il modello supporti tali parametri aggiuntivi. Quando la richiesta viene effettuata al modello sottostante, l'intestazione extra-parameters viene passata al modello con il valore pass-through. Questo valore indica all'endpoint di passare i parametri aggiuntivi al modello. L'uso di parametri aggiuntivi con il modello non garantisce che il suddetto possa gestirli effettivamente. Leggere la documentazione del modello per comprendere quali parametri aggiuntivi sono supportati.

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}");

Usare gli strumenti

I modelli di chat Cohere Command supportano l'uso di strumenti, che possono essere una risorsa straordinaria quando è necessario eseguire l'offload di attività specifiche dal modello linguistico e basarsi su un sistema più deterministico o persino su un modello linguistico diverso. L'API di inferenza del modello di intelligenza artificiale di Azure consente di definire gli strumenti nel modo seguente.

L'esempio di codice seguente crea una definizione dello strumento in grado di esaminare le informazioni sui voli da due città diverse.

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

In questo esempio, l'output della funzione è che non sono disponibili voli per il percorso selezionato e l'utente deve prendere in considerazione di prendere un treno.

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."
    });
}

Richiedere al modello di prenotare i voli con l'aiuto di questa funzione:

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

È possibile esaminare la risposta per verificare se è necessario chiamare uno strumento. Esaminare il motivo di fine per determinare se è necessario chiamare lo strumento. Tenere presente che è possibile indicare più tipi di strumenti. In questo esempio viene illustrato uno strumento di 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}");

Per continuare, aggiungere questo messaggio alla cronologia delle chat:

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

A questo punto, è possibile chiamare la funzione appropriata per gestire la chiamata allo strumento. Il frammento di codice seguente esegue l'iterazione di tutte le chiamate dello strumento indicate nella risposta e chiama la funzione corrispondente con i parametri appropriati. La risposta viene aggiunta anche alla cronologia delle chat.

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");
}

Visualizzare la risposta dal modello:

response = client.Complete(requestOptions);

Applicare la sicurezza dei contenuti

L'API di inferenza del modello di Azure per intelligenza artificiale supporta Sicurezza dei contenuti di Azure AI. Quando si usano distribuzioni con sicurezza dei contenuti di Azure AI attivata, gli input e gli output passano attraverso un insieme di modelli di classificazione volti a rilevare e impedire l'output di contenuto dannoso. Il sistema di filtro del contenuto (anteprima) rileva e agisce su categorie specifiche di contenuto potenzialmente dannoso sia nelle richieste di input che nei completamenti di output.

Nell'esempio seguente viene illustrato come gestire gli eventi quando il modello rileva contenuti dannosi nella richiesta di input e la sicurezza dei contenuti è abilitata.

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;
    }
}

Modelli di chat Cohere Command

I modelli di chat Cohere Command includono i modelli seguenti:

Prerequisiti

Per usare i modelli di chat Cohere Command con Azure Machine Learning, sono necessari i prerequisiti seguenti:

Una distribuzione modello

Distribuzione in API serverless

È possibile distribuire i modelli di chat Cohere Command in endpoint API serverless con fatturazione con pagamento in base al consumo. Questo tipo di distribuzione consente di usare i modelli come le API senza ospitarli nella sottoscrizione, mantenendo al contempo la sicurezza e la conformità aziendali necessarie alle organizzazioni.

La distribuzione in un endpoint API serverless non richiede la quota dalla sottoscrizione. Se il modello non è già stato distribuito, usare studio di Azure Machine Learning, Azure Machine Learning SDK per Python, l'interfaccia della riga di comando di Azure o i modelli ARM per distribuire il modello come API serverless.

Un client REST

I modelli distribuiti con l'API di inferenza del modello di Azure per intelligenza artificiale possono essere usati usando qualsiasi client REST. Per usare il client REST, sono necessari i prerequisiti seguenti:

• Per costruire le richieste, è necessario passare l'URL dell'endpoint. L'URL dell'endpoint ha il formato https://your-host-name.your-azure-region.inference.ai.azure.com, in cui your-host-name`` is your unique model deployment host name and your-azure-region`` è l'area di Azure in cui viene distribuito il modello (ad esempio eastus2).
• A seconda della distribuzione del modello e delle preferenze di autenticazione, è necessario disporre di una chiave per l'autenticazione nel servizio o delle credenziali di Microsoft Entra ID. La chiave è una stringa di 32 caratteri.

Usare i completamenti della chat

In questa sezione si usa l'API di inferenza del modello di intelligenza artificiale di Azure con un modello di completamento della chat per la chat.

Creare un client per utilizzare il modello

Creare prima di tutto il client per utilizzare il modello. Il codice seguente usa un URL dell'endpoint e una chiave archiviati nelle variabili di ambiente.

Ottenere le funzionalità del modello

La route /info restituisce informazioni sul modello distribuito nell'endpoint. Restituire le informazioni del modello chiamando il metodo seguente:

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

Il formato della risposta è il seguente:

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

Creare una richiesta di completamento della chat

L'esempio seguente illustra come creare una richiesta di completamento della chat di base per il modello.

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

La risposta è la seguente, in cui è possibile visualizzare le statistiche di utilizzo del modello:

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

Prendere in esame la sezione usage nella risposta per visualizzare il numero di token usati per il prompt, il numero totale di token generati e il numero di token usati per il completamento.

Streaming dei contenuti

Per impostazione predefinita, l'API di completamento restituisce l'intero contenuto generato in una singola risposta. Se si generano completamenti lunghi, l'attesa della risposta può impiegare diversi secondi.

È possibile trasmettere in streaming i contenuti per ottenerli mentre sono generati. Lo streaming dei contenuti consente di avviare l'elaborazione del completamento man mano che i contenuti diventano disponibili. Questa modalità restituisce un oggetto che ritrasmette la risposta come eventi inviati dal server solo dati. Estrarre blocchi dal campo delta, anziché dal campo del messaggio.

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

È possibile visualizzare il modo in cui lo streaming genera contenuti:

{
    "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
        }
    ]
}

Nell'ultimo messaggio nel flusso è impostato finish_reason, che indica il motivo per cui il processo di generazione deve essere arrestato.

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

Esplorare altri parametri supportati dal client di inferenza

Esplorare altri parametri che è possibile specificare nel client di inferenza. Per un elenco completo di tutti i parametri supportati e della relativa documentazione corrispondente, vedere Informazioni di riferimento sull'API di inferenza del modello di intelligenza artificiale di 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
    }
}

Se si desidera passare un parametro non incluso nell'elenco dei parametri supportati, è possibile passarlo al modello sottostante usando parametri aggiuntivi. Vedere Passare parametri aggiuntivi al modello.

Creare output JSON

I modelli di chat Cohere Command possono creare output JSON. Impostare response_format su per json_object abilitare la modalità JSON e garantire che il messaggio generato dal modello sia output JSON valido. È anche necessario indicare al modello di produrre output JSON manualmente tramite un messaggio di sistema o utente. Inoltre, il contenuto del messaggio può essere parzialmente tagliato se finish_reason="length", che indica che la generazione ha superato max_tokens o che la conversazione ha superato la lunghezza massima del contesto.

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

Passare parametri aggiuntivi al modello

L'API di inferenza del modello di intelligenza artificiale di Azure consente di passare parametri aggiuntivi al modello. Nell'esempio di codice seguente viene illustrato come passare il parametro aggiuntivo logprobs al modello.

Prima di passare parametri aggiuntivi all'API di inferenza del modello di intelligenza artificiale di Azure, assicurarsi che il modello supporti tali parametri aggiuntivi. Quando la richiesta viene effettuata al modello sottostante, l'intestazione extra-parameters viene passata al modello con il valore pass-through. Questo valore indica all'endpoint di passare i parametri aggiuntivi al modello. L'uso di parametri aggiuntivi con il modello non garantisce che il suddetto possa gestirli effettivamente. Leggere la documentazione del modello per comprendere quali parametri aggiuntivi sono supportati.

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
}

Usare gli strumenti

I modelli di chat Cohere Command supportano l'uso di strumenti, che possono essere una risorsa straordinaria quando è necessario eseguire l'offload di attività specifiche dal modello linguistico e basarsi su un sistema più deterministico o persino su un modello linguistico diverso. L'API di inferenza del modello di intelligenza artificiale di Azure consente di definire gli strumenti nel modo seguente.

L'esempio di codice seguente crea una definizione dello strumento in grado di cercare informazioni sui voli da due città diverse.

{
    "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"
            ]
        }
    }
}

In questo esempio, l'output della funzione è che non sono disponibili voli per il percorso selezionato e l'utente deve prendere in considerazione di prendere un treno.

Richiedere al modello di prenotare i voli con l'aiuto di questa funzione:

{
    "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"
                    ]
                }
            }
        }
    ]
}

È possibile esaminare la risposta per verificare se è necessario chiamare uno strumento. Esaminare il motivo di fine per determinare se è necessario chiamare lo strumento. Tenere presente che è possibile indicare più tipi di strumenti. In questo esempio viene illustrato uno strumento di 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
    }
}

Per continuare, aggiungere questo messaggio alla cronologia delle chat:

A questo punto, è possibile chiamare la funzione appropriata per gestire la chiamata allo strumento. Il frammento di codice seguente esegue l'iterazione di tutte le chiamate dello strumento indicate nella risposta e chiama la funzione corrispondente con i parametri appropriati. La risposta viene aggiunta anche alla cronologia delle chat.

Visualizzare la risposta dal modello:

{
    "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"]
            }
            }
        }
    ]
}

Applicare la sicurezza dei contenuti

L'API di inferenza del modello di Azure per intelligenza artificiale supporta Sicurezza dei contenuti di Azure AI. Quando si usano distribuzioni con sicurezza dei contenuti di Azure AI attivata, gli input e gli output passano attraverso un insieme di modelli di classificazione volti a rilevare e impedire l'output di contenuto dannoso. Il sistema di filtro del contenuto (anteprima) rileva e agisce su categorie specifiche di contenuto potenzialmente dannoso sia nelle richieste di input che nei completamenti di output.

Nell'esempio seguente viene illustrato come gestire gli eventi quando il modello rileva contenuti dannosi nella richiesta di input e la sicurezza dei contenuti è abilitata.

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