OpenAI Antworten API: Der ultimative Leitfaden für Entwickler

Was ist die Antwort-API von OpenAI?

Die Responses API ist die neueste und fortschrittlichste API von OpenAI. Sie vereint die Stärken der Chat Completions- und Assistenten-APIs in einer einzigen, optimierten Schnittstelle. Sie wurde im März 2025 veröffentlicht und behält die bekannten Funktionen bei, bietet aber einen stärker integrierten Ansatz für die Entwicklung von KI-Anwendungen. 

Die wichtigste Innovation ist die Vereinfachung der Entwicklung durch die automatische Handhabung der Orchestrierungslogik und die native Integration von OpenAIs eingebauten Tools für die Web- und Dateisuche, ohne dass eine eigene Implementierung erforderlich ist.

In diesem Tutorial zeigen wir dir, wie du die Responses API in deinen Projekten nutzen kannst. Du wirst sehen, wie es mit der Texterstellung umgeht, mit Bildern arbeitet und Streaming-Antworten liefert. Wir werden uns die eingebauten Tools ansehen, die die Entwicklung schneller und einfacher machen als bisher, und dir zeigen, wie diese Tools im Rahmen der API zusammenarbeiten. 

Am Ende dieses Leitfadens wirst du wissen, wann du die Responses API anstelle anderer OpenAI-Optionen verwenden solltest und wie du mit diesem Wissen effizientere Anwendungen mit weniger Code und Aufwand erstellen kannst. Wenn du die OpenAI API noch nicht kennst, schau dir unseren Einführungskurs an, Arbeiten mit der OpenAI APIum mit der Entwicklung von KI-gestützten Anwendungen zu beginnen.

Erste Schritte mit der Antwort-API

Die Responses-API bietet eine schlankere und benutzerfreundlichere Schnittstelle für die Interaktion mit den Modellen von OpenAI, die eine elegante Lösung für die bisher umständliche und komplexe Syntax bietet. 

Bevor wir uns mit konkreten Anwendungsfällen beschäftigen, wollen wir unsere Umgebung einrichten und die grundlegende Syntax verstehen.

from openai import OpenAI
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Initialize the client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

Bei diesem Initialisierungsschritt wird ein Client-Objekt erstellt, das alle deine API-Anfragen bearbeiten wird. Das Paket dotenv hilft dir, deinen API-Schlüssel sicher über Umgebungsvariablen zu verwalten, anstatt ihn fest in dein Skript zu kodieren - eine bewährte Methode, die deinen Code in verschiedenen Umgebungen portabel und sicher macht.

Inhalte mit der Antwort-API generieren

Die einfachste Anwendung der Antwort-API ist die Erstellung von Textinhalten. Schauen wir uns ein reales Szenario an: Angenommen, du baust eine E-Commerce-Plattform auf und musst automatisch überzeugende Produktbeschreibungen auf der Grundlage grundlegender Produktdetails erstellen.

Traditionell würde dies eine sorgfältige , prompte Entwicklung und mehrere Iterationen erfordern. Mit der Antwort-API kannst du eine einfache Funktion erstellen, die dies auf elegante Weise erledigt:

def generate_product_description(product_name, features, target_audience):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a professional copywriter specialized in creating concise, compelling product descriptions. Focus on benefits rather than just features.",
       input=f"""
       Create a product description for {product_name}.
       Key features:
       - {features[0]}
       - {features[1]}
       - {features[2]}
       Target audience: {target_audience}
       Keep it under 150 words.
       """,
       temperature=0.7,
       max_output_tokens=200
   )
  
   return response.output_text

# Example usage
headphones_desc = generate_product_description(
   "NoiseGuard Pro Headphones",
   ["Active noise cancellation", "40-hour battery life", "Memory foam ear cushions"],
   "Business travelers and remote workers"
)

print(headphones_desc)

Ausgabe:

Experience unparalleled focus and comfort with NoiseGuard Pro Headphones—your perfect travel and work companion. 
Designed for business travelers and remote workers, these headphones feature cutting-edge active noise cancellation to block out distractions, allowing you to concentrate on what truly matters. 
With an impressive 40-hour battery life, you can enjoy uninterrupted productivity or relaxation on even the longest journeys. 
The luxurious memory foam ear cushions ensure a snug, comfortable fit for all-day wear, reducing fatigue and enhancing your listening experience. 
Elevate your work and travel with NoiseGuard Pro—where clarity meets comfort.

