MQL5 + ChatGPT/DeepSeek : créer son EA MT5 avec l’IA en 2026

L’intelligence artificielle générative transforme la manière dont les traders algorithmiques conçoivent leurs robots de trading. En 2026, utiliser ChatGPT, Claude ou DeepSeek pour générer du code MQL5 n’est plus un luxe réservé aux développeurs expérimentés. Ce tutoriel vous propose un workflow concret, de la définition de la stratégie en français jusqu’au test dans le Strategy Tester de MetaTrader 5, en passant par la génération et la correction du code. Vous découvrirez également les limites de l’IA et les bonnes pratiques pour en tirer le meilleur parti.

1. Pourquoi utiliser l’IA pour coder un EA MT5 ?

Le langage MQL5 est puissant mais sa courbe d’apprentissage peut freiner les traders qui souhaitent automatiser une stratégie sans maîtriser la programmation orientée objet. Les modèles de langage comme ChatGPT, Claude ou DeepSeek permettent de traduire une idée de trading en code fonctionnel en quelques minutes. L’IA excelle dans la génération de squelettes d’EA, la gestion des ordres, l’implémentation d’indicateurs techniques et la structuration des fichiers. Elle ne remplace pas un développeur chevronné, mais elle accélère considérablement le prototypage.

2. Workflow concret : du français au code MQL5

À lire aussi : notre tutoriel pour copier des signaux Telegram en MQL5

À lire aussi : notre comparatif des 8 meilleurs EA MT5 payants 2026

2.1 Définir la stratégie en français

Avant toute chose, formalisez votre stratégie en langage clair. Par exemple : « Je veux un EA qui ouvre une position longue lorsque le prix dépasse le plus haut des 20 dernières bougies (breakout haussier) et une position courte lorsqu’il casse le plus bas des 20 dernières bougies (breakout baissier). Le take profit est fixé à 2 fois le risque, le stop loss à 1 fois l’ATR(14). La gestion des positions se fait en mode hedge. »

2.2 Rédiger un prompt structuré

Un bon prompt doit contenir : le type de EA (hedge ou netting), les indicateurs utilisés, les règles d’entrée et de sortie, la gestion du risque, les paramètres modifiables (externes), et le format de sortie attendu (fichier .mq5 complet). Exemple de prompt :

« Génère un Expert Advisor MQL5 pour MetaTrader 5 en mode hedge. Stratégie : breakout des 20 dernières bougies. Entrée longue si Close[1] > high[highest(20)] ; entrée short si Close[1] < low[lowest(20)]. Stop loss : ATR(14) * 1.5. Take profit : ATR(14) * 3. Utilise un trailing stop basé sur l’ATR. Paramètres externes : période breakout, multiplicateur ATR pour SL/TP. Ajoute des commentaires en français. »

2.3 Générer le code MQL5

Copiez le prompt dans l’interface de ChatGPT, Claude ou DeepSeek. Le modèle vous retournera un fichier .mq5 complet. Vérifiez la syntaxe de base (points-virgules, accolades).

2.4 Corriger et tester

Importez le code dans MetaEditor (F4 dans MT5). Compilez (F7). Corrigez les erreurs signalées. Lancez un test dans le Strategy Tester (Ctrl+R). Ajustez les paramètres et itérez.

3. Exemple complet : EA Breakout simple

Voici un exemple de code généré par DeepSeek pour la stratégie décrite plus haut. Ce code est fonctionnel après une légère correction sur la gestion des ordres en mode hedge.

//+------------------------------------------------------------------+
//|                                                  BreakoutEA.mq5 |
//|                                    Generated by AI - MQL Experts |
//+------------------------------------------------------------------+
#property copyright "MQL Experts"
#property version   "1.00"
#property description "EA Breakout sur plus haut/plus bas des 20 bougies"

input int      BreakoutPeriod = 20;          // Période de breakout
input double   ATRMultiplierSL = 1.5;        // Multiplicateur ATR pour SL
input double   ATRMultiplierTP = 3.0;        // Multiplicateur ATR pour TP
input int      ATRPeriod = 14;               // Période ATR
input double   LotSize = 0.1;                // Taille du lot

