HybridMicrostructure EA - sistema esperto per MetaTrader 5

Questo EA è progettato per inviare richieste HTTP POST con un payload JSON in stile OpenAI (contenente `messages`, `role: system` e `role: user`) e si aspetta una risposta JSON contenente `decision`, `confidence` e `reason`.

Per creare un’API di IA locale (server locale) in grado di rispondere a queste richieste MT5 in pochi millisecondi, il linguaggio di programmazione ideale è Python utilizzando il framework FastAPI. FastAPI è leggero, velocissimo e perfettamente adatto all’elaborazione di dati ad alta frequenza provenienti da MT5.

Di seguito è riportato il codice completo del server Python. In seguito potrai integrare in questo motore un vero e proprio modello di Machine Learning (come TensorFlow, Scikit-Learn o persino Ollama per un LLM locale).

1. Configurazione dell’ambiente Python

Assicurati che Python sia installato sul tuo computer. Apri il Terminale o il Prompt dei comandi e installa queste due librerie essenziali:

pip install fastapi uvicorn

2. Codice API Python (local_ai_bridge.py)

Crea un file denominato local_ai_bridge.py sul tuo computer e copia il seguente codice: (Python)

from fastapi import FastAPI, Request
from pydantic import BaseModel
from typing import List, Optional
import json
import uvicorn

app = FastAPI(title="MT5 AI Microstructure Bridge")

# --- MODELLI DI DATI (Compatibili con il formato dati MQL5) ---
class Message(BaseModel):
    role: str
    content: str

class AIRequest(BaseModel):
    model: str
    temperature: float
    response_format: Optional[dict] = None
    messages: List[Message]

# --- ENDPOINT PRINCIPALE (/analyze) ---
@app.post("/analyze")
async def analyze_market(payload: AIRequest):
    """
    This endpoint receives tick and microstructure data from MT5,
    analyzes the data, and returns a BUY/SELL/WAIT decision.
    """
    
    # 1. Estrarre i dati JSON dal messaggio "user" inviato da MT5
    user_content = "{}"
    for msg in payload.messages:
        if msg.role == "user":
            user_content = msg.content
            break
            
    try:
        facts = json.loads(user_content)
    except json.JSONDecodeError:
        return {"decision": "WAIT", "confidence": 0.0, "reason": "Invalid JSON format"}

    # 2. Analisi dei dati di mercato
    order_type = facts.get("order_type", "WAIT")
    high_velocity = facts.get("high_velocity", False)
    snapback_pips = facts.get("snapback_pips", 0.0)
    min_snapback = facts.get("min_snapback_pips", 2.0)
    deviation_z = facts.get("deviation_z", 0.0)
    
    mtf = facts.get("mtf", {})
    m1_structure = facts.get("m1_structure", {})

    # 3. IA / ALGORITMO DECISIONALE (Può essere sostituito in seguito con un modello di apprendimento automatico)
    # Questo è un semplice esempio di logica decisionale
    
    confidence = 0.0
    decision = "WAIT"
    reason = ""

    # Valutare la logica quando l'EA richiede la conferma di VENDITA
    if order_type == "SELL":
        score = 0
        
        # Verifica dello snapback e della velocità
        if snapback_pips >= min_snapback and high_velocity:
            score += 0.4

        # Verifica la deviazione estrema (condizione di ipercomprato)
        if deviation_z > 2.0:
            score += 0.3

        # Verifica l'allineamento MTF (almeno H1 o M15 devono essere ribassisti)
        if mtf.get("h1_down") or mtf.get("m15_down"):
            score += 0.2

        # Verifica del rifiuto dell'M1 (coda superiore lunga)
        if m1_structure.get("upper_wick_ratio", 0.0) >= 0.2:
            score += 0.1

        confidence = score
        if confidence >= 0.70:
            decision = "SELL"
            reason = "High velocity drop, MTF align, Z-Score high"
        else:
            reason = f"Score only {confidence:.2 f}, lacking momentum"

    # Valutare la logica quando l'EA richiede la conferma di ACQUISTO
    elif order_type == "BUY":
        score = 0
        
        # Verifica dello snapback e della velocità
        if snapback_pips >= min_snapback and high_velocity:
            score += 0.4

        # Verifica della deviazione estrema (la variabile `deviation_z` è già corretta in base alla direzione in MQL5)
        if deviation_z > 2.0:
            score += 0.3

        # Verifica l'allineamento MTF (almeno H1 o M15 devono essere rialzisti)
        if mtf.get("h1_up") or mtf.get("m15_up"):
            score += 0.2

        # Verifica del rifiuto dell'M1 (coda inferiore lunga)
        if m1_structure.get("lower_wick_ratio", 0.0) >= 0.2:
            score += 0.1

        confidence = score
        if confidence >= 0.70:
            decision = "BUY"
            reason = "High velocity bounce, MTF align, Z-Score high"
        else:
            reason = f"Score only {confidence:.2 f}, lacking momentum"

    # 4. Invia la risposta JSON a MT5
    return {
        "decision": decision,
        "confidence": round(confidence, 2),
        "reason": reason[:60]  # Limitare la motivazione a un massimo di 60 caratteri per MT5
    }

if __name__ == "__main__":
    # Avvia il server locale sulla porta 8787, in corrispondenza del parametro InpAIEndpoint in MQL5
    print("AI Bridge Server is running on http://127.0.0.1:8787")
    uvicorn.run(app, host="127.0.0.1", port=8787)

3. Come eseguire il server e connettersi a MT5

1. Apri il Terminale e accedi alla cartella in cui è salvato il file Python.
2. Esegui il comando:
3. Il server si avvierà e resterà in ascolto all'indirizzo [http://127.0.0.1:8787](http://127.0.0.1:8787).
4. Sulla piattaforma MetaTrader 5, assicurati di aver aggiunto l’URL [http://127.0.0.1](http://127.0.0.1) all’elenco degli URL WebRequest consentiti:
1. Vai su Strumenti -> Opzioni -> Expert Advisor.
2. Selezionare "Consenti WebRequest per gli URL elencati".
3. Aggiungi l’URL [http://127.0.0.1](http://127.0.0.1) all’elenco.
5. Esegui il tuo EA. L'EA invierà ora dati in tempo reale all’API Python; Python li analizzerà in base ai parametri definiti nella funzione Python e invierà i comandi BUY/SELL/WAIT a MT5.

python local_ai_bridge.py

Visualizzazione nel Strategy Tester: