Lavorare con i modelli di completamento della chat

• Installare la libreria di Python OpenAI: pip install openai.
• Per l'autenticazione Microsoft Entra ID, installare Azure Identity (pip install azure-identity) e l'interfaccia della riga di comando di Azure. Assegna il ruolo Cognitive Services User al tuo account utente, quindi esegui az login.
• Per l'esempio di conteggio dei token, installare tiktoken: pip install tiktoken.
• Se usi chiavi API, imposta la variabile di ambiente AZURE_OPENAI_API_KEY.

• Il .NET 8.0 SDK o versione successiva.
• Per l'autenticazione Microsoft Entra ID, installare l'interfaccia della riga di comando di Azure e assegnare il ruolo Cognitive Services User appropriato al proprio account utente.
• Se usi chiavi API, imposta la variabile di ambiente AZURE_OPENAI_API_KEY.

• Node.js 22 o versione successiva.
• Per l'autenticazione di Microsoft Entra ID, installare interfaccia della riga di comando di Azure, assegnare il ruolo Cognitive Services User all'account utente e quindi eseguire az login.
• Se usi chiavi API, imposta la variabile di ambiente AZURE_OPENAI_API_KEY.

Configurare

Salvare ogni esempio completo come chat.pye quindi eseguirlo con python chat.py.

Lavorare con i modelli di completamento della chat

Il frammento di codice seguente illustra il modo più semplice per interagire con i modelli che usano l'API Completamento chat.

from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

response = client.chat.completions.create(
    model="YOUR-DEPLOYMENT-NAME",  # Replace with your model deployment name.
    messages=[
        {"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
        {"role": "user", "content": "Who were the founders of Microsoft?"}
    ]
)

#print(response)
print(response.model_dump_json(indent=2))
print(response.choices[0].message.content)

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
)