int handleATR;
double atrValue;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   handleATR = iATR(_Symbol, _Period, ATRPeriod);
   if(handleATR == INVALID_HANDLE)
     {
      Print("Erreur création handle ATR");
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(Bars(_Symbol, _Period) < BreakoutPeriod + 1) return;

   double highArray[];
   double lowArray[];
   ArraySetAsSeries(highArray, true);
   ArraySetAsSeries(lowArray, true);
   CopyHigh(_Symbol, _Period, 1, BreakoutPeriod, highArray);
   CopyLow(_Symbol, _Period, 1, BreakoutPeriod, lowArray);

   double highestHigh = highArray[ArrayMaximum(highArray)];
   double lowestLow = lowArray[ArrayMinimum(lowArray)];

   double close = iClose(_Symbol, _Period, 1);

   if(close > highestHigh)
     {
      // Signal long
      if(CountPositionsByType(POSITION_TYPE_BUY) == 0)
        {
         atrValue = GetATR();
         double sl = close - atrValue * ATRMultiplierSL;
         double tp = close + atrValue * ATRMultiplierTP;
         OpenOrder(ORDER_TYPE_BUY, sl, tp);
        }
     }
   else if(close < lowestLow)
     {
      // Signal short
      if(CountPositionsByType(POSITION_TYPE_SELL) == 0)
        {
         atrValue = GetATR();
         double sl = close + atrValue * ATRMultiplierSL;
         double tp = close - atrValue * ATRMultiplierTP;
         OpenOrder(ORDER_TYPE_SELL, sl, tp);
        }
     }
  }

//+------------------------------------------------------------------+
//| Fonctions auxiliaires                                            |
//+------------------------------------------------------------------+
double GetATR()
  {
   double atrBuffer[];
   ArraySetAsSeries(atrBuffer, true);
   CopyBuffer(handleATR, 0, 0, 1, atrBuffer);
   return atrBuffer[0];
  }

int CountPositionsByType(ENUM_POSITION_TYPE type)
  {
   int count = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(PositionSelectByTicket(PositionGetTicket(i)))
        {
         if(PositionGetInteger(POSITION_TYPE) == type)
           count++;
        }
     }
   return count;
  }

void OpenOrder(ENUM_ORDER_TYPE type, double sl, double tp)
  {
   MqlTradeRequest request = {};
   MqlTradeResult result = {};
   request.action = TRADE_ACTION_DEAL;
   request.symbol = _Symbol;
   request.volume = LotSize;
   request.type = type;
   request.price = (type == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   request.sl = sl;
   request.tp = tp;
   request.deviation = 10;
   request.magic = 123456;
   OrderSend(request, result);
   if(result.retcode != TRADE_RETCODE_DONE)
      Print("Erreur ouverture ordre : ", result.retcode);
  }
//+------------------------------------------------------------------+

Ce code compile sans erreur sous MetaEditor. Il ouvre une position longue ou courte selon le breakout, avec un stop loss et take profit basés sur l’ATR. La fonction CountPositionsByType assure qu’une seule position par direction est ouverte (mode hedge).

4. Limites de l’IA dans la génération de code MQL5

Limite	Description	Solution
Erreurs de syntaxe	L’IA peut oublier des points-virgules, mal fermer des accolades ou utiliser des fonctions inexistantes.	Compilation systématique dans MetaEditor.
Logique incomplète	La gestion des ordres en mode netting vs hedge est souvent mal implémentée.	Préciser le mode dans le prompt et vérifier la logique.
Optimisation absente	L’IA ne fournit pas de code optimisé pour la vitesse d’exécution (ex : tableaux statiques).	Réécrire les parties critiques manuellement.
Tests insuffisants	Le code généré peut fonctionner sur des données historiques mais échouer en forward test.	Toujours tester sur plusieurs périodes et instruments.
Manque de robustesse	Gestion des erreurs (connexion, requêtes) souvent absente.	Ajouter des blocs try-catch et des vérifications de retour.

5. Bonnes pratiques pour coder un EA avec l’IA

• Diviser le prompt en sous-parties : demandez d’abord la structure de l’EA, puis les indicateurs, puis la gestion des ordres.
• Utiliser des noms de variables explicites : l’IA respecte généralement les noms que vous suggérez.
• Demander des commentaires en français : facilite la relecture et la correction.
• Ne jamais copier-coller sans vérification : chaque ligne doit être comprise avant d’être testée.
• Versionner votre code : utilisez Git ou sauvegardez les versions successives.

6. Outils complémentaires pour le développement d’EA

MetaEditor reste l’IDE incontournable pour compiler et déboguer. Le Strategy Tester permet de backtester sur des données ticks réelles. Pour aller plus loin, des bibliothèques comme Trade (incluse dans MQL5) ou CTrade simplifient la gestion des ordres. Enfin, des plateformes comme MQL5 Code Base offrent des exemples de code que vous pouvez intégrer à vos prompts.

7. Conclusion

L’association de l’IA générative et de MQL5 ouvre des perspectives passionnantes pour les traders algorithmiques. En suivant un workflow structuré – définition de la stratégie, prompt précis, génération, correction et test – vous pouvez créer un EA fonctionnel en quelques heures. Gardez à l’esprit que l’IA est un assistant, pas un remplacement : la compréhension du code, le debugging et l’optimisation restent de votre ressort. En 2026, maîtriser ces outils vous donne un avantage compétitif certain.

FAQ