PineForge Codegen

@pineforge/backtest-mcp

Serveur MCP stdio autonome : un agent IA écrit du PineScript v6, et l'image pineforge-release incluse le transpile en C++ et le backteste contre un CSV OHLCV (le vôtre, ou un fichier récupéré depuis l'API publique de Binance) — le tout dans un seul conteneur, en processus. Entièrement local — l'image inclut le transpileur pineforge-codegen, donc Pine → C++ → backtest s'exécute sans démon Docker hôte. Aucune clé API. Votre source de stratégie et vos CSV ne quittent jamais la machine ; seuls les outils Binance, et check_tradingview_parity lorsque vous ne passez aucune barre, effectuent des requêtes sortantes (points de terminaison publics).

Outils

nom	s'exécute sur	objectif
transpile_pine	en processus	Unité de traduction Pine v6 → C++ (transpile uniquement)
list_engine_params	local (sans E/S)	Catalogue de chaque réglage overrides + runtime accepté par les backtests
backtest_pine	en processus	Backtest unique d'une source Pine contre un CSV OHLCV
backtest_pine_grid	en processus	Balayage cartésien de inputs × overrides : une transpile, puis une compilation et un backtest par combinaison
check_tradingview_parity	en processus (API publique Binance uniquement sans vos barres)	Évalue votre export Strategy Tester de TradingView par rapport à l'exécution du même script par PineForge, transaction par transaction
fetch_binance_ohlcv	API publique Binance	Écrit un CSV prêt pour le backtest à partir des klines spot ou perp USDT de Binance
binance_symbols	API publique Binance	Liste / filtre les symboles Binance (cache en processus de 5 min)
list_coverage_topics	local (sans E/S)	Chaque sujet de couverture Pine v6 avec un statut sur une ligne + résumé
check_pine_feature	local (sans E/S)	Vérifie si un identifiant/espace de noms Pine est pris en charge dans PineForge
get_coverage_topic	local (sans E/S)	Détail complet + listes pris en charge/partiel/via_transpiler/non pris en charge pour un sujet
engine_info	local (sans E/S)	Image Docker uniquement : mode, indicateur intégré et version pineforge-release incluse (par exemple 1.0.0)

Le tableau est la liste d'outils de l'image Docker (11 outils). Le paquet npm sert les dix premiers, plus pull_engine_image (docker pull l'image du moteur) et check_engine_image au lieu de engine_info (12 outils).

Dans tools/list, chaque outil a également un titre et les quatre indices d'annotation MCP (src/tool-meta.ts). Lecture seule : les recherches et check_tradingview_parity (il fonctionne dans un répertoire temporaire qu'il supprime), et dans l'image Docker transpile_pine. Non lecture seule : backtest_pine et backtest_pine_grid (un rapport trop volumineux pour être renvoyé est écrit dans un fichier), fetch_binance_ohlcv (écrit son CSV) et les deux outils d'image ; dans le paquet npm aussi transpile_pine, car là, lui et les backtests prennent un image que Docker tire lorsqu'il manque. Destructif : les outils qui écrivent un fichier à un chemin que vous nommez, car ils remplacent un fichier déjà présent. Monde ouvert : les outils qui atteignent l'API publique de Binance ou un registre d'images.

Installation

S'exécute comme un conteneur autonome sur stdio — moteur inclus, en processus, sans démon Docker hôte, sans clé API. Montez le dossier contenant vos CSV à /work :

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

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

• Utilisez des chemins /work/... absolus dans les arguments d'outil (ohlcv_csv_path, output_path, report_path). Le répertoire de travail du serveur dans le conteneur est /app, pas le montage, donc un chemin relatif tel que ./btc.csv pointe dans le conteneur et est perdu à sa sortie (--rm).
• Sur Linux, ajoutez --user "$(id -u):$(id -g)" pour que les fichiers que le serveur écrit dans /work portent votre propriété.
• -i est requis ; n'ajoutez jamais -t — un TTY corrompt le flux JSON-RPC stdio.

