La récente version du modèle GPT-5 offre aux développeurs des capacités de pointe de l'IA avec des progrès dans le codage, le raisonnement et la créativité. Le modèle GPT-5 dispose de nouvelles fonctionnalités API qui vous permettent de créer des sorties où vous avez un contr?le détaillé. Cette amorce introduit GPT-5 dans le contexte de l'API, résume les différences et explique comment vous pouvez l'appliquer au code et aux taches automatisées.

GPT-5 est con?u pour les développeurs. Le nouveau GPT-5 utilise des outils qui vous permettent de contr?ler la verbosité, la profondeur du raisonnement et le format de sortie. Dans ce guide, vous apprendrez à commencer à utiliser GPT-5, à comprendre certains de ses paramètres uniques, ainsi qu'à examiner les échantillons de code du livre de cuisine d'Openai qui illustrent des processus offrant plus que les versions antérieures des modèles.

Table des matières

• Quoi de neuf dans GPT-5?
• Pourquoi utiliser GPT-5 via API?
• Commencer
  • Variantes du modèle
• Utilisation de GPT-5
  • Exemple d'appel d'API
• Capacités avancées
  • Contr?le de la verbosité
  • Fonction de forme libre appelle
• Prix ??et efficacité des jetons
• Conclusion
• Questions fréquemment posées

Quoi de neuf dans GPT-5?

Le GPT-5 est plus intelligent, plus contr?lable et mieux pour un travail complexe. C'est très bon pour la génération de code, le raisonnement et l'utilisation d'outils. Le modèle montre des performances de pointe sur les références d'ingénierie, écrit de belles interfaces utilisateurs frontales, suit bien les instructions et peut se comporter de manière autonome lors de la réalisation de taches en plusieurs étapes. Le modèle est con?u pour avoir l'impression d'interagir avec un véritable collaborateur. Ses principales caractéristiques comprennent:

Capacités révolutionnaires

• Performance de pointe sur Swe-Bench (74,9%) et Aider (88%)
• Génère un code d'interface utilisateur complexe et réactif tout en présentant un sens de conception
• Peut corriger les bugs durs et comprendre les grandes bases de code
• Planifie les taches comme un véritable agent d'IA car il utilise avec précision les API et se remet correctement à partir de défaillances d'outils.

Raisonnement plus intelligent et moins d'hallucinations

• Moins d'inexactitudes et d'hallucinations factuelles
• Meilleure compréhension et exécution des instructions utilisateur
• Comportement agentique et intégration des outils
• Peut entreprendre des workflows multi-étapes et multi-outils

Pourquoi utiliser GPT-5 via API?

GPT-5 est spécialement con?u pour les développeurs et réalise une performance de niveau expert sur le codage réel et les taches de données. Il a une API puissante qui peut débloquer l'automatisation, la précision et le contr?le. Que vous déboguez ou créez des applications complètes, GPT-5 est facile à intégrer à vos workflows, vous aidant à évoluer la productivité et la fiabilité avec peu de surcharge.

• Développeur spécifique: Construit pour le codage des workflows, il est donc facile d'intégrer dans les outils de développement et les IDE.
• Performances éprouvées: taches du monde réel SOTA (par exemple, fixes de bugs, modifications de code) avec des erreurs et des jetons nécessaires.
• Contr?le à grain fin : sur de nouveaux paramètres tels que la verbosité, le raisonnement et les appels d'outil Blueprint vous permet de fa?onner la sortie et de développer des pipelines automatisés.

Commencer

Afin de commencer à utiliser GPT-5 dans vos applications, vous devez configurer l'accès à l'API, comprendre les différents points de terminaison disponibles et sélectionner la bonne variante de modèle pour vos besoins. Cette section vous guidera dans la fa?on de configurer vos informations d'identification API, quel point de terminaison pour sélectionner le chat par rapport aux réponses, et naviguer dans les modèles GPT-5 afin que vous puissiez l'utiliser à son plein potentiel.

1. Accéder à l'API GPT-5

Tout d'abord, configurez vos informations d'identification API: si vous souhaitez utiliser OpenAI_API_KEY comme variable environnementale. Puis installer ou mettre à niveau le SDK OpenAI pour utiliser GPT-5. De là, vous pouvez appeler les modèles GPT-5 (GPT-5, GPT-5-MINI, GPT-5-NANO) comme tout autre modèle via l'API. Créez un fichier .env et enregistrez la clé API comme:

 Openai_api_key = sk-abc1234567890—

2. Clés API et authentification

