Generera svar med svars-API:et

10 minuter

API:et för OoenAI-svar samlar funktioner från två tidigare separata API:er (ChatCompletions och Assistants) i en enhetlig upplevelse. Den ger tillståndsbevarande, flerstegs svarsgenerering, vilket gör den idealisk för konversations-AI-applikationer. Du kan komma åt svars-API:et via en OpenAI-kompatibel klient med antingen Foundry SDK eller OpenAI SDK.

Förstå API:et för svar

Svars-API:et erbjuder flera fördelar jämfört med traditionella chattavslutningar:

Tillståndsbevarande konversationer: Upprätthåller konversationskontext över flera omgångar
Enhetlig upplevelse: Kombinerar mönster för chattkompletteringar och assistent-API:er
Foundry-direktmodeller: Fungerar med modeller som finns direkt i Microsoft Foundry, inte bara Azure OpenAI-modeller
Enkel integrering: Åtkomst genom den OpenAI-kompatibla klienten

Anmärkning

Svars-API:et är den rekommenderade metoden för att generera AI-svar i Microsoft Foundry-program. Det ersätter det äldre ChatCompletions-API:et för de flesta scenarier.

Generera ett enkelt svar

Med en OpenAI-kompatibel klient kan du generera svar med metoden 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)

Indataparametern accepterar en textsträng som innehåller din fråga. Modellen genererar ett svar baserat på dessa indata.

Förstå svarsstrukturen

Ett svarsobjekt innehåller flera användbara egenskaper:

output_text: Det genererade textsvaret
id: Unik identifierare för det här svaret
status: Svarsstatus (till exempel "slutförd")
användning: Information om tokenanvändning (indata, utdata och totalt antal token)
modell: Den modell som används för att generera svaret

Du kan komma åt dessa egenskaper för att hantera svaren effektivt.

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

Lägga till instruktioner

Förutom användarindata kan du ge instruktioner (kallas ofta systemprompt) för att vägleda modellens beteende:

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)

Kontrollera generering av svar

Du kan styra svarsgenereringen med ytterligare parametrar:

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)

temperatur: Styr slumpmässighet (0,0-2,0). Högre värden gör utdata mer kreativa och varierande
max_output_tokens: Begränsar det maximala antalet token i svaret
top_p: Alternativ till temperatur för att kontrollera slumpmässighet

Arbeta med Foundry-direktmodeller

När du använder FoundrySDK- eller AzureOpenAI-klienten för att ansluta till en projektslutpunkt fungerar Svars-API:et med både Azure OpenAI-modeller och Foundry-direktmodeller (till exempel Microsoft Phi, DeepSeek eller andra modeller som finns direkt i 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)

Skapa konversationsupplevelser

För mer komplexa konversationsscenarier kan du tillhandahålla systeminstruktioner och skapa konversationer med flera turer:

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

I verkligheten kommer implementeringen sannolikt att konstrueras som en loop där en användare interaktivt kan ange meddelanden baserat på varje svar som tas emot från modellen:

# 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

Utdata från det här exemplet ser ut ungefär så här:

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!

När användaren anger nya indata i varje tur innehåller de data som skickas till modellen systemmeddelandet Instruktioner , indata från användaren och det tidigare svaret som togs emot från modellen. På så sätt baseras de nya indata i kontexten som tillhandahålls av svaret som modellen genererade för föregående indata.

Alternativ: Manuell konversationslänkning

Du kan hantera konversationer manuellt genom att skapa meddelandehistoriken själv. Den här metoden ger dig mer kontroll över vilken kontext som ingår:

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

Den här manuella metoden är användbar när du behöver:

Anpassa vilka meddelanden som ingår i kontexten
Implementera konversationsrensning för att hantera tokengränser
Lagra och återställa konversationshistorik från en databas

Hämtar specifika tidigare svar

Svars-API:et upprätthåller svarshistoriken så att du kan hämta tidigare svar:

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

Överväganden för kontextfönster

Parametern previous_response_id länkar ihop svar och upprätthåller konversationskontexten över flera API-anrop.

Det är viktigt att observera att om du behåller konversationshistoriken kan tokenanvändningen öka. För en enda körning kan det aktiva kontextfönstret innehålla:

Systeminstruktioner (instruktioner, säkerhetsregler)
Din aktuella uppmaning
Konversationshistorik (tidigare meddelanden från användare och assistent)
Verktygsscheman (funktioner, OpenAPI-specifikationer, MCP-verktyg osv.)
Verktygsutdata (sökresultat, kodtolkutdata, filer)
Hämtat minne eller dokument (från minneslager, RAG, filsökning)

Alla dessa sammanfogas, tokeniseras och skickas till modellen tillsammans på varje begäran. SDK:t hjälper dig att hantera tillstånd, men det gör inte automatiskt tokenanvändningen billigare.

Skapa dynamiska chattappar

Svar från en modell kan ta lite tid att generera beroende på faktorer som den specifika modell som används, kontextfönstrets storlek och storleken på prompten. Användarens kan bli frustrerad om appen verkar "frysa" i väntan på ett svar, så det är viktigt att överväga appresponsivitet i implementeringen.

Direktuppspelningssvar

För långa svar kan du använda direktuppspelning för att ta emot utdata stegvis – så att användaren ser delvis fullständiga svar när utdata blir tillgängliga:

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)

Om du spårar konversationshistorik vid strömning kan du få svars-ID:t när strömmen slutar, så här:

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

Asynkron användning

För program med höga prestanda kan du använda en asynkron klient som gör att du kan göra icke-blockerande API-anrop. Asynkron användning är perfekt för tidskrävande begäranden eller när du vill hantera flera begäranden samtidigt utan att blockera ditt program. Om du vill använda det importerar AsyncOpenAI du i stället för OpenAI och använder await med varje API-anrop:

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

Asynkron strömning fungerar på samma sätt:

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

Genom att använda svars-API :et via Microsoft Foundry SDK kan du skapa avancerade konversations-AI-program som upprätthåller kontext, stöder flera modelltyper och ger en dynamisk användarupplevelse.

Feedback

Var den här sidan till hjälp?