Experimental MT5 EA using Gemini Flash API - GeminiCommanderEA_v1
While everyone waits for me to finish testing V211... I created this simple EA for MT5 as I don't like grids for anyone to tweak. It took me less than 15 minutes. As much as I don't like the MT5 Strategy Tester I have attached the results. Tested on M15 XAUAUD {image} {image} {image} {file} {file}
Safer Grid Alternative EA v2.0: The Intelligent Grid Trading Solution
Pillar 2: Disciplined Position Sizing 
This pillar directly addresses the most dangerous aspect of grid trading: exponential risk.
Pillar 3: The Unbreakable Safety Nets 
This is the most critical pillar for survival, ensuring there is always a pre-defined exit plan for both winning and losing scenarios.
The AI Difference: How Gemini Manages Your Trades
This is what sets the AI Grid Commander apart. When enabled, the EA's core decisions are handed over to the Gemini API, transforming it from a reactive system to an intelligent agent.
Dynamic Grid Management: When a new grid trade is possible, the EA doesn't just check the RSI. It sends a full report to Gemini, including the current P/L, market volatility, indicator values, and any upcoming news. The AI then makes a strategic decision:
AI-Powered News Filter: The EA uses Gemini's Function Calling and Google Search capabilities to fetch a real-time calendar of high-impact economic events (like NFP or CPI) for the specific asset being traded. It will automatically halt all new trading activity before and after these events, protecting your trades from unpredictable volatility.
The AI Fallback System: We believe in safety above all else. If the AI is ever unavailable (due to an API outage, network error, or invalid key), the EA is designed to continue working seamlessly. It will automatically revert to its robust, built-in trend confirmation rules (Pillar 1) to make trading decisions. Your EA will never be left stranded.
Getting Started: Helpful Tips for New Users
Disclaimer: Trading foreign exchange, indices, and commodities carries a high level of risk and may not be suitable for all investors. The AI Grid Commander EA is a tool for educational and demonstration purposes. Past performance is not indicative of future results. Always use proper risk management and never risk more than you are willing to lose.
You can backtest this BUT...it will only use the default parameters. AI trade management only works in real-time.
{quote} UPDATED Safer Grid Alternative EA with Gemini Flash 2.0 API Trade Management and News Support Still works if you do not have a Google Gemini API KEY.
The Problem: Why the Old Logic Sometimes Failed
The original entry logic was too simple. It relied on a single indicator (a MACD crossover) to make its initial decision. While this works in very clear, strong trends, it has a key weakness: it's a lagging indicator.
This means it's good at telling you what the trend was a little while ago, but it can be slow to react to what's happening right now.
The old logic would see that the overall trend had been "up," and it would try to place a buy trade on a dip, failing to recognise that the momentum had already reversed and the price was actually starting a new downtrend.
The Solution: A Smarter, Two-Part Confirmation
I've replaced the old system with a much more robust Dual-Confirmation Logic. Before opening any new trade, the EA now asks two critical questions, and it needs a "yes" to both:
1. What is the main trend? (The 50 EMA Filter) First, the EA checks if the price is above or below the 50-period Exponential Moving Average, this tells it the direction of the general, underlying trend.
2. What is the immediate momentum? (The Advanced RSI Filter) This is the new, smarter part. After confirming the main trend, the EA analyses the RSI over the last 2 hours (on an M15 chart) to confirm the trade has real strength right now.
What This Means: The EA will no longer buy into a weakening trend. If the price is still above the EMA but the RSI has started falling, the second condition will fail, and the EA will correctly refuse to open a bad buy trade.
New Feature: The Dynamic Trend Exit
If the EA is in a buy grid and the market suddenly turns bearish, it should get out. The old version would have held on, hoping for a recovery.
The new version fixes this. On every new bar, the EA uses the same Dual-Confirmation logic to re-check the trend. If the EA is in a buy grid but the logic now confirms a SELL trend, it will automatically close all trades in the grid. This is a powerful new safety feature designed to cut losses early when the market has clearly reversed against an open position.
The Bottom Line:
These changes mean the EA is now far more intelligent. It is not just reacting to the past; it is analysing the present momentum and has the logic to protect itself when the trend fundamentally changes. This should lead to fewer incorrect entries and better management of risk.
//+------------------------------------------------------------------+
//| Safer_Grid_Alternative_EA.mq5 |
//| Copyright 2025, Your Name/Company |
//| https://www.your-website.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, For Educational Use Only."
#property link "https://www.google.com"
#property version "3.0"
#property description "A risk-managed grid EA based on the 'Safer Grid Alternative' plan."
#property description "Features trend confirmation for grid entries, adaptive ATR spacing,"
#property description "controlled lot sizing, and multiple basket-level safety exits."
#property description "!!!--- WARNING: THIS IS FOR EDUCATIONAL/DEMO USE. TEST THOROUGHLY BEFORE LIVE ---!!!"
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Arrays\List.mqh>
//--- Enums for cleaner settings
enum ENUM_LOT_SIZING_METHOD
{
LOT_METHOD_FIXED, // All trades use the initial lot size
LOT_METHOD_LINEAR // Each subsequent trade increases by Initial Lot (0.1, 0.2, 0.3...)
};
//===== GOOGLE GEMINI AI SETTINGS =====
input group "Google Gemini AI Commander"
input bool InpEnableAIGridManagement = true; // Let AI decide whether to add trades, hold, or close the basket
input bool InpEnableNewsFilter = true; // Use AI to fetch news and pause trading around events
input string InpGeminiApiKey = "GEMINI_API_KEY"; // IMPORTANT: Replace with your Google AI Studio API Key
input string InpPrimaryModel = "gemini-2.0-flash"; // Primary AI model to use
input string InpBackupModel = "gemini-1.5-flash"; // Backup AI model if primary fails
input int InpApiCooldownSeconds = 61; // Minimum seconds to wait between any two API calls
input int InpNewsAnalysisIntervalHours = 12; // How often to re-check for economic news
input int InpPauseMinutesBeforeNews = 90; // Pause new trades X minutes before High-Impact news
input int InpPauseMinutesAfterNews = 60; // Pause new trades X minutes after High-Impact news
//===== Pillar 1: Intelligent Entry & Grid Logic =====
input group "Grid Entry & Spacing"
input int InpMaxGridTrades = 3; // Max number of trades in a grid cycle
input double InpGridSpacingAtrMultiplier = 1.2; // Multiplier for ATR to determine grid spacing
input int InpAtrPeriod = 14; // Period for the ATR indicator
input int InpRsiPeriod = 14; // Period for RSI trend confirmation
input int InpConfEmaPeriod = 50; // Period for the confirmation Moving Average
//===== Pillar 2: Disciplined Position Sizing =====
input group "Position Sizing & Risk Caps"
input double InpInitialLotSize = 0.01; // Starting lot size for the first trade
input ENUM_LOT_SIZING_METHOD InpLotSizingMethod = LOT_METHOD_LINEAR; // Lot sizing for subsequent trades
input double InpMaxTotalLots = 0.5; // Absolute maximum total lots allowed open at once
//===== Pillar 3: The Safety Nets (Basket Exits) =====
input group "Basket Exit Rules"
input double InpMaxDrawdownPerCycle = 4.0; // Close basket if floating loss exceeds this % of account balance
input double InpBasketTpAtrMultiplier = 2.0; // Multiplier for ATR to set the basket Take Profit
input int InpMaxTradeDurationHours = 48; // Close basket if oldest trade is open for this many hours
//===== General & Safety Settings =====
input group "EA General Settings"
input long InpMagicNumber = 616162; // EA Magic Number
//--- Global Variables & Handles
CTrade trade;
CPositionInfo position;
//--- Indicator Handles
int h_atr, h_rsi, h_conf_ema;
//--- AI & News Filter Globals
#define NEWS_LOG_FILE "ai_grid_economic_events.json"
class EconomicEvent : public CObject
{
public:
string name;
datetime eventTime;
string impact; // "High", "Medium", "Low"
};
CList* g_upcomingEvents;
datetime g_lastNewsAnalysisTime = 0;
string g_imminentEventsForPrompt = "";
datetime g_lastApiCallTimestamp = 0;
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
h_atr = iATR(_Symbol, _Period, InpAtrPeriod);
h_rsi = iRSI(_Symbol, _Period, InpRsiPeriod, PRICE_CLOSE);
h_conf_ema = iMA(_Symbol, _Period, InpConfEmaPeriod, 0, MODE_EMA, PRICE_CLOSE);
if(h_atr==INVALID_HANDLE || h_rsi==INVALID_HANDLE || h_conf_ema==INVALID_HANDLE)
{
Print("Error initializing indicators. EA will not run.");
return(INIT_FAILED);
}
trade.SetExpertMagicNumber((int)InpMagicNumber);
trade.SetAsyncMode(true);
if(InpEnableAIGridManagement || InpEnableNewsFilter)
{
if(StringFind(InpGeminiApiKey, "YOUR_API_KEY") != -1 || StringLen(InpGeminiApiKey) < 10)
{
Print("CRITICAL ERROR: Gemini API Key is missing or invalid! AI features disabled.");
return(INIT_FAILED);
}
g_upcomingEvents = new CList();
ReadAndLoadEconomicEventsLog();
UpdateEconomicRiskProfile(true);
}
Print("AI Grid Commander EA Initialized. Version 5.14 (FINAL). Chart Period: ", EnumToString(_Period));
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
IndicatorRelease(h_atr);
IndicatorRelease(h_rsi);
IndicatorRelease(h_conf_ema);
if(CheckPointer(g_upcomingEvents) == POINTER_DYNAMIC)
{
delete g_upcomingEvents;
}
Print("EA Deinitialized. Reason code: ", reason);
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
static datetime lastBarTime = 0;
MqlRates rates[];
if(CopyRates(_Symbol, _Period, 0, 1, rates) < 1) return;
if(lastBarTime == rates[0].time)
return;
lastBarTime = rates[0].time;
UpdateEconomicRiskProfile(false);
if(GetEaPositionsTotal() > 0)
{
ManageBasketExits();
ManageOpenGridAgainstTrend(); // NEW: Check if trend has reversed against open positions
}
string halt_reason = "";
if(InpEnableNewsFilter && IsTradingHaltedByNews(halt_reason))
{
Print("NEWS FILTER: Trading halted. Reason: ", halt_reason);
return;
}
int totalEaPositions = GetEaPositionsTotal();
if(totalEaPositions == 0)
{
CheckForInitialTrade();
}
else if(totalEaPositions > 0 && totalEaPositions < InpMaxGridTrades)
{
ManageGridEntries(totalEaPositions);
}
}
//+------------------------------------------------------------------+
//| NEW: Close grid if trend reverses against open positions |
//+------------------------------------------------------------------+
void ManageOpenGridAgainstTrend()
{
ENUM_POSITION_TYPE gridDirection = GetBasketDirection();
if(gridDirection == WRONG_VALUE)
{
return; // No open grid to manage
}
ENUM_ORDER_TYPE orderDirection = PositionTypeToOrderType(gridDirection);
// If the trend is no longer valid for our open grid's direction, close it.
if(!IsTrendStillValid(orderDirection))
{
Print("EA SAFETY NET: Trend has reversed against the open ", (orderDirection == ORDER_TYPE_BUY ? "BUY" : "SELL"), " grid. Closing all positions.");
CloseAllTrades();
}
}
//+------------------------------------------------------------------+
//| Pillar 3: Manage Basket Exit Conditions (The Safety Nets) |
//+------------------------------------------------------------------+
void ManageBasketExits()
{
double floatingPnl = 0;
long oldestTradeTime = 0;
bool posFound = false;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol)
{
floatingPnl += position.Profit() + position.Swap();
if(oldestTradeTime == 0 || position.Time() < oldestTradeTime) oldestTradeTime = position.Time();
posFound = true;
}
}
if(!posFound) return;
double maxLossAmount = AccountInfoDouble(ACCOUNT_BALANCE) * (InpMaxDrawdownPerCycle / 100.0);
if(floatingPnl <= -maxLossAmount)
{
Print("EA SAFETY NET: Max Drawdown of ", InpMaxDrawdownPerCycle, "% reached. Closing all trades.");
CloseAllTrades();
return;
}
double basketTpPrice = GetBasketTakeProfitPrice();
if(basketTpPrice > 0)
{
ENUM_POSITION_TYPE basketDirection = GetBasketDirection();
double currentPrice = (basketDirection == POSITION_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
if((basketDirection == POSITION_TYPE_BUY && currentPrice >= basketTpPrice) || (basketDirection == POSITION_TYPE_SELL && currentPrice <= basketTpPrice))
{
Print("EA SAFETY NET: Basket Take Profit hit. Closing all trades.");
CloseAllTrades();
return;
}
}
if(InpMaxTradeDurationHours > 0 && (long)TimeCurrent() - oldestTradeTime >= InpMaxTradeDurationHours * 3600)
{
Print("EA SAFETY NET: Max trade duration of ", InpMaxTradeDurationHours, " hours exceeded. Closing all trades.");
CloseAllTrades();
}
}
//+------------------------------------------------------------------+
//| Pillar 1 & 2: Manage Grid Entry Conditions (WITH AI & FALLBACK) |
//+------------------------------------------------------------------+
void ManageGridEntries(int currentTradeCount)
{
ulong lastTicket = 0; double lastPrice = 0; long lastType = -1; long lastTime = 0;
for(int i = PositionsTotal() - 1; i >= 0; i--) {
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol && position.Time() > lastTime) {
lastTicket = position.Ticket(); lastPrice = position.PriceOpen(); lastType = position.PositionType(); lastTime = position.Time();
}
}
if(lastTicket == 0) return;
double atr_val_buf[];
if(CopyBuffer(h_atr, 0, 1, 1, atr_val_buf) < 1) return;
double gridSpacing = atr_val_buf[0] * InpGridSpacingAtrMultiplier;
double currentPrice = (lastType == POSITION_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
double distance = (lastType == POSITION_TYPE_BUY) ? lastPrice - currentPrice : currentPrice - lastPrice;
if(distance >= gridSpacing)
{
string ai_decision = "FALLBACK";
if(InpEnableAIGridManagement)
{
Print("Querying AI for strategic confirmation...");
string api_result = GetAIGridDecision();
if(api_result == "ADD_TRADE" || api_result == "CLOSE_ALL" || api_result == "HOLD_GRID")
{
ai_decision = api_result;
}
else
{
Print("AI returned HOLD or API failed. Reverting to internal EA logic.");
ai_decision = "FALLBACK";
}
}
else
{
Print("AI management is disabled. Using internal EA logic.");
ai_decision = "FALLBACK";
}
if(ai_decision == "ADD_TRADE")
{
Print("AI DECISION: ADD_TRADE");
double nextLotSize = CalculateNextLotSize(currentTradeCount);
if(GetTotalOpenLots() + nextLotSize > InpMaxTotalLots)
{
Print("Grid entry aborted by EA. Would exceed Max_Total_Lots.");
return;
}
if(nextLotSize > 0)
{
ExecuteTrade((ENUM_ORDER_TYPE)lastType, 0, 0, nextLotSize, "AI Approved Grid Entry");
}
}
else if (ai_decision == "FALLBACK")
{
Print("AI FALLBACK: Using internal RSI/EMA check...");
ENUM_ORDER_TYPE orderType = PositionTypeToOrderType((ENUM_POSITION_TYPE)lastType);
if(IsTrendStillValid(orderType))
{
Print(" - Fallback Logic: Trend confirmed.");
double nextLotSize = CalculateNextLotSize(currentTradeCount);
if(GetTotalOpenLots() + nextLotSize > InpMaxTotalLots)
{
Print("Grid entry aborted by EA. Would exceed Max_Total_Lots.");
return;
}
if(nextLotSize > 0)
{
ExecuteTrade(orderType, 0, 0, nextLotSize, "EA Fallback Grid Entry");
}
}
else
{
Print(" - Fallback Logic: Trend invalid, aborting grid entry.");
}
}
else if(ai_decision == "CLOSE_ALL")
{
Print("AI DECISION: CLOSE_ALL. Exiting entire grid based on AI risk assessment.");
CloseAllTrades();
}
else // This will catch HOLD_GRID
{
Print("AI DECISION: HOLD_GRID. No action taken.");
}
}
}
//+------------------------------------------------------------------+
//| Check For Initial Trade Signal |
//+------------------------------------------------------------------+
void CheckForInitialTrade()
{
if(GetEaPositionsTotal() > 0) return;
if(IsTrendStillValid(ORDER_TYPE_BUY))
{
Print("EA INTERNAL LOGIC: Dual-Confirmation BUY Signal detected.");
ExecuteTrade(ORDER_TYPE_BUY, 0, 0, InpInitialLotSize, "EA Internal Logic: Initial Entry");
}
else if(IsTrendStillValid(ORDER_TYPE_SELL))
{
Print("EA INTERNAL LOGIC: Dual-Confirmation SELL Signal detected.");
ExecuteTrade(ORDER_TYPE_SELL, 0, 0, InpInitialLotSize, "EA Internal Logic: Initial Entry");
}
}
//+------------------------------------------------------------------+
//| Executes a Trade |
//+------------------------------------------------------------------+
void ExecuteTrade(ENUM_ORDER_TYPE orderType, double sl, double tp, double lotSize, string comment)
{
if(lotSize <= 0) return;
double lotsMin = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
double lotsMax = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
double lotsStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
lotSize = floor(lotSize / lotsStep) * lotsStep;
lotSize = fmax(lotsMin, fmin(lotsMax, lotSize));
if(lotSize < lotsMin) return;
MqlTradeResult result;
if(orderType == ORDER_TYPE_BUY) trade.Buy(lotSize, _Symbol, 0, sl, tp, comment);
else if(orderType == ORDER_TYPE_SELL) trade.Sell(lotSize, _Symbol, 0, sl, tp, comment);
}
//+------------------------------------------------------------------+
//| AI AND NEWS MANAGEMENT FUNCTIONS (ROBUST) |
//+------------------------------------------------------------------+
bool IsApiReady()
{
if(TimeCurrent() - g_lastApiCallTimestamp >= (uint)InpApiCooldownSeconds)
{
return true;
}
return false;
}
string GetAIGridDecision()
{
if(!IsApiReady()) return "HOLD_GRID";
string prompt = ConstructGridAnalysisPrompt();
if(prompt == "")
{
Print("Failed to construct AI prompt.");
return "FALLBACK";
}
string json_payload = PrepareJsonPayload(prompt, false);
if(!IsValidJson(json_payload))
{
Print("CRITICAL ERROR: Invalid JSON payload constructed. Aborting API call.");
return "FALLBACK";
}
char result_data[];
string models_to_try[];
ArrayResize(models_to_try, 2);
models_to_try[0] = InpPrimaryModel;
models_to_try[1] = InpBackupModel;
for(int i = 0; i < ArraySize(models_to_try); i++)
{
if(models_to_try[i] == "") continue;
Print("Querying AI with model: ", models_to_try[i]);
int res_code = SendWebRequestToGemini(json_payload, result_data, models_to_try[i]);
g_lastApiCallTimestamp = TimeCurrent();
if(res_code == 200)
{
string response_text = CharArrayToString(result_data);
string extracted_json = ExtractJsonFromResponse(response_text);
if(StringLen(extracted_json) > 0)
{
return ParseAIDecision(extracted_json);
}
else
{
Print("AI_ERROR: Parser could not find valid JSON in the response. Raw: ", response_text);
}
}
if(i < ArraySize(models_to_try) - 1)
{
Print("API call to ", models_to_try[i], " failed. Attempting backup model...");
Sleep(1000);
}
}
return "FALLBACK";
}
string ConstructGridAnalysisPrompt()
{
string grid_state, market_data, prompt_text;
double totalLots=0, weightedSum=0, floatingPnl=0;
int tradeCount = 0;
ENUM_POSITION_TYPE direction = WRONG_VALUE;
for(int i = 0; i < PositionsTotal(); i++)
{
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol)
{
tradeCount++;
totalLots += position.Volume();
weightedSum += position.PriceOpen() * position.Volume();
floatingPnl += position.Profit() + position.Swap();
if(direction == WRONG_VALUE) direction = (ENUM_POSITION_TYPE)position.PositionType();
}
}
if(tradeCount == 0) return "";
double avgPrice = (totalLots > 0) ? weightedSum / totalLots : 0;
string dirStr = (direction == POSITION_TYPE_BUY) ? "BUY" : "SELL";
grid_state = StringFormat("A %s grid is active with %d trades. Avg entry: %.5f. Floating P/L: %s.",
dirStr, tradeCount, avgPrice, DoubleToString(floatingPnl,2));
double rsi_buf[], ema_buf[], atr_buf[];
CopyBuffer(h_rsi, 0, 1, 1, rsi_buf);
CopyBuffer(h_conf_ema, 0, 1, 1, ema_buf);
CopyBuffer(h_atr, 0, 1, 1, atr_buf);
market_data = StringFormat("Market Snapshot: RSI(14)=%.2f, EMA(50)=%.5f, ATR(14)=%.5f.", rsi_buf[0], ema_buf[0], atr_buf[0]);
prompt_text = StringFormat(
"## Role: Grid Trading Risk Manager\n"
"## Context: The condition to add another trade to an existing grid has been met. Your task is to analyze the complete situation and decide if adding the trade is prudent.\n"
"## Current Grid State: %s\n## %s\n## Imminent High-Impact News:\n%s\n"
"## Analysis Task: Given the current grid exposure, market readings, and upcoming news, what is the best strategic action? A simple indicator check is not enough; assess the holistic risk.\n"
"## Your Decision (MUST be one of these three options):\n"
"1. ADD_TRADE: The trend looks solid, the pullback is healthy, and risks are acceptable. Proceed.\n"
"2. HOLD_GRID: The situation is uncertain. The trend may be weakening or news risk is too high. Do not add more exposure now.\n"
"3. CLOSE_ALL: The risk profile has become unfavorable. The trend has likely failed. It is better to exit the entire basket now to prevent further losses.\n"
"## Output Format: Respond ONLY with a single, valid JSON object, like: {\"decision\": \"ADD_TRADE\"}",
grid_state, market_data, g_imminentEventsForPrompt
);
return prompt_text;
}
int SendWebRequestToGemini(const string &json_payload, char &result_data[], string model_name)
{
string url = "https://generativelanguage.googleapis.com/v1beta/models/" + model_name + ":generateContent?key=" + InpGeminiApiKey;
uchar post_data[];
int array_size = StringToCharArray(json_payload, post_data, 0, WHOLE_ARRAY, CP_UTF8);
if(array_size > 0 && post_data[array_size - 1] == 0)
{
ArrayResize(post_data, array_size - 1);
}
string headers = "Content-Type: application/json\r\n";
headers += "Accept: application/json\r\n";
int timeout = 180000;
string result_headers;
int retry_delays[] = {5, 15, 30};
int attempts = ArraySize(retry_delays) + 1;
for(int i = 0; i < attempts; i++)
{
if(i > 0)
{
PrintFormat("Retrying Gemini API call in %d seconds... (Attempt %d/%d)", retry_delays[i-1], i + 1, attempts);
Sleep(retry_delays[i-1] * 1000);
}
ResetLastError();
int res_code = WebRequest("POST", url, headers, timeout, post_data, result_data, result_headers);
if(res_code == 200) return res_code;
if(res_code >= 400 && res_code < 500)
{
PrintFormat("GEMINI API CLIENT ERROR: HTTP Status Code: %d. No retries will be attempted.", res_code);
string response_text = CharArrayToString(result_data);
PrintFormat("GEMINI API ERROR Response: %s", response_text);
return res_code;
}
PrintFormat("GEMINI API TEMPORARY ERROR: HTTP Status Code: %d. MQL5 Error: %d.", res_code, GetLastError());
if(i == attempts - 1) return res_code;
}
return -1;
}
string PrepareJsonPayload(string &prompt_text, bool use_grounded_search)
{
string escaped_prompt = EscapeJsonString(prompt_text);
string payload = "{";
payload += "\"contents\":[{\"parts\":[{\"text\":\"" + escaped_prompt + "\"}]}]";
if(use_grounded_search)
{
payload += ",\"tools\":[{\"function_declarations\":[{\"name\":\"search_web\",\"description\":\"Performs a Google search to find real-time information or economic events.\",\"parameters\":{\"type\":\"OBJECT\",\"properties\":{\"query\":{\"type\":\"STRING\"}}}}]}]";
payload += ",\"tool_config\":{\"function_calling_config\":{\"mode\":\"ANY\"}}";
}
payload += ",\"generationConfig\":{";
payload += "\"temperature\":0.2,";
payload += "\"maxOutputTokens\":8192";
payload += "}";
payload += "}";
Print("DEBUG: JSON Payload: ", payload);
return payload;
}
string ParseAIDecision(const string &json_response)
{
string key = "\"decision\":\"";
int key_pos = StringFind(json_response, key);
if(key_pos < 0) return "HOLD_GRID";
int start_pos = key_pos + StringLen(key);
int end_pos = StringFind(json_response, "\"", start_pos);
if(end_pos < 0) return "HOLD_GRID";
string decision = StringSubstr(json_response, start_pos, end_pos - start_pos);
if(decision == "ADD_TRADE" || decision == "HOLD_GRID" || decision == "CLOSE_ALL")
{
return decision;
}
return "HOLD_GRID";
}
void UpdateEconomicRiskProfile(bool force_update=false)
{
if(!InpEnableNewsFilter) return;
if(force_update || (long)TimeCurrent() - (long)g_lastNewsAnalysisTime >= InpNewsAnalysisIntervalHours * 3600)
{
if(!IsApiReady()) return;
Print("NewsRiskMgmt: Triggering economic event analysis for asset: ", _Symbol);
string prompt = ConstructNewsAnalysisPrompt(5);
string json_payload = PrepareJsonPayload(prompt, true);
if(!IsValidJson(json_payload))
{
Print("CRITICAL ERROR: Invalid JSON payload constructed for news request. Aborting.");
return;
}
char result_data[];
string models_to_try[];
ArrayResize(models_to_try, 2);
models_to_try[0] = InpPrimaryModel;
models_to_try[1] = InpBackupModel;
for(int i = 0; i < ArraySize(models_to_try); i++)
{
if(models_to_try[i] == "") continue;
int res_code = SendWebRequestToGemini(json_payload, result_data, models_to_try[i]);
g_lastApiCallTimestamp = TimeCurrent();
if(res_code == 200)
{
string response_str = CharArrayToString(result_data);
string extracted_json = ExtractJsonFromResponse(response_str);
if(StringLen(extracted_json) > 0)
{
ParseAndLogEconomicEvents(extracted_json);
g_lastNewsAnalysisTime = TimeCurrent();
return;
}
else
{
Print("NewsRiskMgmt ERROR: Could not parse JSON from news API response.");
}
}
if(i < ArraySize(models_to_try) - 1)
{
Print("News API call to ", models_to_try[i], " failed. Attempting backup model...");
Sleep(1000);
}
}
}
}
string ConstructNewsAnalysisPrompt(int days_to_fetch)
{
string prompt_text = StringFormat(
"## Role: Financial Event Analyst\n"
"## Task: Using your search tool, identify all significant economic calendar events that directly impact the asset '%s' scheduled for the next %d days. "
"Focus on events universally considered High or Medium impact. "
"For forex pairs like EURUSD, find events for both EUR and USD. For indices like US30, find major US economic events. For commodities like XAUUSD, find major global economic events, especially from the US.\n"
"## Required Fields:\n"
"- Event name (e.g., 'US Non-Farm Payrolls')\n"
"- Exact UTC time (format:บาย-MM-DD HH:MM)\n"
"- Impact level ('High' or 'Medium')\n"
"## Output Format: Return ONLY a strict JSON array of objects. Do not include any other text.\n"
"## Example Output Format:\n"
"[{\"name\":\"U.S. CPI (MoM)\", \"event_time\":\"2025-07-15 12:30\", \"impact\":\"High\"}]",
_Symbol, days_to_fetch
);
return prompt_text;
}
void ParseAndLogEconomicEvents(const string& jsonResponse)
{
if(CheckPointer(g_upcomingEvents) != POINTER_DYNAMIC) return;
g_upcomingEvents.Clear();
int file_handle = FileOpen(NEWS_LOG_FILE, FILE_WRITE | FILE_TXT | FILE_ANSI);
if(file_handle != INVALID_HANDLE) {
FileWriteString(file_handle, jsonResponse);
FileClose(file_handle);
}
int current_pos = 0;
while(true) {
int obj_start = StringFind(jsonResponse, "{", current_pos);
if(obj_start < 0) break;
int obj_end = StringFind(jsonResponse, "}", obj_start);
if(obj_end < 0) break;
string event_obj_str = StringSubstr(jsonResponse, obj_start, obj_end - obj_start + 1);
string eventName, eventTimeStr, eventImpact;
if(JsonGetString(event_obj_str, "name", eventName) &&
JsonGetString(event_obj_str, "event_time", eventTimeStr) &&
JsonGetString(event_obj_str, "impact", eventImpact))
{
EconomicEvent* new_event = new EconomicEvent();
new_event.name = eventName;
new_event.impact = eventImpact;
new_event.eventTime = StringToTime(eventTimeStr);
if(new_event.eventTime > TimeCurrent()) {
g_upcomingEvents.Add(new_event);
} else { delete new_event; }
}
current_pos = obj_end + 1;
}
Print("NewsRiskMgmt: Loaded ", g_upcomingEvents.Total(), " upcoming events.");
UpdateImminentEventsForPrompt();
}
void ReadAndLoadEconomicEventsLog(void)
{
int file_handle = FileOpen(NEWS_LOG_FILE, FILE_READ | FILE_TXT | FILE_ANSI);
if(file_handle == INVALID_HANDLE) return;
string file_content = "";
while(!FileIsEnding(file_handle)) file_content += FileReadString(file_handle);
FileClose(file_handle);
if(StringLen(file_content) > 10) ParseAndLogEconomicEvents(file_content);
}
void UpdateImminentEventsForPrompt(void)
{
if(CheckPointer(g_upcomingEvents) != POINTER_DYNAMIC) { g_imminentEventsForPrompt = "None"; return; }
string event_context = "";
int imminent_count = 0;
for(int i = 0; i < g_upcomingEvents.Total(); i++) {
EconomicEvent* event = g_upcomingEvents.GetNodeAtIndex(i);
if(CheckPointer(event) == POINTER_DYNAMIC && StringFind(event.impact, "High") > -1)
{
long minutes_until = (long)(event.eventTime - TimeCurrent()) / 60;
if(minutes_until > 0 && minutes_until < 24 * 60)
{
event_context += StringFormat("* %s in ~%d mins. ", event.name, minutes_until);
imminent_count++;
}
}
}
g_imminentEventsForPrompt = (imminent_count == 0) ? "None identified." : event_context;
}
bool IsTradingHaltedByNews(string &reason)
{
if(CheckPointer(g_upcomingEvents) != POINTER_DYNAMIC) return false;
datetime now = TimeCurrent();
for(int i = 0; i < g_upcomingEvents.Total(); i++) {
EconomicEvent* event = g_upcomingEvents.GetNodeAtIndex(i);
if(CheckPointer(event) != POINTER_DYNAMIC || StringFind(event.impact, "High") < 0) continue;
long time_until = (long)event.eventTime - (long)now;
long time_since = (long)now - (long)event.eventTime;
if(time_until > 0 && time_until <= InpPauseMinutesBeforeNews * 60) {
reason = StringFormat("Approaching '%s'", event.name); return true;
}
if(time_since > 0 && time_since <= InpPauseMinutesAfterNews * 60) {
reason = StringFormat("Post-event volatility for '%s'", event.name); return true;
}
}
return false;
}
string ExtractJsonFromResponse(const string &raw_response)
{
string clean_response = raw_response;
StringReplace(clean_response, "\0", "");
int start_pos = StringFind(clean_response, "```json");
if(start_pos >= 0)
{
start_pos += 7;
int end_pos = StringFind(clean_response, "```", start_pos);
if(end_pos > start_pos)
{
string json_str = StringSubstr(clean_response, start_pos, end_pos - start_pos);
StringTrimLeft(json_str);
StringTrimRight(json_str);
if(IsValidJson(json_str))
{
return json_str;
}
}
}
start_pos = StringFind(clean_response, "{");
if(start_pos >= 0)
{
int end_pos = FindLast(clean_response, "}");
if(end_pos > start_pos)
{
string json_str = StringSubstr(clean_response, start_pos, end_pos - start_pos + 1);
if(IsValidJson(json_str))
return json_str;
}
}
return "";
}
int FindLast(const string &str, const string &substr)
{
int pos = -1, last = -1;
while((pos = StringFind(str, substr, last + 1)) != -1)
last = pos;
return last;
}
bool JsonGetString(const string &json_str, const string &key, string &value_out)
{
string search_key = "\"" + key + "\":\"";
int key_pos = StringFind(json_str, search_key);
if(key_pos < 0) return false;
int value_start_pos = key_pos + StringLen(search_key);
int quote2_pos = StringFind(json_str, "\"", value_start_pos);
if(quote2_pos < 0) return false;
value_out = StringSubstr(json_str, value_start_pos, quote2_pos - value_start_pos);
StringTrimLeft(value_out);
StringTrimRight(value_out);
return true;
}
string EscapeJsonString(const string text)
{
string result = text;
StringReplace(result, "\\", "\\\\");
StringReplace(result, "\"", "\\\"");
StringReplace(result, "\f", "\\f");
StringReplace(result, "\n", "\\n");
StringReplace(result, "\r", "\\r");
StringReplace(result, "\t", "\\t");
StringReplace(result, "\0", "");
return result;
}
bool IsValidJson(const string &json_str)
{
int open_braces = 0;
int close_braces = 0;
int quote_count = 0;
bool in_escape = false;
for(int i = 0; i < StringLen(json_str); i++)
{
ushort ch = StringGetCharacter(json_str, i);
if(in_escape)
{
in_escape = false;
continue;
}
if(ch == '\\') {
in_escape = true;
continue;
}
if(ch == '"') {
quote_count++;
}
if(ch == '{') open_braces++;
if(ch == '}') close_braces++;
}
return (open_braces > 0 && open_braces == close_braces && quote_count % 2 == 0);
}
bool IsTrendStillValid(ENUM_ORDER_TYPE direction)
{
int rsi_lookback_period = 8;
double rsi_buf[];
double ema_buf[];
ArrayResize(rsi_buf, 9);
ArrayResize(ema_buf, 1);
if(CopyBuffer(h_rsi, 0, 1, 9, rsi_buf) < 9 || CopyBuffer(h_conf_ema, 0, 1, 1, ema_buf) < 1)
{
Print("Failed to copy buffers for advanced trend check.");
return false;
}
ArraySetAsSeries(rsi_buf, true);
if(direction == ORDER_TYPE_BUY)
{
double askPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
bool isPriceAboveEma = (askPrice > ema_buf[0]);
bool isRsiInBuyZone = (rsi_buf[0] > 50 && rsi_buf[0] < 70);
bool isRsiTrendingUp = (rsi_buf[0] > rsi_buf[rsi_lookback_period]);
return (isPriceAboveEma && isRsiInBuyZone && isRsiTrendingUp);
}
else if(direction == ORDER_TYPE_SELL)
{
double bidPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID);
bool isPriceBelowEma = (bidPrice < ema_buf[0]);
bool isRsiInSellZone = (rsi_buf[0] < 50 && rsi_buf[0] > 30);
bool isRsiTrendingDown = (rsi_buf[0] < rsi_buf[rsi_lookback_period]);
return (isPriceBelowEma && isRsiInSellZone && isRsiTrendingDown);
}
return false;
}
ENUM_ORDER_TYPE PositionTypeToOrderType(ENUM_POSITION_TYPE posType)
{
if(posType == POSITION_TYPE_BUY)
return ORDER_TYPE_BUY;
else if(posType == POSITION_TYPE_SELL)
return ORDER_TYPE_SELL;
return WRONG_VALUE;
}
double CalculateNextLotSize(int currentTradeCount) {
if(InpLotSizingMethod == LOT_METHOD_FIXED) return InpInitialLotSize;
else if(InpLotSizingMethod == LOT_METHOD_LINEAR) return InpInitialLotSize * (currentTradeCount + 1);
return 0;
}
void CloseAllTrades() {
for(int i = PositionsTotal() - 1; i >= 0; i--) {
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol) {
trade.PositionClose(position.Ticket());
}
}
}
int GetEaPositionsTotal() {
int count = 0;
for(int i = 0; i < PositionsTotal(); i++) {
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol) count++;
}
return count;
}
double GetTotalOpenLots() {
double totalLots = 0;
for(int i = 0; i < PositionsTotal(); i++) {
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol) {
totalLots += position.Volume();
}
}
return totalLots;
}
ENUM_POSITION_TYPE GetBasketDirection() {
for(int i = 0; i < PositionsTotal(); i++) {
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol) {
return (ENUM_POSITION_TYPE)position.PositionType();
}
}
return WRONG_VALUE;
}
double GetBasketTakeProfitPrice() {
double totalLots = 0, weightedSum = 0;
ENUM_POSITION_TYPE direction = WRONG_VALUE;
for(int i = 0; i < PositionsTotal(); i++) {
if(position.SelectByIndex(i) && position.Magic() == InpMagicNumber && position.Symbol() == _Symbol) {
totalLots += position.Volume();
weightedSum += position.PriceOpen() * position.Volume();
if(direction == WRONG_VALUE) direction = (ENUM_POSITION_TYPE)position.PositionType();
}
}
if(totalLots == 0) return 0;
double averageOpenPrice = weightedSum / totalLots;
double atr_val_buf[];
if(CopyBuffer(h_atr, 0, 1, 1, atr_val_buf) < 1) return 0;
double takeProfitPips = atr_val_buf[0] * InpBasketTpAtrMultiplier;
if(direction == POSITION_TYPE_BUY) return averageOpenPrice + takeProfitPips;
else if(direction == POSITION_TYPE_SELL) return averageOpenPrice - takeProfitPips;
return 0;
}
//+------------------------------------------------------------------+
// Safer_Grid_Alternative_EA.mq5 {quote} V211 Streamlined (AxiomEdge) AxiomEdge_PRO_V211_STREAMLINED.py.txt See edited update below So I've changed the name (obviously) as I am thinking longer term in a commercial sense for the framework. This version is a 'slimmer' framework I am still working on the 'full' version however it does provide an idea of what V211 will be like. It is a version someone will need to just let it complete a full run to see how the framework and AI manage the dynamic development of a strategy. My only suggestion would be not to touch the feature engineering...
Why this matters:
This approach introduces a second dimension to momentum analysis: how stable that momentum is.
3. Practical Implementation
To make this concept actionable:
4. Use Case Scenarios for RSI and RSI + MSE Adaptation
Combining with Traditional RSI:
Use this hybrid signal in a layered confirmation strategy. For example:
5. Real-World Adaptation and Engineering Considerations
This indicator can be implemented in any feature engineering pipeline, particularly useful in quantitative models or machine learning frameworks for trading.
Example integration plan:
def _calculate_rsi_mse(df, period=14, sma_period=5, mse_window=14):
rsi = ta.momentum.RSIIndicator(df['close'], window=period).rsi()
rsi_ma = rsi.rolling(sma_period).mean()
mse_rsi = ((rsi - rsi_ma) ** 2).rolling(mse_window).mean()
df['rsi'] = rsi
df['rsi_mse'] = mse_rsi
return df Quantifies Stability of Momentum: Adds a new dimension not captured by RSI alone. Great for Regime Detection: Helps define “stable trend” vs “choppy market” conditions. Potential Leading Indicator: Spikes in MSE might precede market shifts.Limitations:
Experimental: This is not a mainstream technique and requires thorough validation. Asset-Specific Tuning: MSE levels vary by volatility, so normalization is critical.Conclusion
Incorporating MSE into RSI analysis offers a novel way to quantify the consistency of market momentum—not just its level. This “RSI MSE” metric can act as a stability filter, trend confidence gauge, or even a leading signal of regime shifts.
It is a promising tool, especially for algorithmic strategies or feature-rich ML models, and aligns well with modern quantitative analysis goals: not just detecting signals, but understanding their reliability.