Mit nur ein paar Zeilen Code haben wir Texte in Marketingqualität erstellt, für die normalerweise ein professioneller Autor nötig wäre. Die Funktion ist auch wiederverwendbar - ändere einfach die Parameter, und du kannst Beschreibungen für jedes Produkt in deinem Katalog erstellen.

Dieses Beispiel zeigt die wichtigsten Muster bei der Verwendung der Antwort-API:

1. Der Parameter instructions dient als System-Prompt, der das Verhalten und den Kontext der KI bestimmt.
2. Der Parameter temperature (0-2) steuert die Zufälligkeit - niedrigere Werte erzeugen deterministischere Ergebnisse, während höhere Werte mehr Kreativität einbringen.
3. Der Parameter max_output_tokens begrenzt die Länge der Antwort, was hilft, die Kosten zu kontrollieren und prägnante Ergebnisse zu gewährleisten.
4. Das Antwortobjekt enthält den erzeugten Text in der Eigenschaft output_text.

Analyse von Bildern für praktische Anwendungen

Viele reale Anwendungen müssen sowohl Text als auch Bilder verarbeiten. E-Commerce-Plattformen müssen zum Beispiel Produktfotos analysieren, Content-Moderationssysteme müssen Uploads überprüfen und Social-Media-Anwendungen müssen visuelle Inhalte verstehen.

Die Responses API eignet sich hervorragend für multimodale Aufgaben wie die Bildanalyse, ohne dass separate Endpunkte oder komplexer Integrationscode erforderlich sind:

def analyze_product_image(image_url):
   response = client.responses.create(
       model="gpt-4o",
       instructions="You are a product photography expert and e-commerce consultant.",
       input=[
           {"role": "user", "content": "Analyze this product image and provide the following details:\n1. Product category\n2. Key visible features\n3. Potential quality issues\n4. Suggested improvements for the product photography"},
           {
               "role": "user",
               "content": [
                   {
                       "type": "input_image",
                       "image_url": image_url
                   }
               ],
           },
       ],
       temperature=0.2
   )
  
   return response.output_text

# Example with a sports team image
analysis = analyze_product_image("https://upload.wikimedia.org/wikipedia/commons/a/a5/Barcelona_fc_lamina_elgrafico.jpg")
print(analysis)

Ausgabe:

1. **Product Category**: Sports team memorabilia or vintage sports photography.

2. **Key Visible Features**:
  - The image features a group of individuals in sports uniforms, likely a football (soccer) team.
  - The uniforms have distinct vertical stripes in red and blue.
  - A football is visible in the foreground.
  - The setting appears to be an outdoor field, possibly a stadium.

...

Diese Funktion könnte in eine E-Commerce-Plattform integriert werden, um Produktfotos automatisch zu analysieren, wenn Händler/innen sie hochladen. Das System könnte sofortiges Feedback über die Bildqualität geben und Verbesserungen vorschlagen, was letztlich zu besseren Konversionsraten durch qualitativ hochwertigere Angebote führt - und das alles ohne manuelle Überprüfung.

Wenn du mit Bildern arbeitest, solltest du dem Eingabeparameter statt einer Zeichenkette ein Array von Nachrichtenobjekten übergeben, die jeweils eine Rolle und Inhaltswerte haben.

 Der Bildinhalt wird als Objekt mit type: input_image und einem image_url angegeben. Du kannst Text und Bilder in der gleichen Anfrage kombinieren und so vielfältige multimodale Interaktionen ermöglichen.

Streaming für responsive Anwendungen implementieren

Die Nutzer erwarten sofortiges Feedback. Mehrere Sekunden auf eine KI-Antwort zu warten, kann das Engagement zerstören - deshalb ist Streaming so wichtig, um reaktionsschnelle Nutzererlebnisse zu schaffen, vor allem in Chats oder Echtzeitanwendungen.

Stell dir vor, du baust ein Tool zur Analyse des Kundenfeedbacks für ein Produktteam. Anstatt sie auf die vollständige Analyse warten zu lassen, kannst du die Ergebnisse streamen, sobald sie erstellt sind:

def analyze_customer_feedback(feedback_text):
   print("Analyzing customer feedback in real-time:")
  
   stream = client.responses.create(
       model="gpt-4o",
       instructions="Extract key sentiments, product issues, and actionable insights from this feedback.",
       input=feedback_text,
       stream=True,
       temperature=0.3,
       max_output_tokens=500
   )
  
   full_response = ""
   print("\nAnalysis results:")
   for event in stream:
       if event.type == "response.output_text.delta":
           print(event.delta, end="")
           full_response += event.delta
       elif event.type == "response.error":
           print(f"\nError occurred: {event.error}")
  
   return full_response