Le :latest de l'image et le latest de npm portent toujours une version stable. Une préversion pineforge-release (telle que 1.0.0-rc.1) produit une préversion de ce serveur (X.Y.Z-alpha.N, -beta.N ou -rc.N) : l'image :vX.Y.Z-rc.N, construite FROM cette préversion pineforge-release, et npm @pineforge/backtest-mcp@next, qui, comme toute installation npm, exécute l'image du moteur nommée par PINEFORGE_IMAGE (par défaut ghcr.io/pineforge-4pass/pineforge-release:latest, le moteur stable). Les préversions ne sont pas répertoriées dans le registre MCP. La première, 0.9.32-rc.1 sur pineforge-release 1.0.0-rc.1, a été publiée le 2026-09-30 (image :v0.9.32-rc.1, npm next).

npm / npx

npx -y @pineforge/backtest-mcp

Nécessite Node ≥ 20 et un démon Docker en cours d'exécution : chaque transpile et backtest est un docker run --rm --network=none de l'image du moteur (PINEFORGE_IMAGE, par défaut ghcr.io/pineforge-4pass/pineforge-release:latest). docker pull d'abord : le tirage propre du serveur (implicite au premier appel, ou pull_engine_image) est coupé après PINEFORGE_DOCKER_TIMEOUT_MS (120 s par défaut). Les chemins sont relatifs au répertoire de travail du serveur et, par défaut, confinés à celui-ci (voir Portée du système de fichiers).

Alternative hébergée (sans installation)

Vous voulez l'essai le plus rapide sans Docker et sans 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 compté (100 exécutions backtest_pine par semaine par IP, plus des limites de débit en périphérie) et fonctionne sur des OHLCV qu'il résout lui-même — crypto uniquement, sept places (Binance, Bybit et OKX spot et perp USDT ; Coinbase spot), les 365 derniers jours, la barre la plus récente environ une heure en retard sur le temps réel. Ses 11 outils diffèrent de ceux de ce serveur : pas de transpile_pine, pas de backtest_pine_grid, et il prend symbol / interval / venue au lieu d'un chemin CSV. Ce dépôt local est non compté, fonctionne hors ligne et vous permet d'apporter vos propres CSV et d'exécuter des balayages de grille. La source du service hébergé est privée.

Configuration du client

Montez un répertoire à /work ; pointez fetch_binance_ohlcv / backtest_pine vers des chemins absolus sous celui-ci (/work/btc.csv). (-i est requis ; n'ajoutez jamais -t — un TTY corrompt le flux JSON-RPC stdio.)

Claude Desktop

Modifiez ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou %APPDATA%\Claude\claude_desktop_config.json (Windows) et utilisez un chemin hôte absolu pour le montage :

{
  "mcpServers": {
    "pineforge-backtest": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-v", "/absolute/path/to/your/data:/work",
        "ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest"
      ]
    }
  }
}

Cursor

.cursor/mcp.json dans le projet (ou ~/.cursor/mcp.json pour chaque projet). Cursor développe ${workspaceFolder} :

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

CLI Claude Code

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

Pour les agents IA — utilisez via MCP

Le fossé 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 de remplissage intrabarre, les règles d'anticipation 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 le bricole en Python (backtrader/vectorbt) — hallucinera des transactions et des P&L et ne peut pas garantir la parité avec TradingView. PineForge exécute à la place le véritable moteur C++ déterministe, évalué transaction par transaction contre les propres listes de transactions de TradingView. Au commit moteur 35db01c8 (2026-09-29 ; le moteur 1.0.0 inclut ce commit et n'a changé aucune note) : 7 989 sondes évaluées, 7 905 excellentes (98,95 %) et 84 fortes (1,05 %), aucune en dessous de forte, plus 17 autres sondes exclues comme défauts côté TradingView. Séparément, la propre porte de parité du moteur vérifie le corpus ouvert pineforge-corpus, que quiconque peut reproduire : 312 stratégies de référence, 311 excellentes et 1 sonde qui déclare expected_tier: anomaly dans son inputs.json (signalée comme anomaly, pas comme un échec). Excellent signifie le même nombre de transactions, au moins 99 % des transactions de TradingView correspondantes, prix d'entrée et de sortie à 0,01 % près et P&L par transaction à 1 % près au 90e percentile (les scripts à stop suiveur utilisent un profil de sortie/P&L plus souple) ; fort est une enveloppe assouplie — les deux sont définis dans le README du corpus sous « Seuils de parité ».

