Generare risposte con l'API Risposte

Completato

L'API Risposte OoenAI riunisce le funzionalità di due API separate in precedenza (ChatCompletions e Assistenti) in un'esperienza unificata. Fornisce una generazione di risposta a più turni con stato, che lo rende ideale per le applicazioni di intelligenza artificiale conversazionale. È possibile accedere all'API Risposte tramite un client compatibile con OpenAI usando Foundry SDK o OpenAI SDK.

Informazioni sull'API Risposte

L'API Risposte offre diversi vantaggi rispetto ai completamenti delle chat tradizionali:

• Conversazioni con stato: mantiene il contesto della conversazione tra più turni
• Esperienza unificata: combina i completamenti delle chat e i modelli di API Assistenti
• Modelli diretti di Foundry: funziona con i modelli ospitati direttamente in Microsoft Foundry, non solo i modelli OpenAI di Azure
• Integrazione semplice: Accesso tramite il client compatibile con OpenAI

Annotazioni

L'API Risposte è l'approccio consigliato per generare risposte di intelligenza artificiale nelle applicazioni Microsoft Foundry. Sostituisce l'API ChatCompletions precedente per la maggior parte degli scenari.

Generazione di una risposta semplice

Con un client compatibile con OpenAI, è possibile generare risposte usando il metodo responses.create():

# Generate a response using the OpenAI-compatible client
response = openai_client.responses.create(
    model="gpt-4.1",  # Your model deployment name
    input="What is Microsoft Foundry?"
)

# Display the response
print(response.output_text)

Il parametro di input accetta una stringa di testo contenente il prompt. Il modello genera una risposta basata su questo input.

Informazioni sulla struttura delle risposte

Un oggetto risposta contiene diverse proprietà utili:

• output_text: risposta di testo generata
• id: identificatore univoco per questa risposta
• status: stato della risposta (ad esempio, "completato")
• utilizzo: informazioni sull'utilizzo dei token (input, output e token totali)
• model: modello usato per generare la risposta

È possibile accedere a queste proprietà per gestire in modo efficace le risposte.

response = openai_client.responses.create(
    model="gpt-4.1",
    input="Explain machine learning in simple terms."
)

print(f"Response: {response.output_text}")
print(f"Response ID: {response.id}")
print(f"Tokens used: {response.usage.total_tokens}")
print(f"Status: {response.status}")

Aggiunta di istruzioni

Oltre all'input dell'utente, è possibile fornire istruzioni (spesso definite prompt di sistema) per guidare il comportamento del modello:

response = client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="Explain neural networks."
)

print(response.output_text)

Controllo della generazione di risposte

È possibile controllare la generazione di risposte con parametri aggiuntivi:

response = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="Write a creative story about AI.",
    temperature=0.8,  # Higher temperature for more creativity
    max_output_tokens=200  # Limit response length
)

print(response.output_text)

• temperatura: controlla la casualità (0,0-2,0). Valori più elevati rendono l'output più creativo e vario
• max_output_tokens: limita il numero massimo di token nella risposta
• top_p: un'alternativa alla 'temperature' per controllare la casualità

Uso dei modelli diretti di Foundry

Quando si usa il client FoundrySDK o AzureOpenAI per connettersi a un endpoint di progetto , l'API Risposte funziona con entrambi i modelli OpenAI di Azure e i modelli diretti foundry (ad esempio Microsoft Phi, DeepSeek o altri modelli ospitati direttamente in Microsoft Foundry):

# Using a Foundry direct model
response = openai_client.responses.create(
    model="microsoft-phi-4",  # Example Foundry direct model
    instructions="You are a helpful AI assistant that answers questions clearly and concisely.",
    input="What are the benefits of small language models?"
)

print(response.output_text)

Creazione di esperienze di conversazione

Per scenari di conversazione più complessi, è possibile fornire istruzioni di sistema e creare conversazioni a più turni:

# First turn in the conversation
response1 = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that explains technology concepts clearly.",
    input="What is machine learning?"
)

print("Assistant:", response1.output_text)

# Continue the conversation
response2 = openai_client.responses.create(
    model="gpt-4.1",
    instructions="You are a helpful AI assistant that explains technology concepts clearly.",
    input="Can you give me an example?",
    previous_response_id=response1.id
)

print("Assistant:", response2.output_text)

In realtà, è probabile che l'implementazione venga costruita come ciclo in cui un utente può immettere in modo interattivo i messaggi in base a ogni risposta ricevuta dal modello:

# Track responses
last_response_id = None

# Loop until the user wants to quit
print("Assistant: Enter a prompt (or type 'quit' to exit)")
while True:
    input_text = input('\nYou: ')
    if input_text.lower() == "quit":
        print("Assistant: Goodbye!")
        break

    # Get a response
    response = openai_client.responses.create(
                model=model_name,
                instructions="You are a helpful AI assistant that explains technology concepts clearly.",
                input=input_text,
                previous_response_id=last_response_id
    )
    assistant_text = response.output_text
    print("\nAssistant:", assistant_text)
    last_response_id = response.id 

L'output di questo esempio è simile al seguente:

Assistant: Enter a prompt (or type 'quit' to exit)

You: What is machine learning?

Assistant: Machine learning is a type of artificial intelligence (AI) that enables computers to learn from data and improve their performance over time without being explicitly programmed. It involves training algorithms on large datasets to recognize patterns, make predictions, or take actions based on those patterns. This allows machines to become more accurate and efficient in their tasks as they are exposed to more data.

You: Can you give me an example?

