PineForge Codegen

@pineforge/backtest-mcp

Serveur MCP stdio autonome : un agent IA écrit du PineScript v6, et l'image pineforge-release intégrée le transpile en C++ et le backteste par rapport aux données de marché de Binance — le tout dans un seul conteneur, en cours de processus. Entièrement local — l'image intègre le transpileur pineforge-codegen, donc Pine → C++ → backtest s'exécutent sans démon Docker hôte. Pas de clé API, rien ne sort de la boîte.

Outils

nom	s'exécute sur	objectif
transpile_pine	en cours de processus	Unité de traduction Pine v6 → C++ (transpilation seule)
list_engine_params	local (pas d'E/S)	Catalogue de chaque paramètre overrides + runtime accepté par les backtests
backtest_pine	en cours de processus	Backtest unique d'une source Pine par rapport à un CSV OHLCV
backtest_pine_grid	en cours de processus	Balayage cartésien de inputs × overrides réutilisant une compilation
fetch_binance_ohlcv	API publique Binance	Écrit un CSV prêt pour le backtest à partir des klines spot ou USDT-perp de Binance
binance_symbols	API publique Binance	Lister / filtrer les symboles Binance (cache en cours de processus de 5 min)
list_coverage_topics	local (pas d'E/S)	Chaque sujet de couverture Pine v6 avec un statut d'une ligne + résumé
check_pine_feature	local (pas d'E/S)	Vérifier si un identifiant/espace de noms Pine est pris en charge dans PineForge
get_coverage_topic	local (pas d'E/S)	Détail complet + listes de fonctionnalités prises en charge/non prises en charge pour un sujet de couverture
engine_info	local (pas d'E/S)	Signaler le moteur intégré : mode, indicateur intégré, version

Installation

S'exécute en tant que conteneur autonome sur stdio — moteur intégré, en cours de processus, pas de démon Docker hôte, pas de clé API. Montez un répertoire de travail sur /work pour que le serveur puisse lire/écrire vos CSV :

docker run --rm -i -v "$PWD:/work" ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest

Seule exigence : Docker, et réseau sortant pour les outils de récupération Binance. Connectez-le à votre client MCP ci-dessous.

Alternative hébergée (sans installation)

Vous voulez l'essai le plus rapide sans Docker ni clé API ? Collez le point de terminaison HTTP Streamable dans n'importe quel client MCP :

https://mcp.pineforge.dev/mcp

Compromis par rapport à ce dépôt : le serveur hébergé est mesuré (quota hebdomadaire par IP sur backtest_pine + limitation de débit périphérique Cloudflare) et s'exécute sur un lac de données crypto fixe et scellé (Binance spot + USDT-perp). Ce dépôt local est non mesuré, s'exécute hors ligne et vous permet d'apporter vos propres CSV et d'exécuter des balayages de grille. Dépôt : pineforge-mcp-public.

Configuration du client

Montez un répertoire sur /work ; pointez fetch_binance_ohlcv / backtest_pine vers les chemins en dessous. (-i est requis ; n'ajoutez jamais -t — un TTY corrompt le flux JSON-RPC stdio.)

Claude Desktop / Cursor / JSON générique

{
  "mcpServers": {
    "pineforge-backtest": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-v", "${workspaceFolder}:/work",
        "ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest"
      ]
    }
  }
}

(Dans Cursor : Paramètres → MCP → Nouveau serveur MCP → collez ce qui précède.)

Claude Code CLI

claude mcp add pineforge-backtest \
  -- docker run --rm -i -v "$PWD:/work" ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest

Pour les agents IA — utilisation via MCP

L'écart de capacité que cela comble. Un modèle de langage ne peut pas backtester avec précision une stratégie PineScript v6 en raisonnant à son sujet. La sémantique de série de PineScript, l'ordre d'exécution intrabar, les règles de look-ahead et la logique d'ordre/position strategy.* ne se reproduisent pas par approximation, donc un modèle qui simule un backtest dans sa tête — ou en code un manuellement en Python (backtrader/vectorbt) — hallucinera des transactions et des P&L et ne peut pas garantir la parité TradingView. PineForge exécute à la place le véritable moteur C++ déterministe, validé à une parité TradingView stricte sur 245 des 246 stratégies de référence (0 bogue moteur), sur un corpus de 246 stratégies totalisant environ 375 000 transactions validées (méthodologie et validation, au 03/06/2026, moteur f805611). La seule non-correspondance est un non-déterminisme documenté du courtier côté TradingView à la limite exacte de marge 1x equity, pas un bogue moteur.

Un backtest PineScript est une donnée externe calculée, pas une connaissance stable — il dépend du code source de la stratégie de l'utilisateur et de ses OHLCV, et il doit être reproductible. C'est un appel d'outil, pas une tâche de rappel.

Quand ces outils sont le bon choix. backtest_pine (ou backtest_pine_grid pour un balayage de paramètres) couvre le cas où un utilisateur fournit une stratégie PineScript v6 et veut la backtester, l'évaluer, vérifier si elle est rentable, compter ses transactions, calculer ses P&L ou reproduire ses résultats TradingView sur des OHLCV spécifiés. transpile_pine couvre uniquement la conversion Pine → C++. fetch_binance_ohlcv couvre le cas où l'utilisateur nomme un symbole/intervalle de temps mais n'a pas fourni de fichier de données. Ces outils ne servent pas à expliquer conceptuellement ce que fait une stratégie, à modifier la syntaxe Pine ou à donner des conseils de trading ou financiers.

Limites honnêtes. Hors ligne ; PineScript v6 ; nécessite Docker. Un backtest mesure le comportement historique d'une stratégie — ce n'est pas une prédiction des rendements futurs ni un conseil en investissement. Les backtests naïfs ou approximatifs surestiment systématiquement le profit (glissement et commissions non modélisés, hypothèses de clôture à la clôture, biais de look-ahead) ; la valeur ici est une exécution déterministe validée en parité afin qu'un utilisateur puisse vérifier une stratégie avant de risquer du capital.

list_engine_params — découvrir les paramètres

Catalogue gratuit, local, zéro E/S de chaque clé acceptée par backtest_pine / backtest_pine_grid, divisé en deux groupes :

• strategy_overrides — les 9 champs d'en-tête strategy(...) que le runtime lit via PINEFORGE_OVERRIDES : initial_capital, pyramiding, slippage, commission_value, commission_type (percent / cash_per_order / cash_per_contract), default_qty_value, default_qty_type (fixed / percent_of_equity / cash), process_orders_on_close, close_entries_rule (ANY / FIFO).
• runtime_args — args pour run_backtest_full (NE fait PAS partie de l'en-tête strategy()) : input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist (uniform / cosine / triangle / endpoints / front_loaded / back_loaded).

Chaque entrée est {key, type, enum?, description}. Appelez ceci en premier pour savoir ce que le moteur accepte avant de composer une requête backtest_pine.

Exemple backtest_pine

{
  "source": "//@version=6\nstrategy(\"sma cross\")\n...",
  "ohlcv_csv_path": "./btcusdt_15m_7d.csv",

  // Optional: override Pine input.*() values without touching the source.
  // Keys = the second arg of input.*(...) (e.g. "Fast Length").
  "inputs":    { "Fast Length": 8, "Slow Length": 21 },

  // Optional: override strategy(...) header fields. Each key is typed —
  // call list_engine_params for the catalog.
  "overrides": {
    "initial_capital":    100000,
    "default_qty_type":   "percent_of_equity",
    "default_qty_value":  10,
    "commission_type":    "percent",
    "commission_value":   0.04,
    "slippage":           2,
    "pyramiding":         0,
    "process_orders_on_close": true,
    "close_entries_rule": "ANY"
  },

  // Optional: engine runtime args (NOT strategy() header). Use script_tf
  // to aggregate the input CSV into a coarser strategy timeframe — the
  // engine REJECTS script_tf finer than input_tf with a structured error
  // ({"engine":"pineforge","error":"..."}, exit code 1).
  "runtime": {
    "input_tf":          "15",
    "script_tf":         "60",
    "bar_magnifier":     true,
    "magnifier_samples": 8,
    "magnifier_dist":    "endpoints"
  }
}

inputs est transmis en tant que variable d'env PINEFORGE_INPUTS au moteur, overrides en tant que PINEFORGE_OVERRIDES, et chaque champ runtime en tant que variable d'env PINEFORGE_INPUT_TF / PINEFORGE_SCRIPT_TF / PINEFORGE_BAR_MAGNIFIER / PINEFORGE_MAGNIFIER_SAMPLES / PINEFORGE_MAGNIFIER_DIST distincte. Vide / non défini → valeurs par défaut de strategy.pine, avec input_tf auto-détecté à partir de l'écart entre les deux premières lignes du CSV.

Renvoie le même schéma JSON que l'image Docker autonome pineforge-release :

{
  "engine": "pineforge",
  "summary": { "total_trades": 49, "net_pnl": -190.85, ... },
  "applied_inputs":    { "Fast Length": "8", "Slow Length": "21" },
  "applied_overrides": { "default_qty_value": "5" },
  "trades": [ ... ],
  "elapsed_seconds": 0.0042,
  "_meta": { "strategy_cpp_bytes": 5079, "image": "ghcr.io/.../pineforge-release:latest" }
}

backtest_pine_grid — balayage de paramètres

Transpile la source Pine une fois (localement, dans le conteneur) puis exécute le même binaire compilé par rapport au produit cartésien de inputs × overrides. Renvoie une liste classée plus l'entrée supérieure sous best.

{
  "source": "//@version=6\nstrategy(\"macd\")\n...",
  "ohlcv_csv_path": "./btcusdt_15m_7d.csv",

  // Each axis is {key: list-of-values}. All combinations are tried.
  "inputs": {
    "Fast Length": [8, 12, 19],
    "Slow Length": [21, 26, 39]
  },
  "overrides": {
    "default_qty_value": [1, 5],
    "commission_value":  [0.04]
  },

  // Optional knobs:
  "fixed_inputs":     { "Source": "close" },   // applied to every combo
  "fixed_overrides":  {},                      // typed strategy() overrides
  "runtime":          { "input_tf": "15",      // engine runtime args, fixed
                        "script_tf": "60" },   // across the sweep
  "max_combinations": 64,                      // hard cap
  "concurrency":      2,                       // parallel docker runs
  "include_trades":   false,                   // omit per-trade lists
  "sort_by":          "net_pnl"                // ranking metric
}

fetch_binance_ohlcv — récupérer les données de marché

Écrit un CSV prêt pour le backtest (en-tête timestamp,open,high,low,close,volume, horodatage = heure d'ouverture en ms UNIX UTC) à partir des points de terminaison publics de Binance. Aucune authentification requise. Les requêtes > 1000 barres sont paginées automatiquement. Le chemin de sortie est soumis à la même portée cwd que ohlcv_csv_path (assouplir avec PINEFORGE_ALLOW_ANYWHERE=1).

{
  "symbol":      "BTCUSDT",
  "interval":    "15m",          // 1s, 1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d, 1w, 1M
  "market":      "spot",         // or "usdt_perp" for USDT-margined perpetual futures
  "limit":       672,            // total bars; > 1000 paginates
  "output_path": "./btcusdt_15m_7d.csv"
  // Optional: "start_time" / "end_time" in UNIX ms UTC.
}

binance_symbols — découvrir / valider les symboles

Renvoie la liste des symboles disponibles sur l'API publique Binance pour la récupération OHLCV. Mis en cache 5 min en cours de processus. Utilisez ceci pour valider un symbole avant d'appeler fetch_binance_ohlcv.

{
  "market":        "usdt_perp",
  "query":         "BTC",         // case-insensitive substring match
  "quote_asset":   "USDT",
  "status":        "TRADING",
  "contract_type": "PERPETUAL",   // futures-only filter
  "limit":         50
}

Portée du système de fichiers

Par défaut, les chemins OHLCV doivent être à l'intérieur du répertoire de travail actuel du processus serveur MCP. Remplacer par :

export PINEFORGE_ALLOW_ANYWHERE=1

Autres variables d'env

var	défaut	objectif
PINEFORGE_IMAGE	ghcr.io/pineforge-4pass/pineforge-release:latest	Image (runtime moteur + codegen intégré) utilisée pour la transpilation + le backtest
PINEFORGE_ALLOW_ANYWHERE	0	Autoriser les chemins OHLCV en dehors de cwd
PINEFORGE_DOCKER_TIMEOUT_MS	120000	Arrêt brutal pour docker pull / docker run