API de réponses OpenAI : Le guide ultime du développeur

Qu'est-ce que l'API de réponses d'OpenAI ?

L'API Réponses est la plus récente et la plus avancée des API d'OpenAI. Il combine les points forts des API Chat Completions et Assistants en une seule interface rationalisée. Lancée en mars 2025, elle conserve les fonctionnalités habituelles tout en offrant une approche plus intégrée de la création d'applications d'IA. 

La principale innovation réside dans la manière dont il simplifie le développement en gérant automatiquement la logique d'orchestration et en intégrant nativement les outils intégrés d'OpenAI pour la recherche sur le web et la recherche de fichiers, sans nécessiter d'implémentation personnalisée.

Dans ce tutoriel, nous verrons comment utiliser l'API Responses dans vos projets. Vous verrez comment il gère la génération de texte, travaille avec des images et fournit des réponses en continu. Nous examinerons les outils intégrés qui rendent le développement plus rapide et plus simple qu'auparavant, en vous montrant comment ces outils fonctionnent ensemble dans le cadre de l'API. 

À la fin de ce guide, vous saurez quand utiliser l'API Réponses plutôt que d'autres options OpenAI et comment ces connaissances peuvent vous aider à créer des applications plus efficaces avec moins de code et d'efforts. Si vous ne connaissez pas encore l'API OpenAI, consultez notre cours d'introduction, Travailler avec l'API OpenAIpour commencer à développer des applications basées sur l'IA.

Premiers pas avec l'API des réponses

L'API Responses offre une interface plus rationnelle et plus conviviale pour interagir avec les modèles d'OpenAI, en combinant ce qui nécessitait auparavant une syntaxe verbeuse et complexe en une solution élégante. 

Avant de nous plonger dans des cas d'utilisation spécifiques, configurons notre environnement et comprenons la syntaxe de base.

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

Cette étape d'initialisation crée un objet client qui traitera toutes vos demandes d'API. Le paquetage dotenv permet de gérer votre clé API en toute sécurité au moyen de variables d'environnement plutôt que de la coder en dur dans votre script - une bonne pratique qui rend votre code plus portable et plus sûr dans différents environnements.

Générer du contenu avec l'API des réponses

L'utilisation la plus simple de l'API Responses consiste à générer du contenu textuel. Examinons un scénario concret : supposons que vous construisiez une plateforme de commerce électronique et que vous deviez générer automatiquement des descriptions de produits convaincantes à partir de détails de base sur les produits.

Traditionnellement, cela nécessiterait une ingénierie minutieuse et rapide et de multiples itérations. Avec l'API des réponses, vous pouvez créer une fonction simple qui gère cela de manière élégante :

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)

Sortie :

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.

Avec seulement quelques lignes de code, nous avons créé un texte de qualité marketing qui nécessiterait normalement l'intervention d'un rédacteur professionnel. La fonction est également réutilisable : il suffit de modifier les paramètres pour générer des descriptions pour n'importe quel produit de votre catalogue.

Cet exemple présente des modèles clés lors de l'utilisation de l'API des réponses :

1. Le paramètre instructions agit comme une invite du système, définissant le comportement et le contexte de l'IA.
2. Le paramètre temperature (0-2) contrôle le caractère aléatoire - les valeurs inférieures produisent des résultats plus déterministes tandis que les valeurs supérieures introduisent plus de créativité.
3. Le paramètre max_output_tokens limite la longueur des réponses, ce qui permet de contrôler les coûts et d'obtenir des résultats concis.
4. L'objet réponse contient le texte généré dans la propriété output_text.

Analyse d'images pour des applications pratiques

De nombreuses applications du monde réel doivent traiter à la fois du texte et des images. Par exemple, les plateformes de commerce électronique doivent analyser les photos de produits, les systèmes de modération de contenu doivent examiner les téléchargements et les applications de médias sociaux doivent comprendre le contenu visuel.

L'API Responses excelle dans les tâches multimodales telles que l'analyse d'images sans nécessiter de points d'extrémité distincts ou de code d'intégration complexe :

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)

Sortie :

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.

...