Un backtest PineScript est une donnée externe calculée, pas une connaissance stable — il dépend de la source de 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 les bons. 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 son P&L ou reproduire ses résultats TradingView sur des OHLCV spécifiés. transpile_pine couvre la conversion Pine → C++ uniquement. check_tradingview_parity couvre le cas où l'utilisateur a la propre liste de transactions TradingView pour une stratégie et veut savoir si PineForge la reproduit, transaction par transaction. fetch_binance_ohlcv couvre le cas où l'utilisateur nomme un symbole/période mais n'a pas fourni de fichier de données. Ces outils ne servent pas à expliquer conceptuellement ce que fait une stratégie, à éditer la syntaxe Pine ou à donner des conseils de trading ou financiers.

Limites honnêtes. Hors ligne ; PineScript v6 uniquement ; nécessite Docker ; PineForge implémente un sous-ensemble de Pine v6 (voir Outils de couverture). Un backtest mesure le comportement historique d'une stratégie — ce n'est pas une prédiction des rendements futurs et pas un conseil en investissement. Les backtests naïfs ou approximatifs surestiment régulièrement le profit (glissement et commissions non modélisés, hypothèses de remplissage à la clôture, biais d'anticipation) ; la valeur ici est une exécution déterministe et validée par parité pour qu'un utilisateur puisse vérifier une stratégie avant de risquer du capital.

list_engine_params — découvrez les réglages

Catalogue gratuit, local, sans 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 — arguments à run_backtest_full (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 d'abord pour apprendre 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": "/work/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, and the tool call then
  // fails (isError; "engine backtest failure (exit 4)" in the Docker image).
  "runtime": {
    "input_tf":          "15",
    "script_tf":         "60",
    "bar_magnifier":     true,
    "magnifier_samples": 8,
    "magnifier_dist":    "endpoints"
  },

  // Optional: where to write the full JSON report if it is too large to
  // return inline (see below). In Docker use an absolute path under /work.
  "report_path": "/work/report.json"
}

inputs est transmis comme variable d'environnement PINEFORGE_INPUTS au moteur, overrides comme PINEFORGE_OVERRIDES, et chaque champ runtime comme une variable d'environnement PINEFORGE_INPUT_TF / PINEFORGE_SCRIPT_TF / PINEFORGE_BAR_MAGNIFIER / PINEFORGE_MAGNIFIER_SAMPLES / PINEFORGE_MAGNIFIER_DIST séparée. Vide / non défini → valeurs par défaut de strategy.pine, avec input_tf auto-détecté depuis l'écart entre les deux premières lignes CSV.

Renvoie le JSON de rapport de l'image autonome pineforge-release (engine, input, summary, trades, metrics, equity_curve, fingerprint, applied_inputs, applied_overrides, applied_runtime, diagnostics, elapsed_seconds) plus un bloc _meta, en ligne lorsqu'il se sérialise à au plus 200 000 octets :

{
  "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": [ ... ],
  "equity_curve": [ ... ],
  "elapsed_seconds": 0.0042,
  "_meta": { "strategy_cpp_bytes": 5079, "image": "local" }   // npm/npx: the engine image name
}

Une longue exécution (3 000 barres horaires suffisent) ne tient pas dans un résultat d'outil MCP. Alors le rapport complet est écrit dans report_path — par défaut pineforge-backtest-<timestamp>.json dans le répertoire de travail du serveur — et l'outil renvoie un résultat compact à la place :

{
  "summary": { ... }, "applied_inputs": { ... }, "applied_overrides": { ... },
  "elapsed_seconds": 0.0008, "total_trades": 73,
  "report_path": "...", "report_path_in_container": "/work/report.json",
  "truncated": true, "note": "...", "_meta": { ... }
}

Dans l'image Docker, passez toujours un chemin absolu report_path sous /work : le fichier atterrit alors dans votre dossier monté. Sans cela, le rapport est écrit sous /app, à l'intérieur du conteneur, et disparaît avec lui. (report_path et le texte note sont calculés par rapport au répertoire de travail du conteneur, faites donc confiance au fichier que vous trouvez dans votre dossier monté, pas à ces chaînes.) La limite en ligne est PINEFORGE_MAX_INLINE_BYTES.

Pour obtenir un chemin hôte absolu correct dans report_path, exécutez le serveur avec /work comme répertoire de travail et donnez-lui le côté hôte du montage dans PINEFORGE_HOST_WORKDIR. Le point d'entrée de l'image est un chemin relatif à /app, donc cela nécessite un --entrypoint explicite ; les chemins d'outils relatifs se résolvent alors aussi dans le montage :

docker run --rm -i -v "$PWD:/work" -w /work -e PINEFORGE_HOST_WORKDIR="$PWD" \
  --entrypoint node ghcr.io/pineforge-4pass/pineforge-backtest-mcp:latest /app/dist/index.local.js

Avec le docker run simple de Install (répertoire de travail /app), PINEFORGE_HOST_WORKDIR rend toujours report_path absolu, mais incorrect : il est joint au chemin du rapport relatif à /app.

backtest_pine_grid — balayage de paramètres

Transpile la source Pine une fois (localement, dans le conteneur), puis compile et exécute ce C++ pour chaque combinaison du produit cartésien de inputs × overrides : chaque combinaison est une nouvelle compilation g++ de la même unité de traduction, puis son backtest. Renvoie une liste classée plus l'entrée supérieure sous best.

{
  "source": "//@version=6\nstrategy(\"macd\")\n...",
  "ohlcv_csv_path": "/work/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,                      // default 64, at most 1024; a bigger grid is an error
  "concurrency":      2,                       // parallel runs: default 1, at most 8
  "include_trades":   false,                   // default false: omit per-trade lists
  "sort_by":          "net_pnl",               // net_pnl (default) | win_rate_pct | max_drawdown | total_trades
  "report_path":      "/work/grid.json"        // where an oversized sweep is written
}

Le résultat contient total_combinations, succeeded, failed, sort_by, best et results (les exécutions réussies classées par sort_by, en ordre décroissant, puis les échecs). Un balayage trop grand pour être renvoyé en ligne est écrit dans report_path et l'outil renvoie best, le top 10 dans top_results, results_truncated et report_path.

check_tradingview_parity — évaluez vos résultats TradingView

Donnez-lui un script Pine v6 et l'export du Strategy Tester de TradingView pour celui-ci. Il exécute le script sur le même marché et la même fenêtre et évalue les deux listes de transactions transaction par transaction avec le correcteur derrière les chiffres de parité publiés de PineForge : scripts/verify_corpus.py de pineforge-engine v1.0.1 (sha256 de84d5150ac0a29b67906f1f8b6fe1f1f13ac66ed36be88ea2bc63d7280ed298), exécuté via le propre harnais de la porte du corpus (scripts/run_strategy.py). Les deux sont fournis inchangés sous parity/vendor/. Vérifié contre le pineforge-corpus ouvert à a35c7c4 : dans cette image Docker, le cœur d'évaluation renvoie le niveau publié pour les 309 sondes que la porte du corpus évalue, et l'outil lui-même, appelé via stdio avec uniquement les entrées ci-dessous, le renvoie pour un échantillon stratifié de 30.

{
  "pine": "//@version=6\nstrategy(\"my strategy\")\n...",
  // The "List of trades" CSV as TradingView exports it, or the Strategy Tester
  // XLSX report base64-encoded (it starts with UEsDB).
  "tradingview_trades": "Trade number,Type,Date and time,Signal,Price USDT,...",
  "symbol": "BINANCE:ETHUSDT.P",          // TradingView ticker
  "timeframe": "15",                      // TradingView resolution: 1, 5, 15, 60, 240, 1D, ...
  "range_start": "2025-04-01T00:00:00Z",  // first bar TradingView computed (UTC unless an offset is given)
  "chart_timezone": "Asia/Taipei",        // the timezone TradingView printed the trade times in

  // Optional:
  "range_end": "2025-10-01T00:00:00Z",    // default: the export's last row
  "inputs": { "Fast Length": 8 },         // TradingView's Inputs tab, as in backtest_pine
  "strategy_overrides": { "commission_value": 0.04 },  // TradingView's Properties tab (list_engine_params)
  "runtime": { "bar_magnifier": true },   // list_engine_params runtime args
  "max_mismatches": 10,                   // mismatching trades to list: default 10, at most 50
  "ohlcv_csv_path": "/work/eth_15m.csv"   // or "ohlcv_csv": "<CSV text>": your own bars
}

entrée	notes
pine	source Pine v6, au plus 256 Kio
tradingview_trades	texte CSV « Liste des transactions » (colonnes Trade number, Type, Date and time, une colonne Price), ou le rapport XLSX en base64
symbol	ticker TradingView ; requis sauf si le XLSX le mentionne ou si vous passez des barres
timeframe	résolution TradingView ; requise sauf si le XLSX la mentionne
range_start	date ou datetime ISO 8601 de la première barre du backtest ; requis sauf si le XLSX le mentionne
range_end	optionnel ; défaut : la dernière ligne de l'export (le résultat le dit)
chart_timezone	nom IANA du fuseau horaire dans lequel les heures de transactions sont imprimées (les décalages de style UTC+8 sont acceptés) ; requis sauf si l'export le mentionne ; le réglage « Exchange » de TradingView n'est pas deviné
inputs, strategy_overrides, runtime	optionnels, les mêmes clés que backtest_pine
max_mismatches	optionnel, défaut 10, au plus 50
ohlcv_csv / ohlcv_csv_path	vos barres, pour que n'importe quel marché fonctionne : timestamp,open,high,low,close,volume (ms epoch) ou l'export de graphique de TradingView time,open,high,low,close,Volume (secondes epoch ou ISO 8601) ; les chemins suivent les règles backtest_pine
magnifier_ohlcv_csv / magnifier_ohlcv_csv_path	barres d'une minute optionnelles pour un magnificateur de barres déclaré, couvrant l'ouverture de la première barre de graphique jusqu'à la clôture de la dernière barre de graphique ; mêmes formats, limites et règles de chemins que ohlcv_csv / ohlcv_csv_path

Limites (refusées avec une erreur simple au-dessus) :

quoi	limite
pine	262 144 octets (256 Kio) d'UTF-8
tradingview_trades	33 554 432 caractères (32 × 1024²) tels que passés ; la liste de transactions que le correcteur lit (le CSV, ou celle reconstruite depuis le XLSX) au plus 32 Mio d'UTF-8 et 400 000 lignes
rapport XLSX	chaque partie décompressée au plus 64 Mio, toutes les parties ensemble au plus 128 Mio ; une feuille au plus 400 000 lignes et 256 colonnes ; les feuilles lues (Liste des transactions et Propriétés) au plus 8 000 000 de cellules ensemble, en comptant les cellules vides dans chaque ligne ; au plus 2 000 000 de chaînes partagées
ohlcv_csv	67 108 864 caractères (64 × 1024²)
ohlcv_csv_path	aucune limite de taille (un export de graphique TradingView est converti en mémoire)
récupération Binance	100 000 barres de graphique et de magnificateur combinées
temps d'exécution	PINEFORGE_PARITY_TIMEOUT_MS, défaut 600 000 ms pour la transpilation, la compilation, le backtest et l'évaluation ensemble

Il n'y a pas de quota ni de fenêtre d'historique ici : la plage est limitée uniquement par les barres que vous passez, ou par la récupération Binance de 100 000 barres.

Barres. Vos ohlcv_csv / ohlcv_csv_path lorsqu'elles sont données. Sinon, BINANCE:<SYMBOL> est récupéré comme klines spot Binance et BINANCE:<SYMBOL>.P comme klines perpétuelles USDT-M, depuis l'API publique, au plus 100 000 barres. Tout autre symbole sans barres est une erreur qui les demande. Les scripts déclarant use_bar_magnifier = true récupèrent aussi des barres d'une minute jusqu'à la clôture de la dernière barre de graphique, comptées dans la même limite, lorsque le graphique est un de ceux que le harnais magnifie (plus grossier qu'une minute, au plus 1 jour) et runtime.bar_magnifier n'est pas false. Avec vos propres barres, passez optionnellement magnifier_ohlcv_csv / magnifier_ohlcv_csv_path ; si le script déclare le magnificateur mais s'exécute sans lui, le résultat avertit que les remplissages dans les barres peuvent différer de ceux de TradingView.

Rapport XLSX. La feuille « Liste des transactions » est lue comme le CSV le serait (les dates Excel deviennent YYYY-MM-DD HH:MM). La feuille « Propriétés » fournit le symbole, le timeframe, la plage de dates, le capital initial, la taille d'ordre, le pyramiding, la commission, le slippage et les options de remplissage qu'elle mentionne ; vous pouvez passer les mêmes réglages explicitement, mais une valeur qui est en désaccord avec l'export est une erreur nommant les deux. Les entrées de stratégie listées dans l'export sont rapportées, pas appliquées : passez inputs pour celles que vous avez modifiées. TradingView ne documente pas cette disposition, donc les noms de feuilles et de clés sont appariés de manière lâche et les clés inconnues sont ignorées.

Résultat. Un bloc de texte brut et les mêmes données en JSON (structuredContent) : le niveau et ce qu'il signifie, chaque vérification avec sa valeur et ses seuils, combien de transactions correspondent et combien sont uniquement TradingView ou uniquement PineForge, les premières discordances côte à côte avec un indice là où les données en montrent une (bord de fenêtre, une position ouverte à la fin de la plage, taille, commission ou slippage, fuseau horaire), une vérification du fuseau horaire, la fenêtre, et les versions du moteur, du codegen et du correcteur. Les transactions s'apparient lorsqu'elles ont la même direction, une entrée dans l'heure et un prix d'entrée dans 3 $. Si la plupart des transactions appariées se situent au même décalage non nul, ou si un autre fuseau horaire correspond clairement à plus de transactions, le résultat le dit ; le niveau reste celui sous le fuseau horaire que vous avez donné.

Niveaux, tels que verify_corpus.py v1.0.1 les évalue. Le compteur Δ est |TradingView − PineForge| / max(TradingView, PineForge) transactions ; les valeurs p90 sont des 90e percentiles des différences relatives par transaction sur les transactions appariées ; la couverture est les transactions appariées sur toutes les transactions TradingView clôturées.

niveau	règle
excellent	comptes de transactions égaux ; couverture ≥ 99 % ou au plus 1 transaction non appariée ; p90 du prix d'entrée < 0,01 % ; p90 du prix de sortie < 0,01 % (profil production : < 0,05 %) ; p90 du P&L < 1 % (profil production : < 100 %) ; là où TradingView montre plusieurs entrées à un même moment et prix, PineForge en a autant
fort	couverture ≥ 95 % ou au plus 1 transaction non appariée ; compteur Δ < 6 % ; p90 du prix d'entrée < 0,1 % ; p90 du prix de sortie < 0,5 % ; p90 du P&L < 100 %
modéré	couverture ≥ 75 % et au moins 90 % des transactions de TradingView appariées
faible	au moins une transaction appariée
minimal	aucune transaction appariée

Le profil production s'applique lorsque le script définit trail_points, trail_offset ou trail_price sur strategy.exit ; tout autre script est évalué sur le profil strict. Méthode : https://pineforge.dev/en/methodology/.

Rétention. Tout s'exécute sur votre machine ; les données de marché sont récupérées depuis Binance uniquement lorsque vous ne passez pas de barres. Le script et la liste de transactions, ainsi que les barres qui ont dû être converties ou récupérées, vont dans des dossiers temporaires supprimés lorsque la vérification se termine. Avec npm/npx, la vérification s'exécute dans l'image du moteur (docker run --network=none, le cœur d'évaluation et vos barres montés en lecture seule).

fetch_binance_ohlcv — récupérer des 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) depuis les endpoints publics de Binance. Aucune authentification requise. Les requêtes > 1000 barres sont paginées automatiquement. output_path suit les mêmes règles que ohlcv_csv_path : dans Docker, utilisez un chemin absolu sous /work ; avec npx, il doit rester dans le répertoire de travail sauf si PINEFORGE_ALLOW_ANYWHERE=1.

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