Pour passer des appels API GPT-5, vous avez besoin d'une clé API OpenAI valide. Définissez la variable d'environnement OpenAI_API_KEY, soit passer la clé directement au client. Assurez-vous de garder votre clé en sécurité, car elle authentifiera vos demandes.

 Importer un système d'exploitation

à partir d'Openai Import Openai

Client = Openai (

api_key = os.environ.get ("openai_api_key")

)

3. Sélection du point final correct

GPT-5 propose l'API des réponses, qui sert de point de terminaison uniforme pour les interactions avec le modèle, fournissant des traces de raisonnement, des appels à outils et des contr?les avancés via la même interface, ce qui en fait la meilleure option dans l'ensemble. OpenAI recommande cette API pour tous les nouveaux déploiements.

 à partir d'Openai Import Openai

Importer un système d'exploitation

client = openai ()

réponse = client.Responses.Create (

modèle = "gpt - 5",

entrée = [{"R?le": "utilisateur", "Contenu": "Racontez-moi une histoire au coucher d'une phrase sur une licorne."}]

)

print (réponse.output_text)

Variantes du modèle

Utilisation de GPT-5

Pour accéder au GPT-5, nous pouvons utiliser le SDK OpenAI pour invoquer GPT-5. Par exemple, si vous êtes à Python:

 à partir d'Openai Import Openai

client = openai ()

Utilisez ensuite Client.Responses.Create pour soumettre des demandes avec vos messages et paramètres pour GPT-5. Le SDK utilisera automatiquement votre clé d'API pour authentifier la demande.

Structure de la demande d'API

Une demande d'API GPT-5 typique comprend les champs suivants:

• Modèle : La variante GPT-5 (GPT - 5, GPT-5-MINI ou GPT-5 - NANO).
• entrée / messages :
  • Pour l'API des réponses : utilisez un champ de saisie avec une liste de messages (chacun ayant un r?le et un contenu)
  • Pour l'API de Chat Completion : Utilisez le champ des messages avec la même structure
• Texte : Il s'agit d'un paramètre facultatif et contient un dictionnaire de paramètres de style de sortie, tels que:
  • Verbosité : ?faible?, ?milieu? ou ?élevé? pour contr?ler le niveau de détail
• Raisonnement : Il s'agit d'un paramètre facultatif et contient un dictionnaire pour contr?ler l'effort de raisonnement que le modèle s'applique, tel que:
  • Effort : ?minimal? pour des taches plus rapides et légères
• Outils : Il s'agit d'un paramètre facultatif et contient une liste de définitions d'outils personnalisées, par exemple pour les appels de fonction ou les contraintes de grammaire.
• Paramètres clés: verbosité, raisonnement_effort, max_tokens

Lors de l'interaction avec GPT - 5, divers paramètres vous permettent de personnaliser la réaction du modèle. Cette prise de conscience vous permet d'exercer plus de contr?le sur la qualité, les performances et les co?ts associés aux réponses que vous recevez.

• verbosité
  Administration du niveau de détail fourni dans la réponse du modèle.
  Familles acceptables (valeurs): ?faible?, ?médium? ou ?haut?
  • ?Low? est généralement indiqué dans une zone de texte non encore inclinée, et fournit des réponses courtes et au point
  • ?High? fournit des explications et des réponses approfondies et détaillées
    
• raisonnement_effort
  Fait référence à la quantité de raisonnement interne que fait le modèle avant de répondre.
  Familles acceptables (valeurs): ?minimal?, ?faible?, ?médium?, ?élevé?.
  • Définir ?minimal? renvoie généralement la réponse la plus rapide avec peu ou pas d'explication
  • La définition de ?haut? donne aux sorties des modèles plus de place pour une analyse plus approfondie et, par conséquent, des sorties plus développées par rapport aux paramètres antérieurs
    
• max_tokens
  Définit une limite supérieure pour le nombre de jetons dans la réponse du modèle. Les jetons max sont utiles pour contr?ler les co?ts ou restreindre la durée de votre réponse attendue.

Exemple d'appel d'API

Voici un exemple Python utilisant la bibliothèque OpenAI pour appeler GPT-5. Il prend une invite utilisateur et l'envoie, puis imprime la réponse du modèle:

 à partir d'Openai Import Openai

client = openai ()

réponse = client.Responses.Create (

modèle = "gpt-5",

input = [{"role": "utilisateur", "contenu": "Bonjour gpt-5, que pouvez-vous faire?"}],

text = {"verbosité": "médium"},

raisonnement = {"effort": "minimal"}

)