Cette fonction pourrait être intégrée dans une plateforme de commerce électronique afin d'analyser automatiquement les photos de produits lorsque les commerçants les téléchargent. Le système pourrait fournir un retour d'information immédiat sur la qualité des images et suggérer des améliorations, ce qui permettrait d'améliorer les taux de conversion grâce à des listes de meilleure qualité, le tout sans examen manuel.

Lorsque vous travaillez avec des images, vous devez transmettre un tableau d'objets message au paramètre d'entrée au lieu d'une chaîne, chacun ayant un rôle et des valeurs de contenu.

 Le contenu de l'image est spécifié en tant qu'objet avec type: input_image et image_url. Vous pouvez combiner du texte et des images dans la même demande, ce qui permet des interactions multimodales riches.

Mise en œuvre de la diffusion en continu pour les applications réactives

Les utilisateurs attendent un retour d'information immédiat. Attendre plusieurs secondes une réponse de l'IA peut tuer l'engagement - c'est pourquoi la diffusion en continu est essentielle pour créer des expériences utilisateur réactives, en particulier dans les applications de chat ou en temps réel.

Imaginez que vous construisiez un outil d'analyse des commentaires des clients pour une équipe produit. Au lieu de leur faire attendre l'analyse complète, vous pouvez diffuser les résultats au fur et à mesure qu'ils sont générés :

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)

Dans une application réelle, vous remplaceriez les déclarations print par des mises à jour de l'interface utilisateur, ce qui permettrait à vos utilisateurs de voir l'analyse se former en temps réel, tout comme les applications de chat modernes montrent l'IA en train de "réfléchir" lorsqu'elle génère une réponse. Cela crée une expérience plus engageante et donne aux utilisateurs un retour d'information immédiat sur le traitement de leur demande.

La mise en œuvre de la diffusion en continu fonctionne de la manière suivante :

1. Définition de stream=True dans la méthode de création
2. Traitement de la réponse en tant que tableau itératif d'événements de types spécifiques
3. Traiter séparément les différents types d'événements : response.output_text.delta pour les morceaux de contenu, response.error pour les erreurs.

Maintenant que nous avons couvert les fonctionnalités de base de l'API de réponses, explorons ses outils intégrés qui améliorent encore ses capacités.

Outils intégrés à l'API des réponses OpenAI

L'API Responses intègre quelques outils intégrés qui étendent ses capacités au-delà de la génération de texte de base. Ces outils permettent aux développeurs de créer des applications plus puissantes sans devoir recourir à un code d'intégration complexe ou à de multiples appels d'API.

Recherche sur le web : accès à l'information en temps réel

L'outil de recherche sur le web permet à l'API Réponses de récupérer des informations actuelles sur l'internet, ce qui permet de remédier au fait que les LLM sont limités à leurs données de formation.

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)

Sortie :

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)

L'outil de recherche sur le web effectue plusieurs opérations lorsqu'il est activé, depuis l'analyse de la requête jusqu'à la synthèse d'informations provenant de sources multiples avec les citations appropriées. Cette capacité ouvre la voie à des applications riches en informations, telles que des outils d'analyse financière qui fournissent des informations sur le marché, des plateformes d'agrégation de nouvelles qui combinent plusieurs sources, ou des ressources éducatives qui complètent le contenu de base par des recherches actuelles.

L'un des principaux avantages de cet outil est qu'il permet de fournir des informations en temps utile sans qu'il soit nécessaire d'élaborer et de maintenir un système personnalisé d'intégration de la recherche ou de récupération des données sur le web. L'outil prend en charge le processus de recherche tout en présentant les résultats avec les citations appropriées afin de maintenir la transparence des sources d'information.

Recherche de fichiers : extraction d'informations à partir de documents

Alors que la recherche sur le web apporte des connaissances externes à votre application, l' outil de recherche de fichiers se concentre sur l'extraction d'informations à partir de documents. Cet outil permet à l'API de rechercher et d'extraire des informations des documents qui ont été téléchargés dans l'OpenAI.

L'outil de recherche de fichiers offre plusieurs fonctionnalités essentielles :

• Recherche dans plusieurs types de fichiers (PDF, documents Word, présentations, etc.).
• Recherche d'informations spécifiques dans des documents sur la base de requêtes en langage naturel.
• Extraction et synthèse d'informations à partir de plusieurs documents simultanément.
• Fournir des citations de sections spécifiques des documents sources.
• Support de requêtes complexes qui font référence à des informations contenues dans plusieurs fichiers.

