Antwoorden genereren met de Antwoorden-API

10 minuten

De OoenAI Response-API combineert mogelijkheden van twee eerder afzonderlijke API's (ChatCompletions en Assistenten) in een uniforme ervaring. Het biedt stateful, multi-turn respons generatie, waardoor het ideaal is voor conversationele AI-toepassingen. U kunt de antwoorden-API openen via een openAI-compatibele client met behulp van de Foundry SDK of de OpenAI SDK.

Inzicht in de antwoorden-API

De Response-API biedt verschillende voordelen ten opzichte van traditionele chat-voltooiingen:

Stateful gesprekken: houdt de gesprekscontext over meerdere beurten bij
Geïntegreerde ervaring: combineert chatvoltooiingen en API-patronen voor assistenten
Foundry directe modellen: Werkt met modellen die rechtstreeks worden gehost in Microsoft Foundry, niet alleen Azure OpenAI-modellen
Eenvoudige integratie: Toegang via de OpenAI-compatibele client

Opmerking

De Antwoorden-API is de aanbevolen benadering voor het genereren van AI-antwoorden in Microsoft Foundry-toepassingen. Deze vervangt de oudere ChatCompletions-API voor de meeste scenario's.

Een eenvoudig antwoord genereren

Met een openAI-compatibele client kunt u antwoorden genereren met behulp van de methode 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)

De invoerparameter accepteert een tekenreeks met uw prompt. Het model genereert een antwoord op basis van deze invoer.

Inzicht in antwoordstructuur

Een antwoordobject bevat verschillende nuttige eigenschappen:

output_text: het gegenereerde tekstantwoord
id: unieke id voor dit antwoord
status: Antwoordstatus (bijvoorbeeld 'voltooid')
gebruik: Gebruiksgegevens van tokens (invoer, uitvoer en totaaltokens)
model: Het model dat wordt gebruikt om het antwoord te genereren

U kunt deze eigenschappen benaderen om antwoorden effectief te verwerken.

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

Instructies toevoegen

Naast de gebruikersinvoer kunt u instructies opgeven (ook wel systeemprompt genoemd) om het gedrag van het model te begeleiden:

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)

Het genereren van antwoorden beheren

U kunt het genereren van antwoorden beheren met aanvullende parameters:

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)

temperatuur: Bepaalt willekeurigheid (0,0-2.0). Hogere waarden maken uitvoer creatiever en gevarieerder
max_output_tokens: beperkt het maximum aantal tokens in het antwoord
top_p: Alternatief voor temperatuur voor het beheren van willekeurigheid

Werken met directe Foundry-modellen

Wanneer u de FoundrySDK- of AzureOpenAI-client gebruikt om verbinding te maken met een projecteindpunt , werkt de Response-API met zowel Azure OpenAI-modellen als Foundry directe modellen (zoals Microsoft Phi, DeepSeek of andere modellen die rechtstreeks in Microsoft Foundry worden gehost):

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

Gesprekservaringen maken

Voor complexere gespreksscenario's kunt u systeeminstructies opstellen en gesprekken met meerdere uitwisselingen bouwen.

# 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 werkelijkheid is de implementatie waarschijnlijk opgebouwd als een lus waarin een gebruiker interactief berichten kan invoeren op basis van elk antwoord dat is ontvangen van het model:

# 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

De uitvoer van dit voorbeeld ziet er ongeveer als volgt uit:

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!

Wanneer de gebruiker op elke beurt nieuwe invoer invoer invoert, bevatten de gegevens die naar het model worden verzonden het systeembericht Instructies , de invoer van de gebruiker en het vorige antwoord dat van het model is ontvangen. Op deze manier wordt de nieuwe invoer geaard in de context die wordt geleverd door het antwoord dat het model heeft gegenereerd voor de vorige invoer.

Alternatief: Handmatige gespreksketen

U kunt gesprekken handmatig beheren door de berichtgeschiedenis zelf te bouwen. Met deze aanpak heb je meer controle over welke context is inbegrepen.

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

Deze handmatige benadering is handig wanneer u het volgende moet doen:

Welke berichten in context worden opgenomen aanpassen
Gesprekssnoeiing implementeren om tokenlimieten te beheren
Gespreksgeschiedenis opslaan en herstellen vanuit een database

Specifieke eerdere antwoorden ophalen

De Antwoorden-API onderhoudt de antwoordgeschiedenis, zodat u eerdere antwoorden kunt ophalen:

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

Overwegingen voor contextvensters

De previous_response_id parameter koppelt antwoorden aan elkaar, waarbij de gesprekscontext tussen meerdere API-aanroepen wordt gehandhaafd.

Het is belangrijk te weten dat het bijhouden van de gespreksgeschiedenis het tokengebruik kan verhogen. Voor één uitvoering kan het actieve contextvenster het volgende omvatten:

Systeeminstructies (instructies, veiligheidsregels)
Uw huidige prompt
Gespreksgeschiedenis (vorige berichten van gebruiker en assistent)
Hulpprogrammaschema's (functies, OpenAPI-specificaties, MCP-hulpprogramma's, enzovoort)
Uitvoer van hulpprogramma's (zoekresultaten, uitvoer van code-interpreter, bestanden)
Opgehaald geheugen of documenten (uit geheugenarchieven, RAG, zoeken naar bestanden)

Al deze worden samengevoegd, getokeniseerd en samen naar het model verzonden bij elk verzoek. Met de SDK kunt u de status beheren, maar het tokengebruik wordt niet automatisch goedkoper.

Responsieve chat-apps maken

Antwoorden van een model kunnen enige tijd in beslag nemen om te genereren, afhankelijk van factoren zoals het specifieke model dat wordt gebruikt, de grootte van het contextvenster en de grootte van de prompt. Gebruikers kunnen gefrustreerd raken als de app lijkt te 'blokkeren' tijdens het wachten op een reactie, dus het is belangrijk om rekening te houden met de reactiesnelheid van apps in uw implementatie.

Streamingantwoorden

Voor lange antwoorden kunt u streaming gebruiken om incrementeel uitvoer te ontvangen, zodat de gebruiker gedeeltelijk volledige antwoorden ziet wanneer de uitvoer beschikbaar is:

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)

Als u de gespreksgeschiedenis bijhoudt bij het streamen, kunt u de antwoord-id ophalen wanneer de stream eindigt, zoals deze:

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

Asynchroon gebruik

Voor toepassingen met hoge prestaties kunt u een asynchrone client gebruiken waarmee u niet-blokkerende API-aanroepen kunt maken. Asynchroon gebruik is ideaal voor langlopende aanvragen of wanneer u meerdere aanvragen gelijktijdig wilt verwerken zonder uw toepassing te blokkeren. Importeer AsyncOpenAI in plaats van OpenAI en gebruik await bij elke API-aanroep.

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

Asynchroon streamen werkt op dezelfde manier:

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

Met behulp van de Response-API via de Microsoft Foundry SDK kunt u geavanceerde conversationele AI-toepassingen bouwen die context onderhouden, meerdere modeltypen ondersteunen en een responsieve gebruikerservaring bieden.

Feedback

Is deze pagina nuttig?