imprimer (réponse.output)

Sortir:

Capacités avancées

Dans la section suivante, nous testerons les 4 nouvelles capacités de l'API GPT-5.

Contr?le de la verbosité

Le paramètre de verbosité vous permet de signaler si le GPT - 5 doit être succinct ou verbeux. Vous pouvez définir la verbosité sur ?Low?, ?Medium? ou ?High?. Plus la verbosité est élevée, plus la sortie est longue et plus détaillée du modèle. Contrairement, la faible verbosité maintient le modèle concentré sur la fourniture de réponses plus courtes.

Exemple: codage du cas d'utilisation: série Fibonacci

 à partir d'Openai Import Openai

client = openai (api_key = "sk-proj ---")

prompt = "Outprover un programme Python pour la série Fibonacci"

Def ASK_WITH_VERBUITY (Verbosité: Str, Question: Str):

réponse = client.Responses.Create (

Model = "GPT-5-MINI",

entrée = question,

text = {

"Verbosité": verbosité

}

)

# Extraire la sortie du texte de l'assistant

output_text = ""

pour l'article en réponse.output:

Si hasattr (item, "contenu"):

pour le contenu dans item.content:

Si Hasattr (contenu, "texte"):

output_text = content.Text

# Détails d'utilisation des jetons

usage = réponse.

imprimer("--------------------------------")

print (f "Verbosité: {verbosité}")

Imprimer ("Sortie:")

print (output_text)

print ("tokens => entrée: {} | sortie: {}". Format (

usage.input_tokens, usage.output_tokens

))

Ce cas d'utilisation comprend la génération de code avec différents niveaux de verbosité

1. Faible : génère du code minimum avec très peu d'explications.

 ask_with_verbosity ("Low", invite)

Réponse:

 Verbosité: faible<br><br> Sortir:<br><br> `` Python<br><br> def fibonacci (n):<br><br> A, b = 0, 1<br><br> pour _ dans la gamme (n):<br><br> céder un<br><br> A, b = b, ab<br><br> def main ():<br><br> essayer:<br><br> n = int (entrée ("Entrez le nombre de numéros de Fibonacci à imprimer:"))<br><br> Si n <br> Print ("Veuillez entrer un entier positif.")<br><br> retour<br><br> sauf ValueError:<br><br> Imprimer (?entrée non valide?)<br><br> retour<br><br> print (* fibonacci (n))<br><br> Si __name__ == "__main__":<br><br> principal()<br><br> `` '<br><br> Jetons => entrée: 13 | Sortie: 375

2. Medium : génère du code avec des commentaires en ligne et avec quelques éléments structurels.

 ask_with_verbosity ("médium", invite)

Réponse:

 Verbosité: moyen<br><br> Sortir:<br><br> Voici un programme Python simple qui imprime les premiers nombres N Fibonacci (en commen?ant par 0, 1). Il valide l'entrée et utilise une approche itérative efficace:<br><br> `` Python<br><br> def fib_series (n):<br><br> "" "Renvoie une liste avec les nombres N Fibonacci des premiers (0, 1, 1, 2, ...)." ""<br><br> Si n <br> retour []<br><br> Si n == 1:<br><br> return [0]<br><br> série = [0, 1]<br><br> pour _ dans la plage (2, n):<br><br> série.APPEND (série [-1] série [-2])<br><br> série de retour<br><br> def main ():<br><br> essayer:<br><br> n = int (entrée ("Entrez le nombre de termes de fibonacci à générer:") .strip ())<br><br> sauf ValueError:<br><br> Print ("Veuillez entrer un entier valide.")<br><br> retour<br><br> Si n <br> Print ("Entrez un entier positif.")<br><br> retour<br><br> série = fib_series (n)<br><br> print ("Série Fibonacci (premiers {} termes):". Format (n))<br><br> print ("," .join (carte (STR, série))))<br><br> Si __name__ == "__main__":<br><br> principal()<br><br> `` '<br><br> Si vous voulez d'autres variantes (par exemple, version récursive, générateur qui donne les valeurs indéfiniment ou imprimer jusqu'à une valeur maximale au lieu d'un décompte), dites-moi lequel et je peux le fournir.<br><br> Jetons => entrée: 13 | Sortie: 590

3. High : génère des scripts de production complets avec des arguments, une validation et des commentaires détaillés.

 ask_with_verbosity ("high", invite)