Cette capacité est bien adaptée aux cas d'utilisation de l'analyse de documents tels que l'extraction d'informations à partir de contrats juridiques, l'analyse de documents de recherche ou la construction de bases de connaissances à partir de la documentation technique. L'outil peut identifier les sections pertinentes dans plusieurs documents et synthétiser les informations en réponse à des requêtes spécifiques.

La mise en œuvre nécessite d'abord le téléchargement de fichiers vers le point de terminaison des fichiers de l'OpenAI, puis la transmission des identifiants de fichiers à l'API des réponses lors d'une requête. Cela permet de rationaliser le flux de travail pour les applications qui doivent référencer des informations spécifiques dans les documents sans que les utilisateurs n'aient à effectuer de recherche manuelle.

Utilisation de l'ordinateur : capacités d'interaction avec l'interface

S'appuyant sur la compréhension de textes et de documents, l' outil d'utilisation de l'ordinateur étend les capacités de l'IA au domaine de l'interaction avec l'interface. Cet outil représente une avancée significative qui comble le fossé entre la compréhension du langage et la manipulation de l'interface utilisateur.

L'outil d'utilisation de l'ordinateur peut effectuer diverses interactions avec l'interface :

• Naviguer de manière autonome sur les sites et les applications web.
• Remplissez les formulaires avec les informations appropriées.
• Extraire des données de pages web et d'applications.
• Exécutez des processus en plusieurs étapes sur différents écrans.
• Interagissez avec des éléments tels que des boutons, des listes déroulantes et des champs de texte.
• Comprendre le contexte et l'objectif des différents éléments de l'interface.

Les applications potentielles comprennent l'automatisation des processus pour les tâches répétitives, l'assistance guidée pour les flux de travail complexes et l'amélioration de l'accessibilité pour les utilisateurs qui ont des difficultés avec les interfaces traditionnelles. Cet outil pourrait être utilisé pour automatiser le remplissage de formulaires, naviguer sur des sites web complexes ou tester des interfaces utilisateur.

Cette technologie permet à l'IA de voir et d'interagir avec les éléments de l'écran, de comprendre le contexte et d'exécuter des actions sur la base d'instructions en langage naturel. Cela crée des possibilités d'automatisation et d'assistance qui, autrement, nécessiteraient le développement spécialisé d'un code spécifique à l'interface.

Capacités supplémentaires de l'outil

L'écosystème d'outils au sein de l'API Responses continue de se développer, OpenAI ajoutant régulièrement de nouvelles capacités. La documentation complète sur les outils couvre les détails de mise en œuvre de tous les outils actuellement disponibles, tandis que l'article sur les nouveaux outils pour les agents immobiliers fournit un contexte stratégique sur l'évolution de ces outils.

Ces outils intégrés offrent des capacités puissantes, mais de nombreuses applications nécessitent de se connecter à des services spécialisés ou à des systèmes propriétaires. C'est là que l'appel de fonction devient essentiel, vous permettant d'étendre l'API Responses avec vos propres outils personnalisés et services externes - l'objet de notre prochaine section.

Appel de fonction dans l'API des réponses

Si les outils intégrés offrent de puissantes capacités, de nombreuses applications nécessitent de se connecter à des services spécialisés ou à des systèmes propriétaires. L'appel de fonction vous permet d'étendre l'API des réponses avec vos propres outils personnalisés, ce qui permet au modèle de déterminer quand et comment appeler vos fonctions en fonction des données de l'utilisateur.

L'appel de fonctions crée un pont entre la compréhension du langage de l'IA et vos systèmes externes, qu'il s'agisse de récupérer les taux de change, de calculer les distances ou de vérifier la disponibilité d'un rendez-vous. Ce modèle suit un processus clair :

1. Vous définissez les fonctions que l'IA peut utiliser, en spécifiant les paramètres et leurs types.
2. L'IA décide quand appeler ces fonctions en fonction des requêtes de l'utilisateur.
3. Votre code exécute les fonctions avec les paramètres fournis par l'IA.
4. Vous renvoyez les résultats à l'IA, qui les intègre dans sa réponse.

Création d'un outil de conversion de devises

Prenons l'exemple d'une simple fonction de conversion de devises :

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