# Example with a complex customer review
feedback = """
I've been using the SmartHome Hub for about 3 months now. The voice recognition is fantastic
and the integration with my existing devices was mostly seamless. However, the app crashes
at least once a day, and the night mode feature often gets stuck until I restart the system.
Customer support was helpful but couldn't fully resolve the app stability issues.
"""

analysis_result = analyze_customer_feedback(feedback)

In einer realen Anwendung würdest du die print Anweisungen durch UI-Updates ersetzen, so dass deine Nutzer/innen die Analyse in Echtzeit sehen können - ähnlich wie moderne Chat-Anwendungen die KI "denken" lassen, während sie eine Antwort erzeugt. Das schafft ein angenehmeres Erlebnis und gibt den Nutzern ein unmittelbares Feedback, dass ihre Anfrage bearbeitet wird.

Die Streaming-Implementierung funktioniert so:

1. Einstellung von stream=True in der Erstellungsmethode
2. Verarbeitung der Antwort als Iterable von Ereignissen mit bestimmten Typen
3. Unterschiedliche Ereignistypen getrennt behandeln: response.output_text.delta für Content Chunks, response.error für Fehler

Nachdem wir nun die grundlegenden Funktionen der Antwort-API kennengelernt haben, wollen wir uns nun mit den eingebauten Tools befassen, die die Möglichkeiten der API noch erweitern.

OpenAI Antworten API Eingebaute Tools

Die Antwort-API enthält einige integrierte Tools, die ihre Möglichkeiten über die einfache Texterstellung hinaus erweitern. Diese Tools ermöglichen es Entwicklern, leistungsfähigere Anwendungen zu erstellen, ohne komplexen Integrationscode oder mehrere API-Aufrufe zu benötigen.

Websuche: Zugriff auf Echtzeit-Informationen

Die Websuche ermöglicht es der Responses API, aktuelle Informationen aus dem Internet abzurufen, und behebt damit die Einschränkung, dass LLMs auf ihre Trainingsdaten beschränkt sind.

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
   model="gpt-4o",
   tools=[{"type": "web_search_preview"}],
   input="What are some news related to the stock market?",
)

print(response.output_text)

Ausgabe:

Recent developments in the stock market have been significantly influenced by escalating trade tensions between the United States and China. On April 5, 2025, President Donald Trump announced an additional 34% tariff on Chinese goods, raising total tariffs to 54% this year. In response, China imposed reciprocal 34% tariffs on U.S. products and introduced export restrictions on certain rare earth elements. These actions led to a sharp global market selloff, with the S&P 500 falling 9% for the week, marking the steepest decline since the pandemic. (reuters.com)

…..