Réponse:

 Verbosité: élevée<br><br> Sortir:<br><br> Vous trouverez ci-dessous plusieurs programmes / fonctions Python pour générer des nombres de Fibonacci et la série Fibonacci. J'inclus une courte explication pour chacun, des exemples de la fa?on de les utiliser et des notes sur les performances afin que vous puissiez choisir celle qui correspond le mieux à vos besoins.<br><br> Remarque: La convention habituelle indiquée ici est F0 = 0, F1 = 1, FN = FN-1 FN-2.<br><br> 1) Version itérative simple - Recommandé pour générer une séquence (O (n) Temps, O (1) Espace supplémentaire)<br><br> `` Python<br><br> def fibonacci_list (n):<br><br> "" "Renvoie une liste avec les premiers n numéros de Fibonacci: f0 .. f (n-1).<br><br> n doit être un entier non négatif. "" "<br><br> Si n <br> augmenter ValueError ("n doit être non négatif")<br><br> Si n == 0:<br><br> retour []<br><br> Si n == 1:<br><br> return [0]<br><br> seq = [0, 1]<br><br> pour _ dans la plage (2, n):<br><br> seq.append (seq [-1] seq [-2])<br><br> retourner seq<br><br> # Exemple d'utilisation:<br><br> Si __name__ == "__main__":<br><br> k = int (entrée ("quel fibonacci index (n)?"))<br><br> print (f "f_ {k} =", fibonacci_n (k))<br><br> `` '<br><br> 2) Style du générateur - itérer paresseusement sur la séquence<br><br> `` Python<br><br> def fib_generator ():<br><br> "" "Générateur Fibonacci infini: donne 0, 1, 1, 2, 3, ..." ""<br><br> A, b = 0, 1<br><br> Bien que vrai:<br><br> céder un<br><br> A, b = b, ab<br><br> # Exemple: Imprimez les 10 premiers numéros Fibonacci<br><br> Si __name__ == "__main__":<br><br> Importer Itertools<br><br> pour x dans itertools.islice (fib_generator (), 10):<br><br> imprimer (x, end = "")<br><br> imprimer()<br><br> `` '<br><br> `` '<br><br> 3) récursif avec la mémorisation (rapide et simple)<br><br> `` Python<br><br> à partir de functools import lru_cache<br><br> @lru_cache (maxsize = aucun)<br><br> def fib_memo (n):<br><br> Si n <br> augmenter ValueError ("n doit être non négatif")<br><br> Si n <br> retour n<br><br> return fib_memo (n-1) fib_memo (n-2)<br><br> # Exemple:<br><br> Si __name__ == "__main__":<br><br> print (fib_memo (100)) # fonctionne rapidement grace à la mémorisation<br><br> `` '<br><br> `` '<br><br> Lequel devez-vous utiliser?<br><br> - Pour une utilisation typique (imprimez les nombres N Fibonacci des premiers nombres ou calculez F_N pour modéré n), utilisez le simple fibonacci_list itératif ou Fibonacci_N.<br><br> - Pour un très grand N (par exemple, des milliers ou des millions de chiffres), utilisez la méthode de doublement rapide (fib_fast_doubling) - il calcule f_n dans les opérations arithmétiques o (log n) en utilisant les grands entiers de Python.<br><br> - évitez la récursivité na?ve sauf pour l'enseignement / démonstration.<br><br> - Utilisez la récursivité mémorisée pour plus de commodité si vous voulez un style récursif mais que vous avez toujours besoin de vitesse.<br><br> Si vous me dites quelle variante vous souhaitez (Imprimer la série vs rendement nth, les indices de démarrage, la fa?on dont vous voulez la saisie ou les limites comme très grand n), je peux fournir un seul petit script adapté à ce cas d'utilisation.<br><br> Jetons => entrée: 13 | Sortie: 1708

Fonction de forme libre appelle

GPT - 5 peut désormais envoyer des charges utiles de texte brutes - tout ce qui, des scripts Python, aux requêtes SQL - à votre outil personnalisé sans envelopper les données en JSON à l'aide du nouvel outil ?Type?: ?Custom?. Cela diffère des appels de fonction structurés classiques, vous offrant une plus grande flexibilité lors de l'interaction avec des temps d'exécution externes tels que:

• Code_exec avec sandbox (Python, C, Java,…)
• Bases de données SQL
• Environnements de coquille
• Générateurs de configuration

Notez que le type d'outil personnalisé ne prend pas en charge les appels d'outils parallèles.