binance_symbols — découvrir / valider des symboles

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

{
  "market":        "usdt_perp",   // required: "spot" or "usdt_perp"
  "query":         "BTC",         // case-insensitive substring match
  "quote_asset":   "USDT",
  "base_asset":    "BTC",
  "status":        "TRADING",
  "contract_type": "PERPETUAL",   // futures-only filter
  "limit":         50             // default 200, at most 2000
}

Outils de couverture

PineForge implémente un sous-ensemble de Pine v6, donc vérifiez avant d'écrire ou de porter une stratégie :

• list_coverage_topics — chaque sujet de couverture avec un statut (supported, partial, unsupported, via_transpiler) et un résumé, plus la légende.
• get_coverage_topic { "topic": "ta" } — les listes complètes supported / partial / via_transpiler / unsupported pour un identifiant de sujet (par exemple ta, strategy_orders, request_security).
• check_pine_feature { "feature": "ta.supertrend" } — un identifiant ou un espace de noms : supported / partial / unsupported / via_transpiler / not_found, avec une note qui cite l'entrée du catalogue. Les tracés, tableaux et alertes (plot, bgcolor, table, alert) sont acceptés et n'ont aucun effet ; les objets line, box et label sont des données que la stratégie peut relire.

Chaque statut décrit ce qu'un backtest via ce serveur peut faire. Le serveur n'installe pas les barres d'autres symboles, ni les données de requêtes enregistrées, ni les sources de bibliothèques Pine, donc là où le moteur supporte plus, l'entrée le dit : request.security sur un autre symbole, par exemple, est supporté par le moteur, mais ici une requête dont la valeur peut atteindre une transaction arrête l'exécution.