Cette fonction prend trois paramètres : le montant à convertir, la devise source et la devise cible. Il effectue une simple conversion en utilisant des taux de change prédéfinis et renvoie un résultat structuré avec les détails de la conversion.

Définition de la fonction pour l'API des réponses

Nous devons maintenant informer le modèle de notre fonction afin qu'il puisse décider quand l'appeler :

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
   }
]

Cette définition précise clairement :

• Le nom de la fonction convert_currency qui correspond à notre fonction Python.
• Une description expliquant quand la fonction doit être utilisée.
• Trois paramètres obligatoires avec leur type et leur description.
• Le drapeau strict: true permet de s'assurer que le modèle suit exactement les spécifications de nos paramètres.

Traitement d'une requête d'utilisateur

Simulons une conversation au cours de laquelle un utilisateur pose des questions sur la conversion des devises :

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

Lorsque le modèle voit cette question sur la conversion des devises, il sait qu'il doit utiliser notre fonction. Il l'identifie automatiquement :

• Le montant est de 100
• La devise source est l'euro (EUR)
• La devise cible est le yen japonais (JPY).

Traitement de l'appel de fonction

Nous extrayons maintenant les détails de l'appel de fonction et exécutons notre fonction :

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

Le modèle a traduit la requête en langage naturel en paramètres structurés. Notre fonction effectue ensuite le calcul sur la base de ces paramètres et renvoie le montant converti.

Renvoi des résultats de la fonction au modèle

Enfin, nous renvoyons les résultats au modèle afin qu'il puisse générer une réponse conviviale :

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)

Sortie :

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

Le modèle a pris nos données de conversion brutes et les a transformées en une réponse naturelle, lisible par l'homme. Il a interprété correctement le résultat numérique et l'a présenté dans un format approprié pour la monnaie.

Tout mettre en place

Dans une application réelle, vous voudrez encapsuler l'ensemble de ce processus dans une interface unique qui gère le flux de conversation de manière transparente. Voici comment vous pouvez créer un assistant complet qui gère l'ensemble du processus d'appel de fonction :

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)

Cette mise en œuvre :

1. Conserve l'historique des conversations afin de fournir un contexte pour les questions de suivi.
2. Gère l'ensemble du processus d'appel de fonction dans une interface unique.
3. Détermine quand il est nécessaire d'appeler une fonction et quand le modèle peut répondre directement.
4. Prise en charge des conversations à plusieurs tours où le contexte antérieur est important.

Grâce à cette approche, vous pouvez créer des expériences conversationnelles transparentes où les utilisateurs interagissent naturellement sans être conscients de la complexité des fonctions qui se déroulent en coulisses. L'assistant assure la transition entre la compréhension du langage naturel, les appels de fonctions structurées et la génération de langage naturel.

La création d'applications plus complexes peut impliquer

1. Prise en charge de plusieurs fonctions, chacune pour différents types de requêtes.
2. Gestion de l'authentification et de l'autorisation pour les opérations sensibles.
3. Mise en œuvre d'une gestion des erreurs et d'une récupération plus sophistiquées.
4. Ajout de la journalisation et de la surveillance de l'utilisation et de la performance des fonctions.
5. Créer des interfaces utilisateur qui prennent en charge les interactions textuelles, vocales ou multimodales.

L'appel de fonction permet à l'API Responses de relier des entrées en langage naturel à vos services et données. Cela crée un pont entre les demandes des utilisateurs et vos systèmes d'entreprise, permettant aux utilisateurs de formuler des demandes en langage clair tandis que votre application gère les détails de la mise en œuvre technique en arrière-plan.

Au-delà de l'appel de fonctions, une autre capacité puissante de l'API Responses est la possibilité de générer des sorties structurées. Cette fonction complète l'appel de fonction en fournissant un moyen de recevoir des réponses dans des formats spécifiques qui correspondent aux besoins de votre application.

Sorties structurées avec l'API Responses

Lorsque vous créez des applications d'IA, vous avez souvent besoin de réponses dans un format spécifique pour faciliter l'intégration dans vos systèmes. L'API Responses prend en charge les sorties structurées qui vous permettent de recevoir des données dans un format bien défini et cohérent plutôt que dans un texte libre. Cette fonction est particulièrement utile lorsque vous avez besoin de.. :