Pour illustrer l'utilisation de l'appel d'outils de forme libre, nous demanderons à GPT - 5 de:

• Générez le code Python, C et Java qui multiplie 2 matrices 5 × 5.
• Imprimez uniquement le temps (en ms) pris pour chaque itération dans le code.
• Appelez les trois fonctions, puis arrêtez

 à partir d'Openai Import Openai

à partir de la liste des importations, facultative

Model_Name = "GPT-5-MINI"

# Outils qui seront transmis à chaque invocation du modèle

Outils = [

{

"Type": "Custom",

"nom": "code_exec_python",

"Description": "Exécute le code Python",

},

{

"Type": "Custom",

"nom": "code_exec_cpp",

"Description": "Exécute le code C",

},

{

"Type": "Custom",

"nom": "code_exec_java",

"Description": "Exécute le code Java",

},

]]

client = openai (api_key = "add-your-api-key")

def Create_Response (

input_messages: list [dict],

Précéaire_Response_id: facultatif [str] = aucun,

):

"" "Emballage autour du client.Responses.Create." ""

kwargs = {

"Modèle": Model_name,

"Input": input_messages,

"texte": {"format": {"type": "text"}},

"Outils": outils,

}

Si précédemment_Response_id:

kwargs ["préalable_response_id"] = préalable_response_id

return Client.Responses.Create (** KWARGS)

def run_conversation (

input_messages: list [dict],

Précéaire_Response_id: facultatif [str] = aucun,

):

"" "Fonction récursive pour gérer les appels d'outils et poursuivre la conversation." ""

Response = Create_Response (Input_Messages, PREVER_RESPONSE_ID)

# Vérifiez les appels d'outils dans la réponse

TOLL_CALLS = [sortie pour la sortie dans Response.Output if Output.Type == "Custom_tool_Call"]

Si TOLL_CALLS:

# Gérer tous les appels d'outils dans cette réponse

Pour TOLL_CALL dans TOLL_CALLS:

Imprimer ("--- Nom de l'outil ---")

print (tool_call.name)

Print ("--- Argument de l'appel d'outil (code généré) ---")

print (tool_call.input)

print () # Ajouter un espacement

# Ajouter un résultat de l'outil synthétique pour continuer la conversation

input_messages.append ({

"type": "function_call_output",

"call_id": tool_call.call_id,

"sortie": "fait",

})

# Continuez la conversation récursivement

return run_conversation (input_messages, préalable_response_id = réponse.id)

autre:

# Plus d'appels d'outils - Vérifiez la réponse finale

If Response.output et Len (Response.output)> 0:

message_content = réponse.output [0] .Content

Si message_content:

print ("--- Réponse du modèle final ---")

print (message_content)

autre:

print ("--- Conversation terminée (pas de message final) ---")

Réponse de retour

# Votre invite

prompt = "" "

écrivez du code pour multiplier deux matrices 5x5 en trois langues: C, Python et Java à l'aide de fonctions Code_exec. Chaque langue doit multiplier les matrices 10 fois et mesurer le temps pris pour chaque itération.

Appelez toujours ces trois fonctions exactement une fois: code_exec_python, code_exec_cpp et codes_exec_java outils pour effectuer la multiplication de la matrice dans chaque langue une fois.

Imprimez uniquement le temps nécessaire pour multiplier les matrices (en millisecondes) par itération.

"" "

# Message initial du développeur

messages = [

{

"r?le": "développeur",

"Contenu": invite,

}

]]

# Démarrer la conversation

run_conversation (messages)

