Generieren von Antworten mit der Antwort-API

Die OoenAI-Antwort-API vereint Funktionen aus zwei zuvor separaten APIs (ChatCompletions und Assistants) in einer einheitlichen Umgebung. Es bietet zustandsbehaftete, mehrfach-Turn Antwortgenerierung, die es ideal für Unterhaltung-KI-Anwendungen macht. Sie können über einen openAI-kompatiblen Client über das Foundry SDK oder das OpenAI SDK auf die Antwort-API zugreifen.

Grundlegendes zur Antwort-API

Die Antwort-API bietet gegenüber herkömmlichen Chatabschlussen mehrere Vorteile:

• Zustandsbehaftete Unterhaltungen: Verwaltet den Unterhaltungskontext über mehrere Wendungen hinweg
• Einheitliche Benutzeroberfläche: Kombiniert Chatabschlusse und API-Muster für Assistenten
• Foundry Direct Models: Arbeitet mit Modellen, die direkt in Microsoft Foundry gehostet werden, nicht nur Azure OpenAI-Modelle
• Einfache Integration: Zugriff über den OpenAI-kompatiblen Client

Generieren einer einfachen Antwort

Mit einem openAI-kompatiblen Client können Sie Antworten mithilfe der Methode "responses.create()" generieren:

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

Der Eingabeparameter akzeptiert eine Textzeichenfolge, die Ihre Eingabeaufforderung enthält. Das Modell generiert eine Antwort basierend auf dieser Eingabe.

Grundlegendes zur Antwortstruktur

Ein Antwortobjekt enthält mehrere nützliche Eigenschaften:

• output_text: Die generierte Textantwort
• ID: Eindeutiger Bezeichner für diese Antwort
• status: Antwortstatus (z. B. "abgeschlossen")
• Verwendung: Tokenverwendungsinformationen (Eingabe-, Ausgabe- und Gesamttoken)
• Modell: Das Modell, das zum Generieren der Antwort verwendet wird

Sie können auf diese Eigenschaften zugreifen, um Antworten effektiv zu verarbeiten.

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

Hinzufügen von Anweisungen

Zusätzlich zur Benutzereingabe können Sie Anweisungen (häufig als Systemaufforderung bezeichnet) bereitstellen, um das Verhalten des Modells zu leiten:

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)

Steuern der Reaktionsgenerierung

Sie können die Reaktionsgenerierung mit zusätzlichen Parametern steuern:

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: Steuert die Zufallsvariabilität (0,0-2,0). Höhere Werte machen die Ausgabe kreativer und abwechslungsreicher
• max_output_tokens: Beschränkt die maximale Anzahl von Token in der Antwort.
• top_p: Alternative zur Temperatur zur Steuerung der Zufälligkeit

Arbeiten mit direkten Foundry-Modellen

Wenn Sie den FoundrySDK- oder AzureOpenAI-Client verwenden, um eine Verbindung mit einem Projektendpunkt herzustellen, funktioniert die Antwort-API sowohl mit Azure OpenAI-Modellen als auch mit direkten Foundry-Modellen (z. B. Microsoft Phi, DeepSeek oder anderen Modellen, die direkt in Microsoft Foundry gehostet werden):

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

Gestaltung von Gesprächserlebnissen

Für komplexere Unterhaltungsszenarien können Sie Systeminstruktionen geben und mehrstufige Gespräche erstellen.

# 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 Wirklichkeit wird die Implementierung wahrscheinlich als Schleife erstellt, in der ein Benutzer basierend auf jeder antwort, die vom Modell empfangen wird, interaktiv Nachrichten eingeben kann:

# 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 

Die Ausgabe dieses Beispiels sieht ähnlich aus wie diese:

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!

Wenn der Benutzer jeweils neue Eingaben eingibt, enthält die an das Modell gesendeten Daten die Meldung des Systems "Anweisungen ", die Eingabe des Benutzers und die vorherige Antwort, die vom Modell empfangen wurde. Auf diese Weise wird die neue Eingabe im Kontext der Antwort verankert, die das Modell für die vorherige Eingabe generiert hat.