response = client.chat.completions.create(
    model="YOUR-DEPLOYMENT-NAME",  # Replace with your model deployment name.
    messages=[
        {"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
        {"role": "user", "content": "Who were the founders of Microsoft?"}
    ]
)

#print(response)
print(response.model_dump_json(indent=2))
print(response.choices[0].message.content)

{
    "id": "chatcmpl-8GHoQAJ3zN2DJYqOFiVysrMQJfe1P",
    "choices": [
        {
            "finish_reason": "stop",
            "index": 0,
            "message": {
                "content": "Microsoft was founded by Bill Gates and Paul Allen. They established the company on April 4, 1975. Bill Gates served as the CEO of Microsoft until 2000 and later as Chairman and Chief Software Architect until his retirement in 2008, while Paul Allen left the company in 1983 but remained on the board of directors until 2000.",
                "role": "assistant"
            },
            "content_filter_results": {
                "hate": {
                    "filtered": false,
                    "severity": "safe"
                },
                "self_harm": {
                    "filtered": false,
                    "severity": "safe"
                },
                "sexual": {
                    "filtered": false,
                    "severity": "safe"
                },
                "violence": {
                    "filtered": false,
                    "severity": "safe"
                }
            }
        }
    ],
    "created": 1698892410,
    "model": "gpt-4o",
    "object": "chat.completion",
    "usage": {
        "completion_tokens": 73,
        "prompt_tokens": 29,
        "total_tokens": 102
    },
    "prompt_filter_results": [
        {
            "prompt_index": 0,
            "content_filter_results": {
                "hate": {
                    "filtered": false,
                    "severity": "safe"
                },
                "self_harm": {
                    "filtered": false,
                    "severity": "safe"
                },
                "sexual": {
                    "filtered": false,
                    "severity": "safe"
                },
                "violence": {
                    "filtered": false,
                    "severity": "safe"
                }
            }
        }
    ]
}
Microsoft was founded by Bill Gates and Paul Allen. They established the company on April 4, 1975. Bill Gates served as the CEO of Microsoft until 2000 and later as Chairman and Chief Software Architect until his retirement in 2008, while Paul Allen left the company in 1983 but remained on the board of directors until 2000.

Ogni risposta include finish_reason. I valori possibili per finish_reason sono:

• stop: l'API ha restituito l'output completo del modello.
• length: output del modello incompleto a causa del parametro max_completion_tokens o del limite di token.
• content_filter: contenuto omesso a causa di un flag del filtro contenuti.
• tool_calls: modello denominato strumento.
• function_call: modello denominato funzione. Questo valore è deprecato.

Per le risposte in streaming, finish_reason è null fino a quando il blocco finale non completa la risposta.

Impostare max_completion_tokens un valore sufficientemente elevato per la risposta prevista. Un valore superiore consente di impedire che il modello venga arrestato prima che raggiunga la fine del messaggio.

Lavorare con l'API Chat Completions

OpenAI ha addestrato modelli di completamento della chat per accettare input formattati come una conversazione. Il parametro messages accetta una matrice di oggetti messaggio con una conversazione organizzata per ruolo. Quando si usa l'API Python, viene usato un elenco di dizionari.

Il formato di completamento di una chat di base è:

messages = [
    {"role": "system", "content": "Provide context or instructions to the model."},
    {"role": "user", "content": "The user's message goes here."},
]

Una conversazione con una risposta di esempio seguita da una domanda sarà simile alla seguente:

messages = [
    {"role": "system", "content": "Provide context or instructions to the model."},
    {"role": "user", "content": "Example question goes here."},
    {"role": "assistant", "content": "Example answer goes here."},
    {"role": "user", "content": "First question for the model to answer."},
]

Ruolo del sistema

Il ruolo di sistema, noto anche come messaggio di sistema, è incluso all'inizio della matrice. Questo messaggio fornisce le istruzioni iniziali per il modello. È possibile fornire varie informazioni nel ruolo del sistema, ad esempio:

• Breve descrizione dell'assistente.
• Tratti di personalità dell'assistente.
• Istruzioni o regole che si desidera che l'assistente segua.
• Dati o informazioni necessari per il modello, ad esempio le domande pertinenti da un elenco di domande frequenti.

Personalizza il ruolo di sistema per il tuo caso d’uso o includi istruzioni di base. Il messaggio di sistema è facoltativo, ma include almeno uno di base per ottenere i risultati migliori.

Messaggi

Dopo il ruolo di sistema, è possibile includere una serie di messaggi tra user e assistant.

message = {"role": "user", "content": "What is thermodynamics?"}

Per attivare una risposta dal modello, terminare con un messaggio utente per indicare che è il turno dell'assistente per rispondere. È anche possibile includere una serie di messaggi di esempio tra l'utente e l'assistente come modo per eseguire l'apprendimento con pochi scatti.

Esempi di prompt dei messaggi

La sezione seguente mostra esempi di diversi stili di richieste che è possibile usare con i modelli di completamento della chat. Questi esempi sono solo un punto di partenza. È possibile sperimentare richieste diverse per personalizzare il comportamento per i propri casi d'uso.

Esempio di base

Se si vuole che il modello di completamento della chat si comporti in modo analogo a chatgpt.com, è possibile usare un messaggio di sistema di base, ad esempio Assistant is a large language model trained by OpenAI.

messages = [
    {"role": "system", "content": "Assistant is a large language model trained by OpenAI."},
    {"role": "user", "content": "Who were the founders of Microsoft?"},
]

Esempio con istruzioni

Per alcuni scenari, è possibile fornire altre istruzioni al modello per definire protezioni per le operazioni che il modello è in grado di eseguire.

messages = [
    {"role": "system", "content": """Assistant is an intelligent chatbot designed to help users answer tax-related questions.
Instructions: 
- Only answer questions related to taxes. 
- If you're unsure of an answer, say "I don't know" or "I'm not sure" and recommend the IRS website."""},
    {"role": "user", "content": "When are my taxes due?"},
]

Usare i dati come base

È anche possibile includere dati o informazioni pertinenti nel messaggio di sistema per fornire al modello un contesto aggiuntivo per la conversazione. Se è necessario includere solo una piccola quantità di informazioni, è possibile impostarla come hardcoded nel messaggio di sistema. Se si dispone di una grande quantità di dati che il modello deve conoscere, è possibile usare embeddings o un prodotto come Azure AI Search per recuperare le informazioni più rilevanti in fase di query.

messages = [
    {"role": "system", "content": """Assistant helps users answer technical questions about Azure OpenAI in Microsoft Foundry Models. Only answer questions using the following context. If the context doesn't contain the answer, say 'I don't know.'

Context:
- Azure OpenAI provides REST API access to OpenAI models, including GPT-5, GPT-4.1, and Embeddings model series.
- Azure OpenAI gives customers advanced language AI with GPT-5, GPT-image, and Embeddings models with the security and enterprise capabilities of Azure. Azure OpenAI co-develops the APIs with OpenAI, ensuring compatibility and a smooth transition between the services.
- At Microsoft, we're committed to advancing AI according to principles that put people first."""},
    {"role": "user", "content": "What is Azure OpenAI?"},
]

Apprendimento few-shot con completamento chat

È anche possibile fornire esempi few-shot al modello. L'approccio per l'apprendimento con pochi scatti è leggermente cambiato a causa del nuovo formato di richiesta. È ora possibile includere una serie di messaggi tra l'utente e l'assistente nel prompt come esempi di pochi scatti. Usando questi esempi, è possibile fornire risposte alle domande comuni per preparare il modello o impartire comportamenti specifici.

Questo esempio illustra come usare l'apprendimento few-shot con gli attuali modelli di completamento della chat, come gpt-5-mini e gpt-5. Sperimentare diversi approcci per trovare ciò che funziona meglio per il caso d'uso.

messages = [
    {"role": "system", "content": "Assistant helps users answer tax-related questions."},
    {"role": "user", "content": "When do I need to file my taxes by?"},
    {"role": "assistant", "content": "Check the current individual filing deadline at https://www.irs.gov/filing/individuals/when-to-file."},
    {"role": "user", "content": "How can I check the status of my tax refund?"},
    {"role": "assistant", "content": "Check your refund status at https://www.irs.gov/refunds."},
]

Utilizzare il completamento della chat per contesti che non riguardano la chat

L'API Chat Completions è progettata per funzionare con conversazioni a più turni, ma è adatta anche agli scenari non di chat.

Ad esempio, per uno scenario di estrazione di entità, è possibile usare il prompt seguente:

messages = [
    {"role": "system", "content": """You extract entities from text and return them as a JSON object with this format:
{
   "name": "",
   "company": "",
   "phone_number": ""
}"""},
    {"role": "user", "content": "Hello. My name is Robert Smith. I'm calling from Contoso Insurance, Delaware. My colleague mentioned that you are interested in learning about our comprehensive benefits policy. Could you give me a call back at (555) 346-9322 when you get a chance so we can go over the benefits?"},
]

Creare un ciclo di conversazione di base

Gli esempi precedenti illustrano i meccanismi di base dell'interazione con l'API Completamento chat. In questo esempio viene illustrato come creare un ciclo di conversazione che esegue le azioni seguenti:

• Accetta continuamente l'input della console e lo formatta correttamente come parte dell'elenco di messaggi come contenuto del ruolo utente.
• Restituisce le risposte stampate nella console e formattate, e le aggiunge all'elenco dei messaggi come contenuto del ruolo di assistente.

Ogni volta che si pone una nuova domanda, la richiesta invia la trascrizione della conversazione in esecuzione insieme alla domanda più recente. Poiché il modello non ha memoria, inviare una trascrizione aggiornata con ogni domanda o il modello perde il contesto delle domande e delle risposte precedenti.

from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

conversation = [{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user_input = input("Q:")
    conversation.append({"role": "user", "content": user_input})

    response = client.chat.completions.create(
        model="YOUR-DEPLOYMENT-NAME",  # Replace with your model deployment name.
        messages=conversation
    )

    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
)

conversation = [{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user_input = input("Q:")
    conversation.append({"role": "user", "content": user_input})

    response = client.chat.completions.create(
        model="YOUR-DEPLOYMENT-NAME",  # Replace with your model deployment name.
        messages=conversation
    )

    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

Quando si esegue il codice precedente, si ottiene una finestra della console vuota. Immettere la prima domanda nella finestra e quindi selezionare la Enter chiave. Dopo aver restituito la risposta, è possibile ripetere il processo e continuare a porre domande.

Gestire le conversazioni

L'esempio precedente viene eseguito fino a quando non si raggiunge il limite di token del modello (finestra di contesto). Con ogni domanda e risposta ricevuta, l'elenco messages aumenta di dimensioni. Il numero combinato di token del messages più i token di output richiesti deve rimanere entro il limite del modello oppure la richiesta ha esito negativo. Per informazioni sui limiti correnti dei token, vedere la pagina dei modelli .

È responsabilità dell'utente assicurarsi che il prompt e il completamento rientrino nei limiti di token. Per conversazioni più lunghe, è necessario tenere traccia del numero di token e inviare solo al modello un prompt che rientra nel limite. In alternativa, con l'API delle risposte è possibile che l'API gestisca automaticamente il troncamento/gestione della cronologia delle conversazioni.

L'esempio di codice seguente usa la libreria tiktoken di OpenAI per tagliare una conversazione a una soglia dimostrativa di 4.096 token. Impostare token_limit sulla finestra di contesto del modello distribuito per l'uso in produzione.

Potrebbe essere necessario aggiornare tiktoken eseguendo pip install --upgrade tiktoken.

import tiktoken
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

system_message = {"role": "system", "content": "You are a helpful assistant."}
max_response_tokens = 250
token_limit = 4096
conversation = []
conversation.append(system_message)

def num_tokens_from_messages(messages, model="gpt-4o"):
    """Return the number of tokens used by a list of messages."""
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        print("Warning: model not found. Using o200k_base encoding.")
        encoding = tiktoken.get_encoding("o200k_base")

    if model in {
        "gpt-4o",
        "gpt-4o-mini",
        "gpt-5",
        "gpt-4.1",
        "o1",
        "o1-mini",
        "o3",
        "o3-mini",
        "o4-mini",
    }:
        tokens_per_message = 3
        tokens_per_name = 1

    elif any(model.startswith(prefix) for prefix in [
        "gpt-4o-",
        "gpt-5-",
        "gpt-4.1-",
        "o1-",
        "o3-",
        "o4-mini-",
    ]):
        tokens_per_message = 3
        tokens_per_name = 1
    else:
        raise NotImplementedError(
            f"""num_tokens_from_messages() is not implemented for model {model}. """
        )

    num_tokens = 0
    for message in messages:
        num_tokens += tokens_per_message
        for key, value in message.items():
            num_tokens += len(encoding.encode(value))
            if key == "name":
                num_tokens += tokens_per_name
    num_tokens += 3
    return num_tokens

while True:
    user_input = input("Q:")
    conversation.append({"role": "user", "content": user_input})
    conv_history_tokens = num_tokens_from_messages(conversation, model="gpt-4o")

    while conv_history_tokens + max_response_tokens >= token_limit:
        del conversation[1]
        conv_history_tokens = num_tokens_from_messages(conversation, model="gpt-4o")

    response = client.chat.completions.create(
        model="YOUR-DEPLOYMENT-NAME",
        messages=conversation,
        temperature=0.7,
        max_completion_tokens=max_response_tokens
    )

    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

import tiktoken
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),
    base_url="https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
)

system_message = {"role": "system", "content": "You are a helpful assistant."}
max_response_tokens = 250
token_limit = 4096
conversation = []
conversation.append(system_message)

def num_tokens_from_messages(messages, model="gpt-4o"):
    """Return the number of tokens used by a list of messages."""
    try:
        encoding = tiktoken.encoding_for_model(model)
    except KeyError:
        print("Warning: model not found. Using o200k_base encoding.")
        encoding = tiktoken.get_encoding("o200k_base")

    if model in {
        "gpt-4o",
        "gpt-4o-mini",
        "gpt-5",
        "gpt-4.1",
        "o1",
        "o1-mini",
        "o3",
        "o3-mini",
        "o4-mini",
    }:
        tokens_per_message = 3
        tokens_per_name = 1

    elif any(model.startswith(prefix) for prefix in [
        "gpt-4o-",
        "gpt-5-",
        "gpt-4.1-",
        "o1-",
        "o3-",
        "o4-mini-",
    ]):
        tokens_per_message = 3
        tokens_per_name = 1
    else:
        raise NotImplementedError(
            f"""num_tokens_from_messages() is not implemented for model {model}. """
        )

    num_tokens = 0
    for message in messages:
        num_tokens += tokens_per_message
        for key, value in message.items():
            num_tokens += len(encoding.encode(value))
            if key == "name":
                num_tokens += tokens_per_name
    num_tokens += 3
    return num_tokens

while True:
    user_input = input("Q:")
    conversation.append({"role": "user", "content": user_input})
    conv_history_tokens = num_tokens_from_messages(conversation, model="gpt-4o")

    while conv_history_tokens + max_response_tokens >= token_limit:
        del conversation[1]
        conv_history_tokens = num_tokens_from_messages(conversation, model="gpt-4o")

    response = client.chat.completions.create(
        model="YOUR-DEPLOYMENT-NAME",
        messages=conversation,
        temperature=0.7,
        max_completion_tokens=max_response_tokens
    )

    conversation.append({"role": "assistant", "content": response.choices[0].message.content})
    print("\n" + response.choices[0].message.content + "\n")

In questo esempio, dopo il raggiungimento del numero di token, i messaggi meno recenti nella trascrizione della conversazione vengono rimossi. Per l'efficienza, del viene usato invece di pop(). Si inizia con l'indice 1 per mantenere sempre il messaggio di sistema e rimuovere solo i messaggi utente o assistente. Nel corso del tempo, questo metodo di gestione della conversazione può causare un degrado della qualità della conversazione poiché il modello perde gradualmente il contesto delle parti precedenti della conversazione.

Un approccio alternativo consiste nel limitare la durata della conversazione alla lunghezza massima del token o a un numero specifico di turni. Dopo aver raggiunto il limite massimo di token, il modello perde il contesto se si vuole consentire la continuazione della conversazione. È possibile richiedere all'utente di iniziare una nuova conversazione e cancellare l'elenco dei messaggi per avviare una nuova conversazione con il limite di token completo disponibile.

La parte del conteggio dei token del codice illustrata in precedenza è una versione semplificata di uno degli esempi di cookbook di OpenAI.

Risoluzione dei problemi

Impossibile creare il completamento perché l'output Unicode generato dal modello non è valido

• Codice errore: 500
• Messaggio di errore:500 - InternalServerError: Error code: 500 - {"error": {"message": "Failed to create completion as the model generated invalid Unicode output"}}
• Soluzione: Ridurre la temperatura della richiesta a meno di 1 e usare un client con logica di ripetizione dei tentativi. I tentativi di ripetizione della richiesta hanno spesso esito positivo.

Errori comuni

• 401/403 (autenticazione): verifica la chiave API oppure verifica di avere accesso con Microsoft Entra ID alla risorsa OpenAI Azure.
• 400/404 (distribuzione non trovata): verificare che model corrisponda al nome della distribuzione.
• URL non valido: confermare che base_url termina con /openai/v1/.

Configurare

1. Creare una nuova applicazione console .NET:

   dotnet new console -n chat-completions
   cd chat-completions
   

2. Installare i pacchetti NuGet necessari:

   dotnet add package OpenAI
   dotnet add package Azure.Identity
   

   Il pacchetto OpenAI è stabile. Gli esempi Microsoft Entra ID usano un costruttore di autenticazione personalizzata sperimentale ed eliminano l'avvisoOPENAI001.

3. Per l'autenticazione senza chiave con Microsoft Entra ID, accedere a Azure:

   az login
   

Lavorare con i modelli di completamento della chat

Il frammento di codice seguente illustra il modo più semplice per interagire con i modelli che usano l'API Completamento chat.

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

ChatClient client = new(
    model: "YOUR-DEPLOYMENT-NAME",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
    }
);

ChatCompletion completion = await client.CompleteChatAsync(
[
    new SystemChatMessage("Assistant is a large language model trained by OpenAI."),
    new UserChatMessage("Who were the founders of Microsoft?"),
]);

Console.WriteLine(completion.Content[0].Text);

using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

ChatClient client = new(
    model: "YOUR-DEPLOYMENT-NAME",
    credential: new ApiKeyCredential(
        Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")),
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
    }
);

ChatCompletion completion = await client.CompleteChatAsync(
[
    new SystemChatMessage("Assistant is a large language model trained by OpenAI."),
    new UserChatMessage("Who were the founders of Microsoft?"),
]);

Console.WriteLine(completion.Content[0].Text);

Microsoft was founded by Bill Gates and Paul Allen. They established the company on April 4, 1975. Bill Gates served as the CEO of Microsoft until 2000 and later as Chairman and Chief Software Architect until his retirement in 2008, while Paul Allen left the company in 1983 but remained on the board of directors until 2000.

Ogni risposta include un oggetto FinishReason. I valori possibili per FinishReason sono:

• Stop: l'API ha restituito l'output completo del modello.
• Lunghezza: L'output del modello è incompleto a causa del parametro MaxOutputTokenCount o del limite di token.
• ContentFilter: contenuto omesso a causa di un flag del filtro del contenuto.
• ToolCalls: modello denominato strumento.
• FunctionCall: modello denominato funzione. Questo valore è deprecato.

Impostare MaxOutputTokenCount un valore sufficientemente elevato per la risposta prevista. Un valore superiore consente di impedire che il modello venga arrestato prima che raggiunga la fine del messaggio.

Lavorare con l'API Chat Completions

OpenAI ha addestrato modelli di completamento della chat per accettare input formattati come una conversazione. Il parametro messages accetta una matrice di oggetti messaggio con una conversazione organizzata per ruolo. Quando si utilizza il .NET SDK, vengono utilizzate classi di messaggi fortemente tipizzate per ogni ruolo.

Il formato di completamento di una chat di base è:

new SystemChatMessage("Provide some context and/or instructions to the model"),
new UserChatMessage("The user's message goes here")

Una conversazione con una risposta di esempio seguita da una domanda sarà simile alla seguente:

new SystemChatMessage("Provide some context and/or instructions to the model."),
new UserChatMessage("Example question goes here."),
new AssistantChatMessage("Example answer goes here."),
new UserChatMessage("First question/message for the model to actually respond to.")

Ruolo del sistema

Il ruolo di sistema, noto anche come messaggio di sistema, è incluso all'inizio della matrice. Questo messaggio fornisce le istruzioni iniziali per il modello. È possibile fornire varie informazioni nel ruolo del sistema, ad esempio:

• Breve descrizione dell'assistente.
• Tratti di personalità dell'assistente.
• Istruzioni o regole che si desidera che l'assistente segua.
• Dati o informazioni necessari per il modello, ad esempio le domande pertinenti da un elenco di domande frequenti.

Personalizza il ruolo di sistema per il tuo caso d’uso o includi istruzioni di base. Il messaggio di sistema è facoltativo, ma include almeno uno di base per ottenere i risultati migliori.

Messaggi

Dopo il ruolo di sistema, è possibile includere una serie di messaggi tra user e assistant.

new UserChatMessage("What is thermodynamics?")

Per attivare una risposta dal modello, terminare con un messaggio utente per indicare che è il turno dell'assistente per rispondere. È anche possibile includere una serie di messaggi di esempio tra l'utente e l'assistente come modo per eseguire l'apprendimento con pochi scatti.

Esempi di prompt dei messaggi

La sezione seguente mostra esempi di diversi stili di richieste che è possibile usare con i modelli di completamento della chat. Questi esempi sono solo un punto di partenza. È possibile sperimentare richieste diverse per personalizzare il comportamento per i propri casi d'uso.

Esempio di base

Se si vuole che il modello di completamento della chat si comporti in modo analogo a chatgpt.com, è possibile usare un messaggio di sistema di base, ad esempio Assistant is a large language model trained by OpenAI.

new SystemChatMessage("Assistant is a large language model trained by OpenAI."),
new UserChatMessage("Who were the founders of Microsoft?")

Esempio con istruzioni

Per alcuni scenari, è possibile fornire altre istruzioni al modello per definire protezioni per le operazioni che il modello è in grado di eseguire.

new SystemChatMessage(@"Assistant is an intelligent chatbot designed to help users answer their tax related questions.
Instructions:
- Only answer questions related to taxes.
- If you're unsure of an answer, you can say ""I don't know"" or ""I'm not sure"" and recommend users go to the IRS website for more information."),
new UserChatMessage("When are my taxes due?")

Usare i dati come base

È anche possibile includere dati o informazioni pertinenti nel messaggio di sistema per fornire al modello un contesto aggiuntivo per la conversazione. Se è necessario includere solo una piccola quantità di informazioni, è possibile impostarla come hardcoded nel messaggio di sistema. Se si dispone di una grande quantità di dati che il modello deve conoscere, è possibile usare embeddings o un prodotto come Azure AI Search per recuperare le informazioni più rilevanti in fase di query.

new SystemChatMessage(@"Assistant is an intelligent chatbot designed to help users answer technical questions about Azure OpenAI in Microsoft Foundry Models. Only answer questions using the context below and if you're not sure of an answer, you can say 'I don't know'.

Context:
- Azure OpenAI provides REST API access to OpenAI models, including GPT-5, GPT-4.1, and Embeddings model series.
- Azure OpenAI gives customers advanced language AI with GPT-5, GPT-image, and Embeddings models with the security and enterprise capabilities of Azure. Azure OpenAI co-develops the APIs with OpenAI, ensuring compatibility and a smooth transition between the services.
- At Microsoft, we're committed to the advancement of AI driven by principles that put people first. Microsoft has made significant investments to help guard against abuse and unintended harm, which includes requiring applicants to show well-defined use cases, incorporating Microsoft's principles for responsible AI use."),
new UserChatMessage("What is Azure OpenAI?")

Apprendimento few-shot con completamento chat

È anche possibile fornire esempi few-shot al modello. È possibile includere una serie di messaggi tra l'utente e l'assistente nel prompt come esempi di pochi scatti. Usando questi esempi, è possibile fornire risposte alle domande comuni per preparare il modello o impartire comportamenti specifici.

Questo esempio utilizza modelli attuali di completamento chat come gpt-5-mini e gpt-5.

new SystemChatMessage("Assistant is an intelligent chatbot designed to help users answer their tax related questions."),
new UserChatMessage("When do I need to file my taxes by?"),
new AssistantChatMessage("Check the current individual filing deadline at https://www.irs.gov/filing/individuals/when-to-file."),
new UserChatMessage("How can I check the status of my tax refund?"),
new AssistantChatMessage("Check your refund status at https://www.irs.gov/refunds.")

Utilizzare il completamento della chat per contesti che non riguardano la chat

L'API Chat Completions è progettata per funzionare con conversazioni a più turni, ma è adatta anche agli scenari non di chat.

Ad esempio, per uno scenario di estrazione di entità, è possibile usare il prompt seguente:

new SystemChatMessage(@"You are an assistant designed to extract entities from text. Users will paste in a string of text and you will respond with entities you've extracted from the text as a JSON object. Here's an example of your output format:
{
   ""name"": """",
   ""company"": """",
   ""phone_number"": """"
}"),
new UserChatMessage("Hello. My name is Robert Smith. I'm calling from Contoso Insurance, Delaware. My colleague mentioned that you are interested in learning about our comprehensive benefits policy. Could you give me a call back at (555) 346-9322 when you get a chance so we can go over the benefits?")

Creare un ciclo di conversazione di base

Gli esempi precedenti illustrano i meccanismi di base dell'interazione con l'API Completamento chat. In questo esempio viene illustrato come creare un ciclo di conversazione che esegue le azioni seguenti:

• Accetta continuamente l'input della console e lo formatta correttamente come parte dell'elenco di messaggi come contenuto del ruolo utente.
• Restituisce le risposte stampate nella console e formattate, e le aggiunge all'elenco dei messaggi come contenuto del ruolo di assistente.

Ogni volta che si pone una nuova domanda, la richiesta invia la trascrizione della conversazione in esecuzione insieme alla domanda più recente. Poiché il modello non ha memoria, inviare una trascrizione aggiornata con ogni domanda o il modello perde il contesto delle domande e delle risposte precedenti.

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

ChatClient client = new(
    model: "YOUR-DEPLOYMENT-NAME",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
    }
);

List<ChatMessage> conversation =
[
    new SystemChatMessage("You are a helpful assistant."),
];

while (true)
{
    Console.Write("Q: ");
    string? userInput = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(userInput)) break;

    conversation.Add(new UserChatMessage(userInput));

    ChatCompletion response = await client.CompleteChatAsync(conversation);
    string assistantMessage = response.Content[0].Text;

    conversation.Add(new AssistantChatMessage(assistantMessage));
    Console.WriteLine($"\n{assistantMessage}\n");
}

using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

ChatClient client = new(
    model: "YOUR-DEPLOYMENT-NAME",
    credential: new ApiKeyCredential(
        Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")),
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
    }
);

List<ChatMessage> conversation =
[
    new SystemChatMessage("You are a helpful assistant."),
];

while (true)
{
    Console.Write("Q: ");
    string? userInput = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(userInput)) break;

    conversation.Add(new UserChatMessage(userInput));

    ChatCompletion response = await client.CompleteChatAsync(conversation);
    string assistantMessage = response.Content[0].Text;

    conversation.Add(new AssistantChatMessage(assistantMessage));
    Console.WriteLine($"\n{assistantMessage}\n");
}

Quando si esegue il codice precedente, si ottiene una finestra della console vuota. Immettere la prima domanda nella finestra e quindi selezionare la Enter chiave. Dopo aver restituito la risposta, è possibile ripetere il processo e continuare a porre domande.

Gestire le conversazioni

L'esempio precedente viene eseguito fino a quando non viene raggiunto il limite di token del modello (finestra di contesto). Con ogni domanda e risposta ricevuta, l'elenco conversation aumenta di dimensioni. Il numero combinato di token dei messaggi più i token di output richiesti deve rimanere entro il limite del modello oppure la richiesta ha esito negativo. Per informazioni sui limiti correnti dei token, vedere la pagina dei modelli .

È responsabilità dell'utente assicurarsi che il prompt e il completamento rientrino nei limiti di token. Per conversazioni più lunghe, è necessario tenere traccia del numero di token e inviare solo al modello un prompt che rientra nel limite. In alternativa, con l'API delle risposte è possibile gestire automaticamente il troncamento e la gestione della cronologia delle conversazioni.

L'esempio di codice seguente taglia la conversazione a una soglia di dimostrazione di 4.096 token. Impostare TokenLimit sulla finestra di contesto del modello distribuito per l'uso in produzione. Nell'esempio vengono rimossi i messaggi non di sistema meno recenti per mantenere la conversazione entro limiti.

Installare i pacchetti Microsoft.ML.Tokenizers e Microsoft.ML.Tokenizers.Data.O200kBase per il conteggio accurato dei token:

dotnet add package Microsoft.ML.Tokenizers
dotnet add package Microsoft.ML.Tokenizers.Data.O200kBase

using Azure.Identity;
using Microsoft.ML.Tokenizers;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;

#pragma warning disable OPENAI001

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

ChatClient client = new(
    model: "YOUR-DEPLOYMENT-NAME",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
    }
);

const int MaxResponseTokens = 250;
const int TokenLimit = 4096;

var tokenizer = TiktokenTokenizer.CreateForModel("gpt-4o");

List<ChatMessage> conversation =
[
    new SystemChatMessage("You are a helpful assistant."),
];

static int CountTokens(TiktokenTokenizer tokenizer, IEnumerable<ChatMessage> messages)
{
    int count = 3; // base overhead for reply priming
    foreach (var message in messages)
    {
        count += 4; // per-message overhead
        string content = message switch
        {
            SystemChatMessage s => s.Content[0].Text ?? string.Empty,
            UserChatMessage u => u.Content[0].Text ?? string.Empty,
            AssistantChatMessage a => a.Content[0].Text ?? string.Empty,
            _ => string.Empty
        };
        count += tokenizer.CountTokens(content);
    }
    return count;
}

while (true)
{
    Console.Write("Q: ");
    string? userInput = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(userInput)) break;

    conversation.Add(new UserChatMessage(userInput));

    int historyTokens = CountTokens(tokenizer, conversation);
    while (historyTokens + MaxResponseTokens >= TokenLimit && conversation.Count > 2)
    {
        conversation.RemoveAt(1); // remove oldest non-system message
        historyTokens = CountTokens(tokenizer, conversation);
    }

    ChatCompletionOptions options = new() { MaxOutputTokenCount = MaxResponseTokens };
    ChatCompletion response = await client.CompleteChatAsync(conversation, options);
    string assistantMessage = response.Content[0].Text;

    conversation.Add(new AssistantChatMessage(assistantMessage));
    Console.WriteLine($"\n{assistantMessage}\n");
}

using Microsoft.ML.Tokenizers;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel;

ChatClient client = new(
    model: "YOUR-DEPLOYMENT-NAME",
    credential: new ApiKeyCredential(
        Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")),
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/")
    }
);

const int MaxResponseTokens = 250;
const int TokenLimit = 4096;

var tokenizer = TiktokenTokenizer.CreateForModel("gpt-4o");

List<ChatMessage> conversation =
[
    new SystemChatMessage("You are a helpful assistant."),
];

static int CountTokens(TiktokenTokenizer tokenizer, IEnumerable<ChatMessage> messages)
{
    int count = 3; // base overhead for reply priming
    foreach (var message in messages)
    {
        count += 4; // per-message overhead
        string content = message switch
        {
            SystemChatMessage s => s.Content[0].Text ?? string.Empty,
            UserChatMessage u => u.Content[0].Text ?? string.Empty,
            AssistantChatMessage a => a.Content[0].Text ?? string.Empty,
            _ => string.Empty
        };
        count += tokenizer.CountTokens(content);
    }
    return count;
}

while (true)
{
    Console.Write("Q: ");
    string? userInput = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(userInput)) break;

    conversation.Add(new UserChatMessage(userInput));

    int historyTokens = CountTokens(tokenizer, conversation);
    while (historyTokens + MaxResponseTokens >= TokenLimit && conversation.Count > 2)
    {
        conversation.RemoveAt(1); // remove oldest non-system message
        historyTokens = CountTokens(tokenizer, conversation);
    }

    ChatCompletionOptions options = new() { MaxOutputTokenCount = MaxResponseTokens };
    ChatCompletion response = await client.CompleteChatAsync(conversation, options);
    string assistantMessage = response.Content[0].Text;

    conversation.Add(new AssistantChatMessage(assistantMessage));
    Console.WriteLine($"\n{assistantMessage}\n");
}

In questo esempio, dopo il raggiungimento del numero di token, i messaggi meno recenti nella trascrizione della conversazione vengono rimossi. Il messaggio di sistema viene sempre mantenuto e vengono rimossi solo i messaggi utente o assistente. Nel corso del tempo, questo metodo di gestione della conversazione può causare un degrado della qualità della conversazione poiché il modello perde gradualmente il contesto delle parti precedenti della conversazione.

Un approccio alternativo consiste nel limitare la durata della conversazione alla lunghezza massima del token o a un numero specifico di turni. Dopo aver raggiunto il limite massimo di token, il modello perde il contesto se si vuole consentire la continuazione della conversazione. È possibile richiedere all'utente di iniziare una nuova conversazione e cancellare l'elenco dei messaggi per avviare una nuova conversazione con il limite di token completo disponibile.

Risoluzione dei problemi

Impossibile creare il completamento perché l'output Unicode generato dal modello non è valido

• Codice errore: 500
• Messaggio di errore:500 - InternalServerError: Error code: 500 - {"error": {"message": "Failed to create completion as the model generated invalid Unicode output"}}
• Soluzione alternativa: Impostare Temperature in ChatCompletionOptions su un valore inferiore a 1 e usare un client con logica di ritentativo. I tentativi di ripetizione della richiesta hanno spesso esito positivo.

Errori comuni

• 401/403 (autenticazione): verificare la chiave API e confermare di avere accesso a Microsoft Entra ID per utilizzare la risorsa OpenAI in Azure.
• 400/404 (distribuzione non trovata): verificare che il nome del modello passato al costruttore corrisponda al nome della ChatClient distribuzione.
• Endpoint non valido: verificare che l'URI Endpoint in OpenAIClientOptions punti a https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/.

Configurare

1. Installare Node.js 22 o versione successiva.

2. Creare un progetto TypeScript e installare i pacchetti necessari.

   npm init --yes
   npm install openai @azure/identity
   npm install --save-dev typescript tsx @types/node
   

3. Salvare ogni esempio completo come chat.tse quindi eseguirlo.

   npx tsx chat.ts
   

Lavorare con i modelli di completamento della chat

Gli esempi seguenti illustrano il modo di base per interagire con i modelli che usano l'API Completamento chat.

import {
  DefaultAzureCredential,
  getBearerTokenProvider,
} from "@azure/identity";
import OpenAI from "openai";

const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://ai.azure.com/.default",
);
const openai = new OpenAI({
  baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
  apiKey: tokenProvider,
});

const completion = await openai.chat.completions.create({
  model: "YOUR-DEPLOYMENT-NAME",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Who were the founders of Microsoft?" },
  ],
});

console.log(completion.choices[0]?.message.content);
console.log(`Finish reason: ${completion.choices[0]?.finish_reason}`);

import OpenAI from "openai";

const apiKey = process.env["AZURE_OPENAI_API_KEY"];
if (!apiKey) throw new Error("AZURE_OPENAI_API_KEY is required.");

const openai = new OpenAI({
  baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
  apiKey,
});

const completion = await openai.chat.completions.create({
  model: "YOUR-DEPLOYMENT-NAME",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Who were the founders of Microsoft?" },
  ],
});

console.log(completion.choices[0]?.message.content);
console.log(`Finish reason: ${completion.choices[0]?.finish_reason}`);

L'output seguente è rappresentativo. La formulazione esatta può variare:

Microsoft was founded by Bill Gates and Paul Allen.
Finish reason: stop

Per il modello client Azure OpenAI v1 completo, vedi l'esempio OpenAI Node Azure Chat Completions example.

Ogni risposta include finish_reason. I valori possibili sono:

• stop: l'API ha restituito l'output completo del modello.
• length: il modello si è interrotto a causa di max_completion_tokens o del limite di token.
• content_filter: Un filtro dei contenuti ha omesso dei contenuti.
• tool_calls: modello denominato strumento.
• function_call: modello denominato funzione. Questo valore è deprecato.

Per le risposte in streaming, finish_reason è null fino a quando il blocco finale non completa la risposta.

Impostare max_completion_tokens un valore sufficientemente elevato per la risposta prevista. Un valore superiore consente di impedire che il modello venga arrestato prima che raggiunga la fine del messaggio.

Lavorare con l'API Chat Completions

I modelli di completamento della chat accettano input formattato come conversazione. Il messages parametro accetta una matrice di oggetti messaggio con una conversazione organizzata per ruolo. Digitare la matrice come OpenAI.Chat.ChatCompletionMessageParam[] quando viene definita all'esterno della richiesta.

Il formato di completamento di una chat di base è:

const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
  { role: "system", content: "Provide context or instructions to the model." },
  { role: "user", content: "The user's message goes here." },
];

Una conversazione con una risposta di esempio seguita da una domanda è simile alla seguente:

const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
  { role: "system", content: "Provide context or instructions to the model." },
  { role: "user", content: "Example question goes here." },
  { role: "assistant", content: "Example answer goes here." },
  { role: "user", content: "First question for the model to answer." },
];

Ruolo del sistema

Includere il ruolo di sistema, noto anche come messaggio di sistema, all'inizio della matrice. Questo messaggio fornisce le istruzioni iniziali per il modello. Può definire lo scopo, il comportamento, le regole o i dati di base dell'assistente.

Il messaggio di sistema è facoltativo, ma include almeno uno di base per ottenere i risultati migliori.

Messaggi

Dopo il ruolo di sistema, includere una serie di messaggi tra user e assistant:

const message: OpenAI.Chat.ChatCompletionUserMessageParam = {
  role: "user",
  content: "What is thermodynamics?",
};

Terminare con un messaggio utente per indicare che è il turno dell'assistente per rispondere. È anche possibile includere messaggi di esempio tra l'utente e l'assistente per l'apprendimento con pochi scatti.

Esempi di prompt dei messaggi

Usare questi esempi come punti di partenza per le richieste che è possibile adattare all'applicazione.

Esempio di base

const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
  { role: "system", content: "You are a helpful assistant." },
  { role: "user", content: "Who were the founders of Microsoft?" },
];

Esempio con istruzioni

Usare il messaggio di sistema per definire i limiti per le risposte del modello:

const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
  {
    role: "system",
    content: `You help users answer tax-related questions.
Only answer questions about taxes.
If you don't know an answer, recommend the IRS website.`,
  },
  { role: "user", content: "When are my taxes due?" },
];

Usare i dati come base

Includere una piccola quantità di dati rilevanti nel messaggio di sistema per mettere a terra la risposta del modello:

const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
  {
    role: "system",
    content: `Answer only from this context. If the answer isn't present,
say "I don't know."

Context: Azure OpenAI provides REST API access to OpenAI models.`,
  },
  { role: "user", content: "What does Azure OpenAI provide?" },
];

Per set di dati di base più grandi, usare incorporamenti o Azure AI Search per recuperare le informazioni pertinenti in fase di richiesta.

Usare l'apprendimento few-shot

Includere messaggi utente e assistente di esempio prima della domanda finale:

const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
  { role: "system", content: "You help users answer tax questions." },
  { role: "user", content: "When do I need to file my taxes?" },
  { role: "assistant", content: "Check the current deadline at irs.gov." },
  { role: "user", content: "How can I check my refund status?" },
];

Utilizzare il completamento della chat per contesti che non riguardano la chat

L'API Completamento chat supporta anche attività non di chat, ad esempio l'estrazione di entità:

const messages: OpenAI.Chat.ChatCompletionMessageParam[] = [
  {
    role: "system",
    content: "Extract names and companies. Return a JSON object.",
  },
  {
    role: "user",
    content: "Robert Smith is calling from Contoso Insurance.",
  },
];

Creare un ciclo di conversazione di base

L'esempio seguente legge le domande dalla console, invia la conversazione completa al modello e aggiunge ogni risposta alla cronologia delle conversazioni. Poiché il modello non ha memoria, inviare la cronologia aggiornata a ogni richiesta.

import { stdin, stdout } from "node:process";
import { createInterface } from "node:readline/promises";
import {
  DefaultAzureCredential,
  getBearerTokenProvider,
} from "@azure/identity";
import OpenAI from "openai";

const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://ai.azure.com/.default",
);
const openai = new OpenAI({
  baseURL: "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",
  apiKey: tokenProvider,
});
const conversation: OpenAI.Chat.ChatCompletionMessageParam[] = [
  { role: "system", content: "You are a helpful assistant." },
];
const consoleInput = createInterface({ input: stdin, output: stdout });

while (true) {
  const question = await consoleInput.question("Q: ");
  if (!question.trim()) break;
  conversation.push({ role: "user", content: question });
  const response = await openai.chat.completions.create({
    model: "YOUR-DEPLOYMENT-NAME",
    messages: conversation,
  });
  const answer =
    response.choices[0]?.message.content ?? "No response returned.";
  conversation.push({ role: "assistant", content: answer });
  console.log(`\n${answer}\n`);
}
consoleInput.close();

Quando si esegue il codice, inserire una domanda al prompt Q:. Immettere una riga vuota per chiudere l'applicazione.

Gestire le conversazioni

Il ciclo di conversazione viene eseguito fino a quando la conversazione non raggiunge la finestra di contesto del modello. Il numero di token combinato di messages e l'output richiesto devono rimanere entro il limite del modello. Per i limiti correnti dei token, vedere la pagina dei modelli. OpenAI Node SDK segnala l'utilizzo dei token dopo ogni richiesta tramite response.usage, ma non include un tokenizer per stimare la richiesta successiva. Per stimare l'utilizzo dei token prima di una richiesta, scegliere un tokenizer che supporti il modello e la codifica e valutarlo prima dell'adozione.

Per conversazioni più lunghe, usare uno di questi approcci:

• Rimuovere i turni completi meno recenti dell'utente e dell'assistente, mantenendo il messaggio di sistema. Mantieni un margine di sicurezza prudente perché il numero di caratteri o di turni non corrisponde a un conteggio esatto dei token.
• Avviare una nuova conversazione dopo un numero fisso di turni.
• Usare l'API Risposte, che supporta lo stato della conversazione gestita dal server e il troncamento.

Risoluzione dei problemi

Impossibile creare il completamento perché l'output Unicode generato dal modello non è valido

• Codice errore: 500
• Messaggio di errore:Failed to create completion as the model generated invalid Unicode output
• Soluzione alternativa: Per i modelli che lo supportano, impostare temperature su un valore inferiore a 1. L’SDK Node di OpenAI tenta nuovamente la richiesta due volte in caso di errori di connessione e di errori HTTP selezionati, per impostazione predefinita. Impostare maxRetries sul OpenAI client per modificare questo comportamento.

Errori comuni

• 401/403 (autenticazione): verificare la chiave API o verificare che l'identità con accesso possa accedere alla risorsa Azure OpenAI.
• 400/404 (distribuzione non trovata): verificare che model corrisponda al nome della distribuzione.
• URL non valido: confermare che baseURL termina con /openai/v1/.