## Escalating US-China Trade Tensions Impact Global Markets:
- [China says 'market has spoken' after US tariffs spark selloff](https://www.reuters.com/world/china/china-says-market-has-spoken-after-us-tariffs-spark-selloff-2025-04-05/?utm_source=openai)
- [Trump touts "economic revolution" as economists warn of recession](https://www.axios.com/2025/04/05/trump-tariffs-stock-market-recession?utm_source=openai)
- [Believe it or not, there were some winners in the stock market this week](https://apnews.com/article/ce81e9ae6fb463dc763dfaa464778343?utm_source=openai)

Wenn die Websuche aktiviert wird, führt sie mehrere Vorgänge aus, von der Analyse der Anfrage bis hin zur Zusammenstellung von Informationen aus mehreren Quellen mit korrekten Zitaten. Diese Fähigkeit eröffnet Möglichkeiten für informationsreiche Anwendungen, wie z. B. Finanzanalysetools, die Markteinblicke bieten, Plattformen für die Zusammenführung von Nachrichten, die mehrere Quellen kombinieren, oder Bildungsressourcen, die Kerninhalte mit aktuellen Forschungsergebnissen ergänzen.

Ein wesentlicher Vorteil dieses Tools ist die Möglichkeit, zeitnahe Informationen bereitzustellen, ohne dass eine eigene Suchintegration oder ein Web Scraping System entwickelt und gepflegt werden muss. Das Tool übernimmt den Suchprozess und präsentiert die Ergebnisse mit korrekten Zitaten, um die Transparenz der Informationsquellen zu gewährleisten.

Dateisuche: Informationen aus Dokumenten extrahieren

Während die Websuche externes Wissen in deine Anwendung bringt, konzentriert sich die Dateisuche darauf, Informationen aus Dokumenten zu erschließen. Mit diesem Tool kann die API die Dokumente, die in OpenAI hochgeladen wurden, durchsuchen und Informationen daraus extrahieren.

Das Dateisuchwerkzeug ermöglicht mehrere wichtige Funktionen:

• Suche über mehrere Dateitypen hinweg (PDFs, Word-Dokumente, Präsentationen usw.).
• Suche nach bestimmten Informationen in Dokumenten auf der Grundlage von natürlichsprachlichen Abfragen.
• Extrahieren und Zusammenfassen von Informationen aus mehreren Dokumenten gleichzeitig.
• Verweise auf bestimmte Abschnitte in den Quellendokumenten.
• Unterstützung komplexer Abfragen, die sich auf Informationen aus mehreren Dateien beziehen.

Diese Fähigkeit eignet sich gut für die Analyse von Dokumenten, z. B. für die Extraktion von Informationen aus juristischen Verträgen, die Analyse von Forschungsarbeiten oder den Aufbau von Wissensdatenbanken aus technischen Unterlagen. Das Tool kann relevante Abschnitte in mehreren Dokumenten identifizieren und Informationen als Antwort auf spezifische Abfragen zusammenfassen.

Für die Implementierung müssen zunächst Dateien auf den Dateiendpunkt von OpenAI hochgeladen und dann die Datei-IDs bei einer Abfrage an die Antwort-API übergeben werden. So entsteht ein optimierter Arbeitsablauf für Anwendungen, die auf bestimmte Informationen in Dokumenten verweisen müssen, ohne dass die Benutzer/innen manuell suchen müssen.

Computernutzung: Interaktionsmöglichkeiten der Schnittstelle

Aufbauend auf der Grundlage des Text- und Dokumentenverständnisses erweitert das Tool zur Computernutzung die KI-Fähigkeiten auf den Bereich der Interaktion mit Schnittstellen. Dieses Tool stellt einen bedeutenden Fortschritt dar, der die Lücke zwischen Sprachverständnis und Benutzeroberflächenmanipulation schließt.

Das Computer-Nutzungswerkzeug kann eine Vielzahl von Schnittstelleninteraktionen durchführen:

• Navigiere selbstständig durch Websites und Webanwendungen.
• Fülle die Formulare mit den entsprechenden Informationen aus.
• Extrahiere Daten aus Webseiten und Anwendungen.
• Führe mehrstufige Prozesse über verschiedene Bildschirme hinweg aus.
• Interagiere mit Elementen wie Schaltflächen, Dropdowns und Textfeldern.
• Verstehe den Kontext und den Zweck der verschiedenen Oberflächenelemente.

Mögliche Anwendungen sind die Prozessautomatisierung für sich wiederholende Aufgaben, geführte Unterstützung für komplexe Arbeitsabläufe und die Verbesserung der Zugänglichkeit für Nutzer, die Schwierigkeiten mit traditionellen Schnittstellen haben. Das Tool kann verwendet werden, um das Ausfüllen von Formularen zu automatisieren, durch komplexe Websites zu navigieren oder Benutzeroberflächen zu testen.

Die Technologie ermöglicht es der KI, Bildschirmelemente zu sehen und mit ihnen zu interagieren, den Kontext zu verstehen und Aktionen auf der Grundlage von Anweisungen in natürlicher Sprache auszuführen. Dies schafft Möglichkeiten zur Automatisierung und Unterstützung, die sonst die Entwicklung von schnittstellenspezifischem Code erfordern würden.

Zusätzliche Werkzeugfunktionen

Das Tool-Ökosystem innerhalb der Responses API wächst weiter, da OpenAI regelmäßig neue Funktionen hinzufügt. Die umfassende Dokumentation zu den Werkzeugen enthält Details zur Implementierung aller derzeit verfügbaren Werkzeuge, während der Artikel zu neuen Werkzeugen für Bauagenten einen strategischen Überblick über die Entwicklung dieser Werkzeuge gibt.

Diese eingebauten Tools bieten von Haus aus leistungsstarke Funktionen, aber viele Anwendungen erfordern eine Verbindung zu speziellen Diensten oder proprietären Systemen. An dieser Stelle wird der Funktionsaufruf unverzichtbar, denn er ermöglicht es dir, die Responses API mit deinen eigenen Tools und externen Diensten zu erweitern - das ist der Schwerpunkt des nächsten Abschnitts.

Funktionsaufrufe in der Antwort-API

Während integrierte Tools leistungsstarke Funktionen bieten, müssen viele Anwendungen mit speziellen Diensten oder proprietären Systemen verbunden werden. Mit dem Funktionsaufruf kannst du die Antwort-API um deine eigenen Tools erweitern, so dass das Modell anhand der Benutzereingaben bestimmen kann, wann und wie es deine Funktionen aufruft.

Funktionsaufrufe bilden eine Brücke zwischen dem Sprachverständnis der KI und deinen externen Systemen - egal ob es darum geht, Wechselkurse abzurufen, Entfernungen zu berechnen oder die Verfügbarkeit von Terminen zu prüfen. Dieses Muster folgt einem klaren Arbeitsablauf:

1. Du definierst Funktionen, die die KI verwenden kann, indem du Parameter und ihre Typen angibst.
2. Die KI entscheidet auf der Grundlage von Nutzeranfragen, wann sie diese Funktionen aufruft.
3. Dein Code führt die Funktionen mit den von der KI zur Verfügung gestellten Parametern aus.
4. Du gibst die Ergebnisse an die KI zurück, die sie in ihre Antwort einbaut.

Erstellen eines Währungsumrechnungstools

Lass uns als Beispiel eine einfache Währungsumrechnungsfunktion implementieren:

# Dictionary of exchange rates (relative to USD)
exchange_rates = {
   "USD": 1.0,
   "EUR": 0.93,
   "GBP": 0.79,
   "JPY": 153.2,
   "CAD": 1.37,
   "AUD": 1.52
}

def convert_currency(amount, from_currency, to_currency):
   """Convert an amount from one currency to another."""
   # Normalize currency codes to uppercase
   from_currency = from_currency.upper()
   to_currency = to_currency.upper()
  
   # Check if currencies are supported
   if from_currency not in exchange_rates:
       return {"error": f"Currency not supported: {from_currency}"}
   if to_currency not in exchange_rates:
       return {"error": f"Currency not supported: {to_currency}"}
  
   # Convert to USD first, then to target currency
   amount_in_usd = amount / exchange_rates[from_currency]
   converted_amount = amount_in_usd * exchange_rates[to_currency]
  
   return {
       "original_amount": amount,
       "from_currency": from_currency,
       "to_currency": to_currency,
       "converted_amount": round(converted_amount, 2)
   }

Diese Funktion benötigt drei Parameter: den umzurechnenden Betrag, die Ausgangswährung und die Zielwährung. Es führt eine einfache Umrechnung mit vordefinierten Wechselkursen durch und liefert ein strukturiertes Ergebnis mit den Umrechnungsdetails.

Definieren der Funktion für die Antwort-API

Jetzt müssen wir dem Modell unsere Funktion mitteilen, damit es entscheiden kann, wann es sie aufrufen soll:

from openai import OpenAI
import json

client = OpenAI()

tools = [
   {
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }
]

Diese Definition legt eindeutig fest:

• Der Funktionsname convert_currency, der zu unserer Python-Funktion passt.
• Eine Beschreibung, die erklärt, wann die Funktion verwendet werden soll.
• Drei erforderliche Parameter mit ihren Typen und Beschreibungen.
• Das strict: true Flag, um sicherzustellen, dass das Modell genau unseren Parameterspezifikationen folgt.

Bearbeitung einer Benutzeranfrage

Simulieren wir eine Unterhaltung, in der ein Nutzer nach der Währungsumrechnung fragt:

input_messages = [
   {"role": "user", "content": "How much is 100 euros in Japanese yen?"}
]

response = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)

Wenn das Modell diese Frage nach der Währungsumrechnung sieht, erkennt es, dass es unsere Funktion verwenden sollte. Sie erkennt das automatisch:

• Der Betrag ist 100
• Die Ausgangswährung ist Euro (EUR)
• Die Zielwährung ist der japanische Yen (JPY)

Verarbeitung des Funktionsaufrufs

Jetzt extrahieren wir die Details des Funktionsaufrufs und führen unsere Funktion aus:

tool_call = response.output[0]
print(f"Function called: {tool_call.name}")
print(f"Arguments: {tool_call.arguments}")

args = json.loads(tool_call.arguments)

# Execute the function with the parameters determined by the model
conversion_result = convert_currency(**args)
print(f"Function results: {conversion_result}")

Das Modell hat die natürlichsprachliche Anfrage in strukturierte Parameter übersetzt. Unsere Funktion führt dann die Berechnung auf der Grundlage dieser Parameter durch und gibt den umgerechneten Betrag zurück.

Rückgabe von Funktionsergebnissen an das Modell

Schließlich senden wir die Ergebnisse an das Modell zurück, damit es eine benutzerfreundliche Antwort geben kann:

input_messages.append(tool_call)  # append model's function call message
input_messages.append(
   {  # append result message
       "type": "function_call_output",
       "call_id": tool_call.call_id,
       "output": json.dumps(conversion_result)
   }
)

response_2 = client.responses.create(
   model="gpt-4o",
   input=input_messages,
   tools=tools,
)
print(response_2.output_text)

Ausgabe:

100 euros is equal to 16,473.12 Japanese yen based on current exchange rates.

Das Modell hat unsere rohen Umrechnungsdaten in eine natürliche, für Menschen lesbare Antwort umgewandelt. Er hat das numerische Ergebnis richtig interpretiert und in einem für die Währung geeigneten Format dargestellt.

Alles zusammenfügen

In einer echten Anwendung willst du diesen gesamten Prozess in einer einzigen Schnittstelle kapseln, die den Konversationsfluss nahtlos abwickelt. So könntest du einen kompletten Assistenten erstellen, der den gesamten Prozess des Funktionsaufrufs verwaltet:

def currency_assistant(user_message, conversation_history=None):
   """A complete assistant that handles currency conversion queries."""
   if conversation_history is None:
       conversation_history = []
  
   # Add the user's new message to the conversation
   conversation_history.append({"role": "user", "content": user_message})
  
   # Define available tools (our currency conversion function)
   tools = [{
       "type": "function",
       "name": "convert_currency",
       "description": "Convert an amount from one currency to another using current exchange rates",
       "parameters": {
           "type": "object",
           "properties": {
               "amount": {
                   "type": "number",
                   "description": "The amount of money to convert"
               },
               "from_currency": {
                   "type": "string",
                   "description": "The currency code to convert from (e.g., USD, EUR, GBP)"
               },
               "to_currency": {
                   "type": "string",
                   "description": "The currency code to convert to (e.g., USD, EUR, GBP)"
               }
           },
           "required": ["amount", "from_currency", "to_currency"],
           "additionalProperties": False
       },
       "strict": True
   }]
  
   # Get initial response from the model
   response = client.responses.create(
       model="gpt-4o",
       input=conversation_history,
       tools=tools,
   )
  
   # Check if the model wants to call a function
   if response.output and isinstance(response.output, list) and response.output[0].type == "function_call":
       tool_call = response.output[0]
      
       # Process the function call
       args = json.loads(tool_call.arguments)
       result = convert_currency(**args)
      
       # Add the function call and its result to the conversation
       conversation_history.append(tool_call)
       conversation_history.append({
           "type": "function_call_output",
           "call_id": tool_call.call_id,
           "output": json.dumps(result)
       })
      
       # Get the final response with the function results incorporated
       final_response = client.responses.create(
           model="gpt-4o",
           input=conversation_history,
           tools=tools,
       )
      
       return final_response.output_text, conversation_history
   else:
       # If no function call was needed, return the direct response
       return response.output_text, conversation_history

# Example usage
response, conversation = currency_assistant("How much is 50 British pounds in Australian dollars?")
print("Assistant:", response)

# Continue the conversation
response, conversation = currency_assistant("And what if I wanted to convert 200 Canadian dollars instead?", conversation)
print("Assistant:", response)

Diese Umsetzung:

1. Behält den Gesprächsverlauf bei, um den Kontext für Folgefragen zu liefern.
2. Verwaltet den gesamten Prozess des Funktionsaufrufs in einer einzigen Schnittstelle.
3. Legt fest, wann ein Funktionsaufruf notwendig ist und wann das Modell direkt antworten kann.
4. Unterstützt Multi-Turn-Konversationen, bei denen der vorherige Kontext wichtig ist.

Mit diesem Ansatz kannst du nahtlose Konversationserlebnisse schaffen, bei denen die Nutzerinnen und Nutzer auf natürliche Weise interagieren, ohne sich der komplexen Funktionsaufrufe bewusst zu sein, die im Hintergrund ablaufen. Der Assistent sorgt für den Übergang zwischen dem Verstehen natürlicher Sprache, strukturierten Funktionsaufrufen und der Erzeugung natürlicher Sprache.

Die Entwicklung komplexerer Anwendungen kann Folgendes beinhalten:

1. Unterstützung mehrerer Funktionen, jeweils für verschiedene Arten von Abfragen.
2. Verwaltung der Authentifizierung und Autorisierung für sensible Vorgänge.
3. Implementierung einer ausgefeilteren Fehlerbehandlung und -behebung.
4. Hinzufügen von Logging und Monitoring für Funktionsnutzung und Leistung.
5. Erstellen von Benutzeroberflächen, die Text-, Sprach- oder multimodale Interaktionen unterstützen.

Der Funktionsaufruf ermöglicht es der Responses API, natürlichsprachliche Eingaben mit deinen Diensten und Daten zu verbinden. So entsteht eine Brücke zwischen den Nutzeranfragen und deinen Geschäftssystemen. Die Nutzerinnen und Nutzer können ihre Anfragen in einfacher Sprache stellen, während deine Anwendung die technischen Implementierungsdetails im Hintergrund erledigt.

Neben dem Funktionsaufruf ist eine weitere leistungsstarke Fähigkeit der Responses API die Möglichkeit, strukturierte Ausgaben zu erzeugen. Diese Funktion ergänzt Funktionsaufrufe, indem sie eine Möglichkeit bietet, Antworten in bestimmten Formaten zu erhalten, die auf die Bedürfnisse deiner Anwendung abgestimmt sind.

Strukturierte Ausgaben mit der Antwort-API

Wenn du KI-Anwendungen entwickelst, brauchst du oft Antworten in einem bestimmten Format, um sie leichter in deine Systeme integrieren zu können. Die Antwort-API unterstützt strukturierte Ausgaben, die es dir ermöglichen, Daten in einem klar definierten, konsistenten Format statt als Freiformtext zu erhalten. Diese Funktion ist besonders wertvoll, wenn du sie brauchst:

1. Extrahiere bestimmte Informationen aus unstrukturiertem Text.
2. Wandle Benutzereingaben in strukturierte Daten um.
3. Sorge für einheitliche Antwortformate für die nachgelagerte Verarbeitung.
4. Integriere die KI-Ergebnisse direkt in Datenbanken oder APIs.

Strukturierte Ausgaben reduzieren den Bedarf an zusätzlicher Analyse und Validierung und machen deine Anwendungen robuster und einfacher zu pflegen.

Produktinformationen aus Beschreibungen extrahieren

Betrachten wir ein praktisches Beispiel: Stell dir vor, du baust eine E-Commerce-Plattform auf und musst automatisch Produktdetails aus unstrukturierten Produktbeschreibungen extrahieren, um deine Datenbank aufzufüllen.

from openai import OpenAI
import json

client = OpenAI()

product_description = """
Our Premium Laptop Backpack is perfect for professionals and students alike.
Made with water-resistant material, it features padded compartments that fit
laptops up to 15.6 inches. The backpack includes 3 main storage areas,
5 smaller pockets, and has an integrated USB charging port. Available in
navy blue, black, and gray. Current retail price: $79.99, though it's
currently on sale for $64.99 until the end of the month.
"""

response = client.responses.create(
   model="gpt-4o",
   input=f"Extract structured product information from this description: {product_description}",
   text={
       "format": {
           "type": "json_schema",
           "name": "product_details",
           "schema": {
               "type": "object",
               "properties": {
                   "product_name": {"type": "string"},
                   "category": {"type": "string"},
                   "features": {"type": "array", "items": {"type": "string"}},
                   "colors": {"type": "array", "items": {"type": "string"}},
                   "pricing": {
                       "type": "object",
                       "properties": {
                           "regular_price": {"type": "number"},
                           "sale_price": {"type": "number"},
                           "currency": {"type": "string"},
                       },
                       "additionalProperties": False,
                       "required": ["regular_price", "sale_price", "currency"],
                   },
               },
               "required": ["product_name", "features", "colors", "pricing","category"],
               "additionalProperties": False,
           },
           "strict": True,
       }
   },
)

product_data = json.loads(response.output_text)
print(json.dumps(product_data, indent=2))

Ausgabe:

{
 "product_name": "Premium Laptop Backpack",
 "category": "Backpack",
 "features": [
   "Water-resistant material",
   "Padded compartments for laptops up to 15.6 inches",
   "3 main storage areas",
   "5 smaller pockets",
   "Integrated USB charging port"
 ],
 "colors": [
   "Navy blue",
   "Black",
   "Gray"
 ],
 "pricing": {
   "regular_price": 79.99,
   "sale_price": 64.99,
   "currency": "USD"
 }
}

Diese formatierten JSON-Daten können jetzt direkt in deine Produktdatenbank integriert werden, wodurch die Notwendigkeit einer eigenen Parsing-Logik entfällt und die Fehlerwahrscheinlichkeit sinkt.

Verstehen der strukturierten Ausgabekonfiguration

Der Schlüssel zu effektiven und fehlerfreien strukturierten Ausgaben liegt in der richtigen Definition deines Schemas. Schauen wir uns die wichtigsten Elemente der Konfiguration an:

text={
   "format": {
       "type": "json_schema",        # Specifies we're using JSON Schema
       "name": "product_details",    # A descriptive name for this schema
       "schema": {
           # Your JSON Schema definition here
           "type": "object",
           "properties": {
               # Each property with type information, e.g.
               "product_name": {"type": "string"},
               # ... other properties
           },
           "required": ["product_name", ...], # All other properties
           "additionalProperties": False
       },
       "strict": True                # Enforce schema constraints strictly
   }
}

Die wichtigsten Komponenten sind:

1. Schema-Definition: Beschreibt die Struktur, einschließlich aller Eigenschaften und ihrer Typen.
2. Erforderliche Felder: Listet die Eigenschaften auf, die in der Antwort enthalten sein müssen.
3. Zusätzliche Eigenschaften: Bei der Einstellung False werden zusätzliche Felder, die nicht im Schema definiert sind, verhindert.
4. Strenger Modus: Wenn du True wählst, wird sichergestellt, dass das Modell genau dem Schema folgt.

Praktische Tipps zur Verwendung strukturierter Ausgaben

Um die besten Ergebnisse mit strukturierten Ausgaben zu erzielen, befolge diese Richtlinien:

1. Gestalte dein Schema sorgfältig: Fülle alle erforderlichen Felder aus, aber konzentriere dich auf die wichtigsten Informationen.
2. Verwende geeignete Datentypen: Stimme deine Schematypen darauf ab, wie du die Daten verwenden wirst (Zahlen für Berechnungen, Strings für Text).
3. Setze klare Einschränkungen: Verwende enum für Felder mit begrenzten Optionen und minimum /maximum für numerische Grenzen.
4. Test mit verschiedenen Eingängen: Stelle sicher, dass dein Schema verschiedene Eingabeformate und Randfälle verarbeiten kann.
5. Füge klare Beschreibungen ein: Das Hinzufügen von Beschreibungen zu Feldern hilft dem Modell bei der Interpretation der zu extrahierenden Informationen.

Vergleich mit der Chat Completions API

Während die Responses API strukturierte Ausgaben über JSON Schema liefert, bietet die Chat Completions API einen alternativen Ansatz mit Pydantic Modellen, der viel einfacher ist:

from pydantic import BaseModel, Field
from typing import List, Optional
from openai import OpenAI

client = OpenAI()

class ProductDetails(BaseModel):
   product_name: str
   category: str = Field(default=None)
   features: List[str]
   specifications: Optional[dict] = None
   colors: List[str]
   pricing: dict

# With Chat Completions API
completion = client.beta.chat.completions.parse(
   model="gpt-4o",
   messages=[
       {"role": "system", "content": "Extract structured product information."},
       {"role": "user", "content": product_description}
   ],
   response_format=ProductDetails
)

pydantic_product = completion.choices[0].message.parsed

Jeder Ansatz hat seine Vorteile:

• Die Antwort-API verwendet das Standard-JSON-Schema direkt im API-Aufruf
• Chat Completions API integriert sich über Pydantic in das Typensystem von Python

Wenn du mich fragst, würde ich die Chat Completions API verwenden, damit ich keine rohen JSON-Schemata schreiben muss. Natürlich nur, bis OpenAI die Antworten-API um Unterstützung für Pydantic-Modelle erweitert.

Weitere Informationen finden Sie in der Antworten API-Dokumentation für strukturierte Ausgaben.

Fazit

Die OpenAI Responses API vereinfacht die Interaktion von Entwicklern mit Sprachmodellen, indem sie die Stärken der bisherigen APIs in einer einheitlichen Schnittstelle vereint, die weniger Code und Komplexität erfordert. Sie unterstützt Textgenerierung, Bildanalyse, Funktionsaufrufe und strukturierte Ausgaben und macht so KI-Funktionen leichter zugänglich, während sich Entwickler auf die Lösung von Geschäftsproblemen statt auf Integrationsaufgaben konzentrieren können.

Wenn du deine Reise mit der Antwort-API fortsetzt, könnten diese zusätzlichen Ressourcen hilfreich sein, um dein Verständnis zu vertiefen und deine Implementierungsfähigkeiten zu erweitern:

• Arbeiten mit der OpenAI API
• OpenAI Grundlagen Lernpfad
• GPT-4.5: Was ist neu im neuesten Modell von OpenAI?
• Tiefe Forschung mit OpenAI
• GPT-4.5 Funktionsaufrufe Tutorial
• GPT-4.5 API Tutorial
• OpenAI Agents SDK Tutorial