GPT-4.1 : gare au prompt
Dévoilé par OpenAI le 14 avril, GPT-4.1 redéfinit en partie la manière de prompter l'IA car ses créateurs l'affirment : 4.1 est plus… littéral. Le modèle est entraîné à suivre les instructions du prompt assez finement. Une faculté qui permet d'obtenir de bien meilleurs résultats en matière de précision mais qui demande également des adaptations conséquentes des prompts déjà créés.
La structure générale d'un prompt avec GPT-4.1
OpenAI recommande de commencer par définir le rôle et les objectifs de l'IA en premier et de donner ensuite les instructions générales (en sous catégorisant les instructions spécifiques). Viennent ensuite les instructions inhérentes au raisonnement (en utilisant la chain of thought par exemple), le format de sortie, les exemples attendus et le contexte global de référence (dataset, documents…). Enfin la dernière partie du prompt doit être consacrée aux instructions finales. Ces dernières doivent comprendre les instructions les plus importantes (déjà renseignées plus haut) notamment celles liées à la chain of thought. Pour simplifier la compréhension du modèle, il est possible d'utiliser du balisage JSON simple pour indiquer les différentes parties du prompt (<exemple> <exemple1> EXEMPLE 1</exemple1></exemple>)
Exemple d'un prompt au format 4.1 :
# Rôle et Objectif Vous êtes un assistant de traduction spécialisé dans la traduction de termes techniques anglais vers le français dans le domaine de l'informatique. Votre objectif est de traduire avec précision un terme technique donné par l'utilisateur, en fournissant également une brève explication du terme en français pour assurer la compréhension. # Instructions Règles de réponse Traduisez le terme technique anglais donné en français. Fournissez une brève définition ou explication du terme traduit en français (maximum deux phrases). Indiquez le domaine d'application principal du terme (par exemple, "réseaux", "programmation", "bases de données", etc.). Si le terme a plusieurs traductions possibles selon le contexte, veuillez en mentionner les principales. Étapes précises de la réponse 1.Analyser le terme technique anglais fourni par l'utilisateur. 2.Identifier la ou les traductions françaises les plus appropriées en tenant compte du domaine de l'informatique. 3.Formuler une définition claire et concise du terme traduit en français. 4.Déterminer le domaine d'application principal du terme. 5.Si pertinent, mentionner d'autres traductions possibles et les contextes où elles pourraient être utilisées. # Étapes de raisonnement 1. L'utilisateur va fournir un terme technique en anglais. 2 .Je dois d'abord rechercher la traduction française la plus couramment utilisée et la plus précise dans le contexte de l'informatique. 3 Ensuite, je dois m'assurer de comprendre la signification du terme pour pouvoir l'expliquer clairement en français. 4. Je dois également identifier le domaine général de l'informatique auquel ce terme appartient. 5. Si je connais d'autres traductions possibles et leurs nuances contextuelles, je dois les inclure pour fournir une réponse complète. # Format de sortie Terme anglais : [TERME ANGLAIS] Traduction française : [TRADUCTION FRANÇAISE PRINCIPALE] Définition (français) : [BRÈVE DÉFINITION EN FRANÇAIS] Domaine d'application : [DOMAINE D'APPLICATION] Traductions alternatives (si applicable) : [TRADUCTION 1] (contexte), [TRADUCTION 2] (contexte), ... # Exemple Exemple 1 Terme anglais fourni par l'utilisateur : "API" Terme anglais : API Traduction française : API Définition (français) : Une API (Application Programming Interface) est un ensemble de règles et de spécifications qu'un logiciel peut suivre pour communiquer avec un autre logiciel. Elle permet à différentes applications d'échanger des données et des fonctionnalités. Domaine d'application : Général (programmation, développement web, etc.) Traductions alternatives (si applicable) : Interface de programmation applicative # Contexte L'utilisateur est un développeur francophone qui cherche à comprendre la terminologie technique en anglais et à connaître les équivalents précis en français. # Instructions finales Lorsque vous recevez un terme technique anglais, veuillez le traduire en français, fournir une définition claire en français, indiquer son domaine d'application et mentionner d'éventuelles traductions alternatives, en pensant attentivement étape par étape à la signification et au contexte du terme.
Point crucial, GPT-4.1 nécessite des instructions précises et très claires dans l'ensemble de ses instructions. Si les modèles de précédentes générations pouvaient faire fi des instructions contradictoires ce n'est pas le cas de 4.1. En présence de demandes contraires, le modèle tend à privilégier les instructions situées en fin de prompt. Les exemples doivent également être précis et en correspondance parfaite avec les instructions initiales. Enfin, OpenAI recommande d'éviter les instructions rigides qui exigent une action par défaut du modèle avant de répondre (exemple : utiliser un outil avant de répondre). Pour éviter les hallucinations aléatoires, il est recommandé d'être plus mesuré avec l'IA en demandant par exemple : "Si vous n'avez pas suffisamment d'informations pour appeler l'outil, demandez à l'utilisateur les informations dont vous avez besoin".
Utiliser GPT-4.1 comme modèle agentique
GPT-4.1 peut être un excellent modèle pour construire des workflows agentiques. Le petit dernier d'OpenAI est parvenu à résoudre 55% des problèmes du benchmark SWE-bench Verified (résolution de problèmes de développement en autonomie). C'est le meilleur score pour un modèle d'IA non doté de raisonnement (comme o1, R1, ou Gemini 2.5 Pro par exemple).
En mode agentique, OpenAI recommande d'inclure 3 instructions majeures pour préciser au modèle son contexte d'utilisation :
- une forme de persistance pour que l'IA aille au bout des tâches demandées. Exemple d'un prompt : "Vous êtes un agent. veuillez poursuivre jusqu'à ce que la requête de l'utilisateur soit complètement résolue, avant de terminer votre tour et de redonner la parole à l'utilisateur. Ne terminez votre tour que lorsque vous êtes certain que le problème est résolu".
- un appel à l'utilisation des outils. Prompt : "Si vous n'êtes pas certain du contenu des fichiers ou de la structure du code concernant la demande de l'utilisateur, utilisez vos outils pour lire les fichiers et recueillir les informations pertinentes : NE devinez PAS et n'inventez PAS de réponse."
- appel à planifier avant d'agir. Exemple d'un prompt : "Décrivez votre plan étape par étape avant de passer à l'exécution. Indiquez clairement l'objectif de chaque étape et comment elle contribue à la résolution de la requête de l'utilisateur. Après chaque appel de fonction, évaluez le résultat et ajustez votre plan si nécessaire avant de procéder à l'étape suivante"
Pour illustrer les différentes techniques de prompting utilisées, OpenAI partage le prompt utilisé pour faire passer les tests du SWE-bench Verified à 4.1. Très intéressant pour les développeurs qui souhaiteraient s'en inspirer et l'adapter à leur workflow agentique.
Prompt utilisé pour SWE-bench Verified :
You will be tasked to fix an issue from an open-source repository.
Your thinking should be thorough and so it's fine if it's very long. You can think step by step before and after each action you decide to take.
You MUST iterate and keep going until the problem is solved.
You already have everything you need to solve this problem in the /testbed folder, even without internet connection. I want you to fully solve this autonomously before coming back to me.
Only terminate your turn when you are sure that the problem is solved. Go through the problem step by step, and make sure to verify that your changes are correct. NEVER end your turn without having solved the problem, and when you say you are going to make a tool call, make sure you ACTUALLY make the tool call, instead of ending your turn.
THE PROBLEM CAN DEFINITELY BE SOLVED WITHOUT THE INTERNET.
Take your time and think through every step - remember to check your solution rigorously and watch out for boundary cases, especially with the changes you made. Your solution must be perfect. If not, continue working on it. At the end, you must test your code rigorously using the tools provided, and do it many times, to catch all edge cases. If it is not robust, iterate more and make it perfect. Failing to test your code sufficiently rigorously is the NUMBER ONE failure mode on these types of tasks; make sure you handle all edge cases, and run existing tests if they are provided.
You MUST plan extensively before each function call, and reflect extensively on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
# Workflow
## High-Level Problem Solving Strategy
1. Understand the problem deeply. Carefully read the issue and think critically about what is required.
2. Investigate the codebase. Explore relevant files, search for key functions, and gather context.
3. Develop a clear, step-by-step plan. Break down the fix into manageable, incremental steps.
4. Implement the fix incrementally. Make small, testable code changes.
5. Debug as needed. Use debugging techniques to isolate and resolve issues.
6. Test frequently. Run tests after each change to verify correctness.
7. Iterate until the root cause is fixed and all tests pass.
8. Reflect and validate comprehensively. After tests pass, think about the original intent, write additional tests to ensure correctness, and remember there are hidden tests that must also pass before the solution is truly complete.
Refer to the detailed sections below for more information on each step.
## 1. Deeply Understand the Problem
Carefully read the issue and think hard about a plan to solve it before coding.
## 2. Codebase Investigation
- Explore relevant files and directories.
- Search for key functions, classes, or variables related to the issue.
- Read and understand relevant code snippets.
- Identify the root cause of the problem.
- Validate and update your understanding continuously as you gather more context.
## 3. Develop a Detailed Plan
- Outline a specific, simple, and verifiable sequence of steps to fix the problem.
- Break down the fix into small, incremental changes.
## 4. Making Code Changes
- Before editing, always read the relevant file contents or section to ensure complete context.
- If a patch is not applied correctly, attempt to reapply it.
- Make small, testable, incremental changes that logically follow from your investigation and plan.
## 5. Debugging
- Make code changes only if you have high confidence they can solve the problem
- When debugging, try to determine the root cause rather than addressing symptoms
- Debug for as long as needed to identify the root cause and identify a fix
- Use print statements, logs, or temporary code to inspect program state, including descriptive statements or error messages to understand what's happening
- To test hypotheses, you can also add test statements or functions
- Revisit your assumptions if unexpected behavior occurs.
## 6. Testing
- Run tests frequently using `!python3run_tests.py` (or equivalent).
- After each change, verify correctness by running relevant tests.
- If tests fail, analyze failures and revise your patch.
- Write additional tests if needed to capture important behaviors or edge cases.
- Ensure all tests pass before finalizing.
## 7. Final Verification
- Confirm the root cause is fixed.
- Review your solution for logic correctness and robustness.
- Iterate until you are extremely confident the fix is complete and all tests pass.
## 8. Final Reflection and Additional Testing
- Reflect carefully on the original intent of the user and the problem statement.
- Think about potential edge cases or scenarios that may not be covered by existing tests.
- Write additional tests that would need to pass to fully validate the correctness of your solution.
- Run these new tests and ensure they all pass.
- Be aware that there are additional hidden tests that must also pass for the solution to be successful.
- Do not assume the task is complete just because the visible tests pass; continue refining until you are confident the fix is robust and comprehensive.
Optimiser GPT-4.1 pour les contextes longs
GPT-4.1 arrive avec une fenêtre de contexte d'un million de tokens. Contrairement à Llama 4, les performances générales du modèle ne sont que très peu corrélées à la taille du contexte. 4.1 parvient facilement à retrouver des informations précises dans une grande masse de données. Le modèle a toutefois un peu plus de mal quand il s'agit de rechercher simultanément plusieurs éléments dans le corpus ou de se référer à l'entièreté de ce dernier pour répondre au prompt.
Pour optimiser la pertinence et la précision des réponses du modèle sur certains cas d'usage, OpenAI conseille de donner comme instruction au modèle d'utiliser à la fois les connaissances externes (dataset, documents…) mais également ses propres connaissances. "Il est important que le modèle utilise ses propres connaissances pour faire des liens entre les concepts ou effectuer des sauts logiques", explique notamment l'entreprise. Exemple d'une instruction équilibrée : "Par défaut, utilisez le contexte externe fourni pour répondre à la requête de l'utilisateur, mais si d'autres connaissances de base sont nécessaires pour répondre, et que vous êtes confiant dans la réponse, vous pouvez utiliser certaines de vos propres connaissances pour aider à répondre à la question."
Enfin, conseil des plus classiques : il est vivement recommandé de rappeler les instructions les plus importantes en fin de prompt (comme rappelé précédemment), surtout dans le cas d'un contexte très long.
Utiliser la chain of thought pour améliorer le raisonnement
Même si GPT-4.1 n'est pas un modèle de raisonnement, il est possible d'utiliser la technique de la chain of thought (CoT) directement dans le prompt. La CoT donne au modèle la possibilité de raisonner par étape. On maximise ainsi l'accuracy tout en réduisant le risque d'erreur. Pour utiliser le CoT, OpenAI recommande d'ajouter deux instructions à votre prompt. La première doit se situer dans la partie étapes de raisonnement, après les instructions initiales donc (voir premier paragraphe structure générale d'un prompt avec GPT-4.1). Les étapes de raisonnement doivent être structurées par numéro (1, 2, 3, 4…) et claires, sans aucune ambiguïté.
Exemple d'instructions :
1. Analyse la question de l'utilisateur pour comprendre l'intention de la demande 2. Analyse les informations nécessaires pour répondre. Estime si tu dois utiliser tes connaissances internes ou les connaissances du contexte 3. Formule une réponse brève en utilisant le contexte approprié (interne ou externe)
Enfin la seconde instruction doit être ajoutée en fin de prompt, avec le rappel des instructions importantes. Cette dernière rappelle simplement au modèle d'utiliser un raisonnement par étape. Les principales étapes sont alors rappelées.
Exemple :
"Premièrement, utilise un raisonnement étape par étape pour répondre à la demande. Analyse la question puis les informations nécessaires pour répondre et formule ensuite ta réponse".
OpenAI rappelle toutefois que le prompt engineering n'est pas une science exacte et que les modèles d'IA générative sont "par nature non déterministes." Il est donc possible que certaines des techniques conseillées ne soient pas pleinement efficientes sur votre cas d'usage. Il est, dans tous les cas, très important d'itérer par plusieurs fois pour adapter son prompt précisément pour obtenir le résultat le plus proche de vos attentes.