Alternative: Manuelle Verkettung von Unterhaltungen

Sie können Unterhaltungen manuell verwalten, indem Sie den Nachrichtenverlauf selbst erstellen. Mit diesem Ansatz können Sie besser steuern, welcher Kontext enthalten ist:

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

Dieser manuelle Ansatz ist nützlich, wenn Sie:

• Anpassen, welche Nachrichten im Kontext enthalten sind
• Implementierung der Konversationsbereinigung zur Verwaltung von Tokenbeschränkungen
• Speichern und Wiederherstellen des Unterhaltungsverlaufs aus einer Datenbank

Abrufen bestimmter vorheriger Antworten

Die Antwort-API verwaltet den Antwortverlauf, sodass Sie frühere Antworten abrufen können:

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

Überlegungen zu Kontextfenstern

Der previous_response_id Parameter verknüpft Antworten miteinander, wobei der Unterhaltungskontext über mehrere API-Aufrufe hinweg beibehalten wird.

Es ist wichtig zu wissen, dass das Führen einer Historie über die Kommunikation die Verwendung von Token erhöhen kann. Bei einer einzelnen Ausführung kann das aktive Kontextfenster Folgendes umfassen:

• Systemanweisungen (Anweisungen, Sicherheitsregeln)
• Ihre aktuelle Eingabeaufforderung
• Aufgezeichnete Unterhaltungen (vorherige Benutzer- und Assistentennachrichten)
• Toolschemas (Funktionen, OpenAPI-Spezifikationen, MCP-Tools usw.)
• Toolausgabe (Suchergebnisse, Codedolmetscherausgabe, Dateien)
• Abgerufene Speicher oder Dokumente (aus Speicher, RAG, Dateisuche)

Bei jeder Anforderungen werden alle diese verkettet, tokenisiert und an das Modell gesendet. Das SDK hilft Ihnen beim Verwalten des Zustands, macht die Tokenverwendung jedoch nicht automatisch billiger.

Erstellen reaktionsfähiger Chat-Apps

Antworten eines Modells können je nach verwendetem Modell, Kontextfenstergröße und Eingabeaufforderungsgröße einige Zeit dauern. Benutzer können frustriert werden, wenn die App beim Warten auf eine Antwort "einfriert" erscheint. Daher ist es wichtig, in Ihrer Implementierung die Reaktionsfähigkeit der App zu berücksichtigen.

Antworten bei Streaming-Diensten

Bei langen Antworten können Sie Streaming verwenden, um die Ausgabe inkrementell zu empfangen – sodass der Benutzer teilweise vollständige Antworten sieht, wenn die Ausgabe verfügbar wird:

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)

Wenn Sie beim Streaming aufgezeichnete Unterhaltungen nachverfolgen, können Sie die Antwort-ID abrufen, wenn der Datenstrom endet, wie folgt:

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

Asynchrone Verwendung

Für Hochleistungsanwendungen können Sie einen asynchronen Client verwenden, der es Ihnen ermöglicht, nicht blockierende API-Aufrufe zu tätigen. Die asynchrone Verwendung eignet sich ideal für lange laufende Anforderungen oder, wenn Sie mehrere Anforderungen gleichzeitig verarbeiten möchten, ohne dass Ihre Anwendung blockiert wird. Um sie zu verwenden, importieren Sie AsyncOpenAI anstelle von OpenAI und verwenden Sie await bei jedem API-Aufruf.

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

Asynchrones Streaming funktioniert auf die gleiche Weise:

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

Mithilfe der Antwort-API über das Microsoft Foundry SDK können Sie anspruchsvolle KI-Anwendungen für Unterhaltungen erstellen, die Kontext verwalten, mehrere Modelltypen unterstützen und eine reaktionsfähige Benutzererfahrung bieten.