Réponse dans les 3 langues:

 --- Nom de l'outil ---<br><br> code_exec_python<br><br> --- Argument de l'appel d'outil (code généré) ---<br><br> heure d'importation<br><br> N = 5<br><br> A = [[ij pour j dans la gamme (n)] pour i dans la plage (n)]<br><br> B = [[i * j pour j dans la plage (n)] pour i dans la plage (n)]<br><br> Def Matmul (A, B):<br><br> N = len (a)<br><br> C = [[0] * n pour _ dans la plage (n)]<br><br> pour i à portée (n):<br><br> pour j à portée (n):<br><br> S = 0<br><br> pour k dans la gamme (n):<br><br> s = a [i] [k] * b [k] [j]<br><br> C [i] [j] = s<br><br> retour c<br><br> pour _ dans la gamme (10):<br><br> t1 = time.perf_counter ()<br><br> C = matmul (a, b)<br><br> t2 = time.perf_counter ()<br><br> ms = (t2 - t1) * 1000.0<br><br> # Imprimez uniquement le temps en millisecondes par itération<br><br> Imprimer (MS)<br><br> --- Nom de l'outil ---<br><br> code_exec_cpp<br><br> --- Argument de l'appel d'outil (code généré) ---<br><br> #inclure<bits .h><br><br> Utilisation de Namespace Std;<br><br> int main () {<br><br> const int n = 5;<br><br> double a [n] [n], b [n] [n], c [n] [n];<br><br> pour (int i = 0; i <n i><br> pour (int j = 0; j <n j><br> A [i] [j] = ij;<br><br> B [i] [j] = i * j;<br><br> }<br><br> pour (int it = 0; it <br> pour (int i = 0; i <n i><br> pour (int j = 0; j <n j><br> C [i] [j] = 0,0;<br><br> auto t1 = chrono :: high_resolution_clock :: maintenant ();<br><br> pour (int i = 0; i <n i><br> pour (int j = 0; j <n j><br> double s = 0,0;<br><br> pour (int k = 0; k <n k><br> s = a [i] [k] * b [k] [j];<br><br> C [i] [j] = s;<br><br> }<br><br> }<br><br> auto t2 = chrono :: high_resolution_clock :: maintenant ();<br><br> Double MS = Chrono :: Durée<double milli> (t2 - t1) .Count ();<br><br> cout <br> }<br><br> retour 0;<br><br> }<br><br> --- Nom de l'outil ---<br><br> code_exec_java<br><br> --- Argument de l'appel d'outil (code généré) ---<br><br> classe publique Main {<br><br> public static void main (String [] args) {<br><br> int n = 5;<br><br> double [] [] a = nouveau double [n] [n];<br><br> double [] [] b = nouveau double [n] [n];<br><br> double [] [] c = nouveau double [n] [n];<br><br> pour (int i = 0; i <n i><br> pour (int j = 0; j <n j><br> A [i] [j] = ij;<br><br> B [i] [j] = i * j;<br><br> }<br><br> pour (int it = 0; it <br> pour (int i = 0; i <n i><br> pour (int j = 0; j <n j><br> C [i] [j] = 0,0;<br><br> long t1 = System.NanoTime ();<br><br> pour (int i = 0; i <n i><br> pour (int j = 0; j <n j><br> double s = 0,0;<br><br> pour (int k = 0; k <n k><br> s = a [i] [k] * b [k] [j];<br><br> C [i] [j] = s;<br><br> }<br><br> }<br><br> long t2 = System.NanoTime ();<br><br> double ms = (t2 - t1) / 1_000_000.0;<br><br> System.out.println (MS);<br><br> }<br><br> }<br><br> }</n></n></n></n></n></n></n></double></n></n></n></n></n></n></n></bits>

Application de la grammaire sans contexte (CFG)

La fonction d'application de la grammaire sans contexte (CFG) de GPT-5 permet aux développeurs de contraindre les sorties d'une structure rigide, idéale s'il existe des formats très précis, comme SQL ou même Regex. Un exemple pourrait être d'avoir une grammaire séparée pour MS SQL (en haut) et PostgreSQL (limite) et garantir que GPT-5 génère une requête syntaxiquement valide pour l'une ou l'autre de ces bases de données.

Le MSSQL_GRAMMAR spécifie la structure exacte d'une requête SQL Server valide pour la sélection, le filtrage, la commande et la syntaxe. Il limite le modèle à:

• Renvoi d'un nombre fixe de lignes (top n)
• Filtrage sur le Total_amount et Order_Date
• Utilisation de la syntaxe appropriée comme l'ordre par… desc et des demi-colons
• En utilisant uniquement des requêtes en lecture seule avec un ensemble fixe de colonnes, de mots clés et de formats de valeur

Grammaire postgresql

• Le Postgres_grammar est analogue à MSSQL_GRAMMAR, mais est con?u pour correspondre à la syntaxe de PostgreSQL en utilisant la limite au lieu du haut. Il limite le modèle à:
• Utilisation de la limite N pour limiter la taille des résultats
• En utilisant les mêmes règles de filtrage et de commande
• Valider les identifiants, les nombres et les formats de date
• Limiter les opérations SQL dangereuses / non soutenues en limitant la structure SQL.

 importer textwrap

# ----------------- Grammaires pour le dialecte MS SQL -----------------