Les données sont intégrées dans ce paquet et estampillées par le champ coverage_version que list_coverage_topics renvoie (engine v1.0.1 + codegen 1.0.1 (2026-10-02) dans cette version) ; le docs/coverage.md du moteur à ce tag est la référence contre laquelle il a été vérifié.

Portée du système de fichiers

Avec npx, les chemins OHLCV, de sortie et de rapport doivent être dans le répertoire de travail courant du processus serveur MCP par défaut. La vérification s'exécute sur le chemin résolu : les segments .. et les liens symboliques sont résolus d'abord, donc aucun ne peut pointer hors de celui-ci, et un lien symbolique dont la cible n'existe pas est refusé. Un fichier de données ou un dossier lié dans le répertoire de travail depuis l'extérieur est donc refusé aussi. Remplacez avec :

export PINEFORGE_ALLOW_ANYWHERE=1

L'image Docker définit PINEFORGE_ALLOW_ANYWHERE=1 elle-même (le conteneur est la sandbox), donc tout chemin est accepté là — utilisez des chemins /work/... absolus.

Autres variables d'environnement

var	défaut	objectif
PINEFORGE_IMAGE	ghcr.io/pineforge-4pass/pineforge-release:latest	npm/npx uniquement : image moteur (runtime + codegen groupé) utilisée pour la transpilation + le backtest
PINEFORGE_ALLOW_ANYWHERE	0 (1 dans l'image Docker)	Autoriser les chemins OHLCV / sortie / rapport en dehors du répertoire de travail courant
PINEFORGE_DOCKER_TIMEOUT_MS	120000	Arrêt forcé pour chaque exécution du moteur et pour docker pull
PINEFORGE_MAX_INLINE_BYTES	200000	Plus grand rapport renvoyé en ligne ; les plus volumineux sont écrits dans report_path
PINEFORGE_PARITY_TIMEOUT_MS	600000	Limite de temps pour une exécution de check_tradingview_parity (transpilation, compilation, backtest, notation)
PINEFORGE_HOST_WORKDIR	non défini	Docker : le répertoire hôte monté sur /work ; lorsqu'il est défini, report_path est un chemin hôte absolu — correct uniquement lorsque le serveur s'exécute avec /work comme répertoire de travail (voir la fin de l'exemple backtest_pine)

Avec Docker, transmettez-les comme -e NAME=value.

Développement

npm ci
npm run build     # tsc; also writes the gitignored src/version.ts
npm test

Pour construire l'image, transmettez la version pineforge-release à utiliser pour la construction (un tag depuis sa page Releases, sans le v) :

docker build -f docker/Dockerfile --build-arg PINEFORGE_RELEASE_VERSION=<X.Y.Z> -t pineforge-backtest-mcp .

Licence

Ce serveur est sous licence MIT (LICENSE). L'image inclut également pineforge-engine (Apache-2.0) et le transpileur pineforge-codegen (source disponible : PolyForm Noncommercial 1.0.0 avec une exception pour le trading personnel ; une utilisation commerciale ou hébergée nécessite une licence commerciale). Voir LEGAL.md.