Assistant: Certainly! Let's look at a simple example of supervised learning—predicting house prices based on features like size, location, and number of rooms.
Imagine you want to build a machine learning model that can predict the price of a house based on various factors.
...
    { the example provided in the model response may be extensive}
...

You: quit

Assistant: Goodbye!

Quando l'utente immette un nuovo input a ogni turno, i dati inviati al modello includono il messaggio di sistema Istruzioni , l'input dell'utente e la risposta precedente ricevuta dal modello. In questo modo, il nuovo input è radicato nel contesto fornito dalla risposta generata dal modello per l'input precedente.

Alternativa: concatenamento manuale delle conversazioni

È possibile gestire manualmente le conversazioni creando manualmente la cronologia dei messaggi. Questo approccio offre maggiore controllo su quale contesto viene incluso:

try:
    # Start with initial message
    conversation_history = [
        {
            "type": "message",
            "role": "user",
            "content": "What is machine learning?"
        }
    ]
    
    # First response
    response1 = openai_client.responses.create(
        model="gpt-4.1",
        input=conversation_history
    )
    
    print("Assistant:", response1.output_text)
    
    # Add assistant response to history
    conversation_history += response1.output
    
    # Add new user message
    conversation_history.append({
        "type": "message",
        "role": "user", 
        "content": "Can you give me an example?"
    })
    
    # Second response with full history
    response2 = openai_client.responses.create(
        model="gpt-4.1",
        input=conversation_history
    )
    
    print("Assistant:", response2.output_text)

except Exception as ex:
    print(f"Error: {ex}")

Questo approccio manuale è utile quando è necessario:

• Personalizzare i messaggi inclusi nel contesto
• Implementare la potatura delle conversazioni per gestire i limiti di token
• Archiviare e ripristinare la cronologia delle conversazioni da un database

Recupero di risposte precedenti specifiche

L'API Risposte mantiene la cronologia delle risposte, consentendo di recuperare le risposte precedenti:

try:   
   
    # Retrieve a previous response
    response_id = "resp_67cb61fa3a448190bcf2c42d96f0d1a8"  # Example ID
    previous_response = openai_client.responses.retrieve(response_id)
    
    print(f"Previous response: {previous_response.output_text}")

except Exception as ex:
    print(f"Error: {ex}")

Considerazioni sulla finestra di contesto

Il parametro previous_response_id collega le risposte, mantenendo il contesto della conversazione tra più chiamate API.

È importante notare che mantenere la cronologia delle conversazioni può aumentare l'utilizzo dei token. Per una singola esecuzione, la finestra del contesto attivo può includere:

• Istruzioni di sistema (istruzioni, regole di sicurezza)
• Prompt corrente
• Cronologia conversazioni (precedenti messaggi utente e assistente)
• Schemi degli strumenti (funzioni, specifiche OpenAPI, strumenti MCP e così via)
• Output degli strumenti (risultati della ricerca, output dell'interprete del codice, file)
• Memoria o documenti recuperati (da archivi di memoria, RAG, ricerca file)

Tutti questi elementi vengono concatenati, tokenizzati e inviati al modello insieme in ogni richiesta. L'SDK consente di gestire lo stato, ma non rende automaticamente più economico l'utilizzo dei token.

Creazione di app di chat responsive

Le risposte di un modello possono richiedere del tempo per generare a seconda di fattori come il modello specifico usato, le dimensioni della finestra di contesto e le dimensioni della richiesta. L'utente potrebbe diventare frustrante se l'app sembra "bloccarsi" durante l'attesa di una risposta, quindi è importante considerare la velocità di risposta dell'app nell'implementazione.

Risposte in streaming

Per le risposte lunghe, è possibile usare lo streaming per ricevere l'output in modo incrementale, in modo che l'utente visualizzi le risposte parzialmente complete man mano che l'output diventa disponibile:

stream = openai_client.responses.create(
    model="gpt-4.1",
    input="Write a short story about a robot learning to paint.",
    stream=True
)

for event in stream:
    print(event, end="", flush=True)

Se si sta monitorando la cronologia delle conversazioni durante lo streaming, è possibile ottenere l'ID risposta al termine del flusso, come illustrato di seguito:

stream = openai_client.responses.create(
    model="gpt-4.1",
    input="Write a short story about a robot learning to paint.",
    stream=True
)
for event in stream:
                if event.type == "response.output_text.delta":
                    print(event.delta, end="")
                elif event.type == "response.completed":
                    response_id = event.response.id

Utilizzo asincrono

Per le applicazioni ad alte prestazioni, è possibile usare un client asincrono che consente di effettuare chiamate API non bloccabili. L'utilizzo asincrono è ideale per le richieste a esecuzione prolungata o quando si desidera gestire più richieste contemporaneamente senza bloccare l'applicazione. Per usarlo, importare AsyncOpenAI anziché OpenAI e usare await con ogni chiamata API:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://<resource-name>.openai.azure.com/openai/v1/",
    api_key=token_provider,
)

async def main():
    response = await client.responses.create(
        model="gpt-4.1",
        input="Explain quantum computing briefly."
    )
    print(response.output_text)

asyncio.run(main())

Lo streaming asincrono funziona allo stesso modo:

async def stream_response():
    stream = await client.responses.create(
        model="gpt-4.1",
        input="Write a haiku about coding.",
        stream=True
    )
    
    async for event in stream:
        print(event, end="", flush=True)

asyncio.run(stream_response())

Usando l'API Risposte tramite Microsoft Foundry SDK, è possibile creare applicazioni di intelligenza artificiale conversazionali sofisticate che mantengono il contesto, supportano più tipi di modello e offrono un'esperienza utente reattiva.