Générer des réponses avec l’API Réponses

10 minutes

L’API Réponses OoenAI regroupe les fonctionnalités de deux API précédemment distinctes (ChatCompletions et Assistants) dans une expérience unifiée. Il autorise la production de réponses multitours avec gestion d’état, ce qui le rend particulièrement adapté aux applications d’IA conversationnelle. Vous pouvez accéder à l’API Réponses via un client compatible OpenAI à l’aide du Kit de développement logiciel (SDK) Foundry ou du Kit de développement logiciel (SDK) OpenAI.

Présentation de l’API Réponses

L’API Réponses offre plusieurs avantages par rapport aux achèvements de conversation traditionnels :

Stateful conversations : maintient le contexte de conversation à travers plusieurs interactions
Expérience unifiée : combine les achèvements de conversation et les modèles d’API Assistants
modèles directs Foundry : fonctionne avec des modèles hébergés directement dans Microsoft Foundry, pas seulement les modèles OpenAI d'Azure
intégration simple : Accès par le biais du client compatible OpenAI

Note

L’API Réponses est l’approche recommandée pour générer des réponses IA dans les applications Microsoft Foundry. Il remplace l’ANCIENNE API ChatCompletions pour la plupart des scénarios.

Génération d’une réponse simple

Avec un client compatible OpenAI, vous pouvez générer des réponses à l’aide de la méthode 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)

Le paramètre d’entrée accepte une chaîne de texte contenant votre invitation. Le modèle génère une réponse basée sur cette entrée.

Présentation de la structure de réponse

Un objet réponse contient plusieurs propriétés utiles :

output_text : réponse de texte générée
ID : identificateur unique pour cette réponse
état : État de la réponse (par exemple, « terminé »)
utilisation : informations d’utilisation des jetons (entrée, sortie et jetons totaux)
modèle : modèle utilisé pour générer la réponse

Vous pouvez accéder à ces propriétés pour gérer efficacement les réponses :

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

Ajout d’instructions

En plus de l’entrée utilisateur, vous pouvez fournir des instructions (souvent appelée 'invite système') pour guider le comportement du modèle :

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)

Contrôle de la génération de réponse

Vous pouvez contrôler la génération de réponse avec des paramètres supplémentaires :

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)

température : contrôle l’aléatoire (0,0-2,0). Les valeurs plus élevées rendent la sortie plus créative et variée
max_output_tokens : limite le nombre maximal de jetons dans la réponse
top_p : Alternative à la température pour contrôler la randomité

Utilisation directe de modèles Foundry

Lorsque vous utilisez le client FoundrySDK ou AzureOpenAI pour vous connecter à un point de terminaison de projet , l’API Réponses fonctionne avec les modèles Azure OpenAI et les modèles directs Foundry (tels que Microsoft Phi, DeepSeek ou d’autres modèles hébergés directement dans 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)

Création d’expériences conversationnelles

Pour les scénarios conversationnels plus complexes, vous pouvez fournir des instructions système et créer des conversations à plusieurs tours :

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

En réalité, l’implémentation est susceptible d’être construite en tant que boucle dans laquelle un utilisateur peut entrer des messages de manière interactive en fonction de chaque réponse reçue du modèle :

# 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

La sortie de cet exemple ressemble à ceci :

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!

Lorsque l’utilisateur entre une nouvelle entrée à chaque tour, les données envoyées au modèle incluent le message système Instructions , l’entrée de l’utilisateur et la réponse précédente reçue du modèle. De cette façon, la nouvelle entrée est ancrée dans le contexte fourni par la réponse générée par le modèle généré pour l’entrée précédente.

Alternative : Chaînage manuel des conversations

Vous pouvez gérer les conversations manuellement en créant vous-même l’historique des messages. Cette approche vous donne plus de contrôle sur le contexte inclus :

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

Cette approche manuelle est utile lorsque vous devez :

Personnaliser les messages inclus dans le contexte
Implémentez l’élagage des conversations afin de maîtriser les limites de jetons.
Stocker et restaurer l’historique des conversations à partir d’une base de données

Récupérer les réponses spécifiques précédentes

L’API Réponses gère l’historique des réponses, ce qui vous permet de récupérer les réponses précédentes :

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

Considérations relatives à la fenêtre de contexte

Le paramètre previous_response_id lie les réponses ensemble, en conservant le contexte de conversation entre plusieurs appels d’API.

Il est important de noter que la conservation de l’historique des conversations peut augmenter l’utilisation des jetons. Pour une seule exécution, la fenêtre de contexte active peut inclure :

Instructions système (instructions, règles de sécurité)
Votre instruction actuelle
Historique des conversations (anciens messages utilisateur + Assistant)
Schémas d’outil (fonctions, spécifications OpenAPI, outils MCP, etc.)
Sorties de l’outil (résultats de la recherche, sortie de l’interpréteur de code, fichiers)
Mémoire ou documents récupérés (à partir de magasins de mémoire, RAG, recherche de fichiers)

Toutes ces opérations sont concaténées, tokenisées et envoyées au modèle ensemble sur chaque requête. Le Kit de développement logiciel (SDK) vous aide à gérer l’état, mais il ne rend pas automatiquement l’utilisation des jetons moins coûteuse.

Création d’applications de conversation réactives

Les réponses d’un modèle peuvent prendre un certain temps pour générer en fonction de facteurs tels que le modèle spécifique utilisé, la taille de la fenêtre de contexte et la taille de l’invite. Les utilisateurs peuvent devenir frustrés si l’application semble « figer » en attendant une réponse. Il est donc important de prendre en compte la réactivité de l’application dans votre implémentation.

Réponses en streaming

Pour les réponses longues, vous pouvez utiliser la diffusion en continu pour recevoir la sortie de manière incrémentielle. Ainsi, l’utilisateur voit des réponses partiellement complètes à mesure que la sortie devient disponible :

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)

Si vous effectuez le suivi de l’historique des conversations lors de la diffusion en continu, vous pouvez obtenir l’ID de réponse lorsque le flux se termine, comme suit :

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

Utilisation asynchrone

Pour les applications hautes performances, vous pouvez utiliser un client asynchrone qui vous permet d’effectuer des appels d’API non bloquants. L’utilisation asynchrone est idéale pour les requêtes de longue durée ou lorsque vous souhaitez gérer plusieurs requêtes simultanément sans bloquer votre application. Pour l’utiliser, importez AsyncOpenAI au lieu de OpenAI et utilisez await avec chaque appel d'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())

Le streaming asynchrone fonctionne de la même façon :

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

À l’aide de l’API Réponses via le Kit de développement logiciel (SDK) Microsoft Foundry, vous pouvez créer des applications d’IA conversationnelles sophistiquées qui gèrent le contexte, prennent en charge plusieurs types de modèles et fournissent une expérience utilisateur réactive.

Commentaires

Cette page a-t-elle été utile ?