mssql_grammar = textwrap.dedent (r "" "

// ---------- ponctuation et opérateurs ----------

SP: ""

Comma: ","

GT: ">"

Eq: "="

Semi: ";"

// ---------- Commencer ----------

Démarrer: "Sélectionnez" SP "TOP" NUMBRE SP SELECT_LIST SP "FROM" SP TABLE SP "où" SP Mult_Filter SP "et" SP DATE_FILTER SP "ORDER" SP "par" SP SORT_COLS SEMI

// ---------- Projections ----------

select_list: colonne (colonne de virgule SP) *

colonne: identifiant

// ---------- Tables ----------

Tableau: identifiant

// ---------- Filtres ----------

quantité_filter: "Total_amount" SP GT SP Numéro

DATE_FILTER: "ORDER_DATE" SP GT SP DATE

// ---------- Tri ----------

sort_cols: "Order_Date" SP "DESC"

// ---------- Terminaux ----------

Identifier: / [a-za-z _] [a-za-z0-9 _] * /

Numéro: / [0-9] /

Date: / '[0-9] {4} - [0-9] {2} - [0-9] {2}' /

"" ")

# ----------------- Grammaires pour le dialecte postgresql -----------------

postgres_grammar = textwrap.dedent (r "" "

// ---------- ponctuation et opérateurs ----------

SP: ""

Comma: ","

GT: ">"

Eq: "="

Semi: ";"

// ---------- Commencer ----------

Démarrer: "Sélectionnez" SP SELECT_LIST SP "FROM" SP TABLE SP "où" SP Mult_Filter SP "et" SP DATE_FILTER SP "ORDER" SP "par" SP SORT_COLS SP "LIMIT" SP NUMBRE SEMI

// ---------- Projections ----------

select_list: colonne (colonne de virgule SP) *

colonne: identifiant

// ---------- Tables ----------

Tableau: identifiant

// ---------- Filtres ----------

quantité_filter: "Total_amount" SP GT SP Numéro

DATE_FILTER: "ORDER_DATE" SP GT SP DATE

// ---------- Tri ----------

sort_cols: "Order_Date" SP "DESC"

// ---------- Terminaux ----------

Identifier: / [a-za-z _] [a-za-z0-9 _] * /

Numéro: / [0-9] /

Date: / '[0-9] {4} - [0-9] {2} - [0-9] {2}' /

"" ")

L'exemple utilise GPT-5 et un outil MSSQL_GRAMMAR personnalisé pour produire une requête SQL Server qui renvoie les commandes de grande valeur récemment faites récemment, par le client. Le MSSQL_GRAMMAR a créé des règles de grammaire pour appliquer la syntaxe SQL Server et a produit la syntaxe de sélection de sélection correcte pour renvoyer des résultats limités.

 à partir d'Openai Import Openai

client = openai ()

sql_prompt_mssql = (

"Appelez le MSSQL_GRAMMAR pour générer une requête pour Microsoft SQL Server qui récupère le"

"Cinq commandes les plus récentes par client, montrant Customer_ID, ORDER_ID, ORDER_DATE et TOTAL_AMOUNT,"

"Où Total_amount> 500 et Order_Date est après '2025-01-01'."

)

réponse_mssql = client.Responses.Create (

modèle = "gpt-5",

input = sql_prompt_mssql,

text = {"format": {"type": "text"}},

outils = [

{

"Type": "Custom",

"nom": "mssql_grammar",

"Description": "Exécute les requêtes de serveur Microsoft SQL en lecture seule Limited pour sélectionner des instructions avec le haut et la base de la commande.

"format": {

"Type": "Grammaire",

"Syntaxe": "Lark",

"Définition": MSSQL_GRAMMAR

}

},

],

parallel_tool_calls = false

)

print ("--- MS SQL Query ---")

print (réponse_mssql.output [1] .input)

Réponse:

 --- MS SQL Query ---<br><br> Sélectionnez le top 5 Customer_ID, Order_id, Order_Date, Total_amount à partir des commandes<br><br> Où total_amount> 500 et ordonnance_date> '2025-01-01'<br><br> Ordre par ORDAND_DATE DESC;

Cette version cible PostgreSQL et utilise un outil Postgres_grammar pour aider GPT-5 à produire une requête conforme. Il suit la même logique que l'exemple précédent, mais utilise la limite pour la limite des résultats de retour, démontrant la syntaxe postgresql conforme.

 sql_prompt_pg = (

"Appelez le Postgres_grammar pour générer une requête pour PostgreSQL qui récupère le"

"Cinq commandes les plus récentes par client, montrant Customer_ID, ORDER_ID, ORDER_DATE et TOTAL_AMOUNT,"

"Où Total_amount> 500 et Order_Date est après '2025-01-01'."

)

réponse_pg = client.Responses.Create (

modèle = "gpt-5",

input = sql_prompt_pg,

text = {"format": {"type": "text"}},

outils = [

{

"Type": "Custom",

"nom": "postgres_grammar",

"Description": "Exécute des requêtes postgresql en lecture seule limitées à sélectionner des instructions avec limite et de base où / commande par. Vous devez raisonner beaucoup sur la requête et vous assurer qu'elle obéit à la grammaire.",

"format": {

"Type": "Grammaire",

"Syntaxe": "Lark",

"Définition": postgres_grammar

}

},

],

parallel_tool_calls = false,

)

print ("--- PG SQL Query ---")

print (réponse_pg.output [1] .input)

Réponse:

 --- PG SQL Query ---<br><br> Sélectionnez Customer_ID, ORDAND_ID, ORDER_DATE, TOTAL_AMOUNT à partir des commandes<br><br> Où total_amount> 500 et ordonnance_date> '2025-01-01'<br><br> Ordre par ORDAND_DATE DESC LIMIT 5;

Effort de raisonnement minimal

GPT-5 soutient désormais un nouvel effort de raisonnement minimal. Lorsque vous utilisez un effort de raisonnement minimal, le modèle sortira très peu ou pas de jetons de raisonnement. Ceci est con?u pour les cas d'utilisation où les développeurs souhaitent un jeton très rapide de temps à utiliser.

Remarque : Si aucun effort de raisonnement n'est fourni, la valeur par défaut est moyenne.

 à partir d'Openai Import Openai

client = openai ()

prompt = "traduire la phrase suivante en espagnol. Renvoyez uniquement le texte traduit."

réponse = client.Responses.Create (

modèle = "gpt-5",

entrée = [

{'role': 'développeur', 'contenu': invite},

{'r?le': 'utilisateur', 'contenu': 'Où est la gare la plus proche?' }

],

raisonnement = {"effort": "minimal"}

)

# Extraire la sortie du texte du modèle

output_text = ""

pour l'article en réponse.output:

Si hasattr (item, "contenu"):

pour le contenu dans item.content:

Si Hasattr (contenu, "texte"):

output_text = content.Text

# Détails d'utilisation des jetons

usage = réponse.

imprimer("--------------------------------")

Imprimer ("Sortie:")

print (output_text)

Réponse :

 --------------------------------<br><br> Sortir:<br><br> ?Dónde Está la Estación de Tren Más Cercana?

Prix ??et efficacité des jetons

OpenAI a des modèles GPT-5 en niveaux pour répondre à diverses exigences de performance et de budget. GPT-5 convient aux taches complexes. GPT-5-MINI accomplit rapidement les taches et est moins cher, et GPT-5-Nano est pour des cas d'utilisation en temps réel ou légers. Tous les jetons réutilisés dans les conversations à court terme obtiennent une remise de 90%, ce qui réduit considérablement les co?ts des interactions multi-tours.

Conclusion

GPT-5 spécifie une nouvelle ère de l'IA pour les développeurs. Il combine l'intelligence de codage de niveau supérieur avec un plus grand contr?le via son API. Vous pouvez vous engager avec ses fonctionnalités, telles que le contr?le de la verbosité, l'activation des appels d'outils personnalisés, l'application de la grammaire et l'exécution du raisonnement minimal. Avec l'aide de ceux-ci, vous pouvez créer des applications plus intelligentes et fiables.

De l'automatisation des workflows complexes à l'accélération des workflows banals, GPT-5 est con?u avec une flexibilité et des performances énormes pour permettre aux développeurs de créer. Examinez et explorez les fonctionnalités et les capacités de vos projets pour tirer parti entièrement les avantages du GPT-5.

Référence: livre de cuisine Openai

Questions fréquemment posées

A. GPT - 5 est le plus puissant. GPT-5-MINI équilibre la vitesse et le co?t. GPT - 5-NANO est le moins cher et le plus rapide, idéal pour les cas d'utilisation légers ou en temps réel.

UN . Utilisez le paramètre de verbosité:
"bas" = court
"Medium" = équilibré
"haut" = détaillé
Utile pour régler les explications, les commentaires ou la structure du code.

A. Utilisez le point de terminaison des réponses. Il prend en charge l'utilisation des outils, le raisonnement structuré et les paramètres avancés, tout au long d'une interface unifiée. Recommandé pour la plupart des nouvelles applications.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!