1. Extraire des informations spécifiques d'un texte non structuré.
2. Transformez les entrées des utilisateurs en données structurées.
3. Garantir des formats de réponse cohérents pour le traitement en aval.
4. Intégrez les résultats de l'IA directement aux bases de données ou aux API.

Les sorties structurées réduisent la nécessité d'une analyse et d'une validation supplémentaires, ce qui rend vos applications plus robustes et plus faciles à maintenir.

Extraction d'informations sur les produits à partir de descriptions

Prenons un exemple concret : imaginez que vous construisiez une plateforme de commerce électronique et que vous deviez extraire automatiquement les détails des produits à partir de descriptions non structurées pour alimenter votre base de données.

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

Sortie :

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

Ces données JSON formatées peuvent désormais être directement intégrées à votre base de données produits, ce qui élimine le besoin d'une logique d'analyse personnalisée et réduit le risque d'erreurs.

Comprendre la configuration des sorties structurées

La clé de sorties structurées efficaces et exemptes d'erreurs est de définir correctement votre schéma. Détaillons les éléments importants de la configuration :

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

Les éléments les plus importants sont les suivants :

1. Définition du schéma : Décrit la structure, y compris toutes les propriétés et leurs types.
2. Champs obligatoires : Liste des propriétés qui doivent être incluses dans la réponse.
3. Propriétés supplémentaires : Lorsqu'il est défini sur False, il empêche la création de champs supplémentaires non définis dans le schéma.
4. Mode strict: Lorsque True, il garantit que le modèle suit précisément le schéma.

Conseils pratiques pour l'utilisation des résultats structurés

Pour obtenir les meilleurs résultats avec les sorties structurées, suivez les lignes directrices suivantes :

1. Concevez votre schéma avec soin: Incluez tous les champs obligatoires, mais concentrez-vous sur les informations essentielles.
2. Utilisez les types de données appropriés: Faites correspondre vos types de schéma à la manière dont vous utiliserez les données (nombres pour les calculs, chaînes pour le texte).
3. Fixer des contraintes claires: Utilisez enum pour les champs dont les options sont limitées et minimum /maximum pour les limites numériques.
4. Test avec des entrées variées: Veillez à ce que votre schéma prenne en compte les différents formats d'entrée et les cas particuliers.
5. Incluez des descriptions claires: L'ajout de descriptions aux champs aide le modèle à interpréter les informations à extraire.

Comparaison avec l'API Chat Completions

Alors que l'API Responses fournit des sorties structurées via JSON Schema, l'API Chat Completions propose une approche alternative utilisant les modèles Pydantic qui est beaucoup plus simple :

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

Chaque approche présente des avantages :

• L'API des réponses utilise le schéma JSON standard directement dans l'appel API.
• L'API Chat Completions s'intègre au système de types de Python par l'intermédiaire de Pydantic

Si vous voulez mon avis, j'utiliserais l'API Chat Completions pour éviter d'écrire des schémas JSON bruts. Jusqu'à ce que, bien sûr, OpenAI ajoute la prise en charge des modèles pydantiques à l'API des réponses.

Pour plus d'informations, consultez la documentation de l'API Documentation de l'API Responses pour les sorties structurées.

Conclusion

L'API OpenAI Responses simplifie la manière dont les développeurs interagissent avec les modèles de langage en combinant les points forts des API précédentes dans une interface unifiée qui nécessite moins de code et de complexité. Il prend en charge la génération de texte, l'analyse d'images, l'appel de fonctions et les sorties structurées, rendant ainsi les capacités d'IA plus accessibles tout en permettant aux développeurs de se concentrer sur la résolution de problèmes commerciaux plutôt que sur des défis d'intégration.

Alors que vous poursuivez votre voyage avec l'API de réponses, vous trouverez peut-être ces ressources supplémentaires utiles pour approfondir votre compréhension et développer vos compétences en matière de mise en œuvre :

• Travailler avec l'API OpenAI
• Le cursus des fondamentaux de l'OpenAI
• GPT-4.5 : Nouveautés du dernier modèle d'OpenAI
• Recherche approfondie avec OpenAI
• GPT-4.5 Didacticiel d'appel de fonction
• Tutoriel de l'API GPT-4.5
• Tutoriel sur le SDK des agents OpenAI