PineForge Codegen

@pineforge/backtest-mcp

स्व-निहित stdio MCP सर्वर: एक AI एजेंट PineScript v6 लिखता है, और बंडल किया गया pineforge-release इमेज इसे C++ में ट्रांसपाइल करता है और इसे OHLCV CSV के विरुद्ध बैकटेस्ट करता है (आपका अपना, या Binance की सार्वजनिक API से लाया गया) — सब कुछ एक कंटेनर में, इन-प्रोसेस। पूरी तरह से स्थानीय — इमेज में बंडल है pineforge-codegen ट्रांसपाइलर, इसलिए Pine → C++ → बैकटेस्ट बिना किसी होस्ट Docker डेमन के चलता है। कोई API कुंजी नहीं। आपका स्ट्रेटेजी सोर्स और CSV कभी भी मशीन से बाहर नहीं जाते; केवल Binance टूल्स, और check_tradingview_parity जब आप कोई बार पास नहीं करते, बाहरी अनुरोध करते हैं (सार्वजनिक एंडपॉइंट)।

टूल्स

नाम	किस पर चलता है	उद्देश्य
transpile_pine	इन-प्रोसेस	Pine v6 → C++ ट्रांसलेशन यूनिट (केवल ट्रांसपाइल)
list_engine_params	स्थानीय (कोई I/O नहीं)	बैकटेस्ट द्वारा स्वीकार किए गए हर overrides + runtime नॉब की सूची
backtest_pine	इन-प्रोसेस	OHLCV CSV के विरुद्ध Pine सोर्स का एकल बैकटेस्ट
backtest_pine_grid	इन-प्रोसेस	inputs × overrides का कार्टेशियन स्वीप: एक ट्रांसपाइल, फिर प्रति संयोजन एक कंपाइल और एक बैकटेस्ट
check_tradingview_parity	इन-प्रोसेस (आपके बार के बिना केवल Binance सार्वजनिक API)	अपने TradingView Strategy Tester एक्सपोर्ट को PineForge के उसी स्क्रिप्ट के रन के विरुद्ध, ट्रेड-दर-ट्रेड ग्रेड करें
fetch_binance_ohlcv	Binance सार्वजनिक API	Binance स्पॉट या USDT-पर्प klines से बैकटेस्ट-तैयार CSV लिखें
binance_symbols	Binance सार्वजनिक API	Binance प्रतीकों को सूचीबद्ध / फ़िल्टर करें (5-मिनट इन-प्रोसेस कैश)
list_coverage_topics	स्थानीय (कोई I/O नहीं)	हर Pine v6 कवरेज विषय एक-पंक्ति स्थिति + सारांश के साथ
check_pine_feature	स्थानीय (कोई I/O नहीं)	जाँचें कि क्या कोई Pine पहचानकर्ता/नेमस्पेस PineForge में समर्थित है
get_coverage_topic	स्थानीय (कोई I/O नहीं)	एक विषय के लिए पूर्ण विवरण + समर्थित/आंशिक/वाया_ट्रांसपाइलर/असमर्थित सूचियाँ
engine_info	स्थानीय (कोई I/O नहीं)	केवल Docker इमेज: मोड, बेक्ड-इन फ्लैग और बंडल किया गया pineforge-release संस्करण (उदाहरण के लिए 1.0.0)

तालिका Docker इमेज की टूल सूची है (11 टूल)। npm पैकेज पहले दस को सेवा देता है, साथ ही pull_engine_image (docker pull इंजन इमेज) और check_engine_image के बजाय engine_info (12 टूल)।

tools/list में हर टूल का एक शीर्षक और चार MCP एनोटेशन संकेत भी हैं (src/tool-meta.ts)। केवल-पठनीय: लुकअप और check_tradingview_parity (यह एक अस्थायी निर्देशिका में काम करता है जिसे यह हटा देता है), और Docker इमेज में transpile_pine। केवल-पठनीय नहीं: backtest_pine और backtest_pine_grid (एक रिपोर्ट जो लौटाने के लिए बहुत बड़ी है, एक फ़ाइल में लिखी जाती है), fetch_binance_ohlcv (अपना CSV लिखता है) और दो इमेज टूल; npm पैकेज में भी transpile_pine, क्योंकि वहाँ यह और बैकटेस्ट एक image लेते हैं जिसे Docker अनुपस्थित होने पर खींचता है। विनाशकारी: वे टूल जो आपके द्वारा नामित पथ पर एक फ़ाइल लिखते हैं, क्योंकि वे वहाँ पहले से मौजूद फ़ाइल को बदल देते हैं। ओपन-वर्ल्ड: वे टूल जो Binance की सार्वजनिक API या एक इमेज रजिस्ट्री तक पहुँचते हैं।

इंस्टॉल

stdio पर एक स्व-निहित कंटेनर के रूप में चलता है — इंजन बंडल, इन-प्रोसेस, कोई होस्ट Docker डेमन नहीं, कोई API कुंजी नहीं। अपने CSV वाले फ़ोल्डर को /work पर माउंट करें:

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

केवल आवश्यकता: Docker, और Binance फ़ेच टूल्स के लिए आउटबाउंड नेटवर्क। इसे अपने MCP क्लाइंट में नीचे वायर करें।

• टूल तर्कों में पूर्ण /work/... पथ का उपयोग करें (ohlcv_csv_path, output_path, report_path)। कंटेनर के अंदर सर्वर की कार्यशील निर्देशिका /app है, माउंट नहीं, इसलिए ./btc.csv जैसा सापेक्ष पथ कंटेनर में इंगित करता है और बाहर निकलने पर खो जाता है (--rm)।
• Linux पर, --user "$(id -u):$(id -g)" जोड़ें ताकि सर्वर द्वारा लिखी गई फ़ाइलें /work पर आपके स्वामित्व को धारण करें।
• -i आवश्यक है; -t कभी न जोड़ें — एक TTY stdio JSON-RPC स्ट्रीम को दूषित करता है।

इमेज का :latest और npm का latest हमेशा एक स्थिर रिलीज़ रखते हैं। एक pineforge-release प्रीरिलीज़ (जैसे 1.0.0-rc.1) इस सर्वर का एक प्रीरिलीज़ उत्पन्न करता है (X.Y.Z-alpha.N, -beta.N या -rc.N): इमेज :vX.Y.Z-rc.N, उस pineforge-release प्रीरिलीज़ से निर्मित, और npm @pineforge/backtest-mcp@next, जो, किसी भी npm इंस्टॉल की तरह, PINEFORGE_IMAGE द्वारा नामित इंजन इमेज चलाता है (डिफ़ॉल्ट ghcr.io/pineforge-4pass/pineforge-release:latest, स्थिर इंजन)। प्रीरिलीज़ MCP रजिस्ट्री में सूचीबद्ध नहीं हैं। पहला, 0.9.32-rc.1, pineforge-release 1.0.0-rc.1 पर, 2026-09-30 को प्रकाशित हुआ था (इमेज :v0.9.32-rc.1, npm next)।

npm / npx

npx -y @pineforge/backtest-mcp

Node ≥ 20 और एक चालू Docker डेमन की आवश्यकता है: प्रत्येक ट्रांसपाइल और बैकटेस्ट इंजन इमेज का एक docker run --rm --network=none है (PINEFORGE_IMAGE, डिफ़ॉल्ट ghcr.io/pineforge-4pass/pineforge-release:latest)। इसे पहले docker pull करें: सर्वर का अपना पुल (पहली कॉल पर निहित, या pull_engine_image) कट जाता है PINEFORGE_DOCKER_TIMEOUT_MS (डिफ़ॉल्ट रूप से 120 सेकंड) के बाद। पथ सर्वर की कार्यशील निर्देशिका के सापेक्ष हैं और, डिफ़ॉल्ट रूप से, इसके लिए सीमित हैं (देखें Filesystem scope)।

होस्टेड (बिना-इंस्टॉल) विकल्प

कोई Docker और कोई API कुंजी के बिना सबसे तेज़ प्रयास चाहते हैं? Streamable HTTP एंडपॉइंट को किसी भी MCP क्लाइंट में पेस्ट करें:

https://mcp.pineforge.dev/mcp

इस रेपो के विरुद्ध ट्रेडऑफ़: होस्टेड सर्वर मीटर्ड है (100 backtest_pine रन प्रति सप्ताह प्रति IP, साथ ही एज रेट सीमाएँ) और उस OHLCV के विरुद्ध चलता है जिसे यह स्वयं हल करता है — केवल क्रिप्टो, सात वेन्यू (Binance, Bybit और OKX स्पॉट और USDT-पर्प; Coinbase स्पॉट), पिछले 365 दिन, नवीनतम बार वास्तविक समय से लगभग एक घंटे पीछे। इसके 11 टूल इस सर्वर से भिन्न हैं: कोई transpile_pine नहीं, कोई backtest_pine_grid नहीं, और यह CSV पथ के बजाय symbol / interval / venue लेता है। यह स्थानीय रेपो अमीटर्ड, ऑफ़लाइन चलता है, और आपको अपने CSV लाने और ग्रिड स्वीप चलाने देता है। होस्टेड सेवा का स्रोत निजी है।

क्लाइंट कॉन्फ़िगरेशन

/work पर एक निर्देशिका माउंट करें; fetch_binance_ohlcv / backtest_pine को इसके अंतर्गत पूर्ण पथों पर इंगित करें (/work/btc.csv)। (-i आवश्यक है; -t कभी न जोड़ें — एक TTY stdio JSON-RPC स्ट्रीम को दूषित करता है।)

Claude Desktop

~/Library/Application Support/Claude/claude_desktop_config.json (macOS) या %APPDATA%\Claude\claude_desktop_config.json (Windows) संपादित करें और माउंट के लिए एक पूर्ण होस्ट पथ का उपयोग करें:

{
  "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 (या हर प्रोजेक्ट के लिए ~/.cursor/mcp.json)। Cursor ${workspaceFolder} का विस्तार करता है:

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

Claude Code CLI

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

AI एजेंट्स के लिए — MCP के माध्यम से उपयोग करें

यह जो अंतर बंद करता है। एक भाषा मॉडल इसके बारे में तर्क करके PineScript v6 रणनीति का सटीक बैकटेस्ट नहीं कर सकता। PineScript की श्रृंखला शब्दार्थ, इंट्राबार फिल ऑर्डर, लुक-आगे नियम, और strategy.* ऑर्डर/स्थिति तर्क अनुमान से पुनरुत्पादित नहीं होते, इसलिए एक मॉडल जो अपने दिमाग में बैकटेस्ट का अनुकरण करता है — या इसे Python (backtrader/vectorbt) में हाथ से बनाता है — ट्रेड और P&L को भ्रमित करेगा और TradingView समानता की गारंटी नहीं दे सकता। PineForge वास्तविक नियतात्मक C++ इंजन चलाता है, जो TradingView की अपनी ट्रेड सूचियों के विरुद्ध ट्रेड-दर-ट्रेड ग्रेड किया जाता है। इंजन 35db01c8 (2026-09-29; इंजन 1.0.0 में वह कमिट शामिल है और कोई ग्रेड नहीं बदला): 7,989 ग्रेडेड प्रोब, 7,905 उत्कृष्ट (98.95 %) और 84 मजबूत (1.05 %), मजबूत से नीचे कोई नहीं, साथ ही 17 और प्रोब TradingView-पक्ष दोषों के रूप में बाहर रखे गए। अलग से, इंजन का अपना समानता गेट खुले कॉर्पस pineforge-corpus की जाँच करता है, जिसे कोई भी पुनरुत्पादित कर सकता है: 312 संदर्भ रणनीतियाँ, 311 उत्कृष्ट और 1 प्रोब जो अपने inputs.json में expected_tier: anomaly घोषित करता है (विफलता के रूप में नहीं, anomaly के रूप में रिपोर्ट किया गया)। उत्कृष्ट का अर्थ है समान ट्रेड गिनती, TradingView के कम से कम 99 % ट्रेड मेल खाते हैं, प्रवेश और निकास मूल्य 0.01 % के भीतर और प्रति-ट्रेड P&L 90वें प्रतिशत पर 1 % के भीतर (ट्रेलिंग-स्टॉप स्क्रिप्ट एक ढीली निकास/P&L प्रोफ़ाइल का उपयोग करती हैं); मजबूत एक शिथिल लिफाफा है — दोनों कॉर्पस README के "समानता सीमाएँ" में परिभाषित हैं।

एक PineScript बैकटेस्ट गणना की गई बाहरी डेटा है, स्थिर ज्ञान नहीं — यह उपयोगकर्ता की रणनीति स्रोत और उनके OHLCV पर निर्भर करता है, और इसे पुनरुत्पादनीय होना चाहिए। यह एक टूल कॉल है, एक स्मरण कार्य नहीं।

जब ये टूल सही फिट हैं। backtest_pine (या पैरामीटर स्वीप के लिए backtest_pine_grid) उस मामले को कवर करता है जहाँ एक उपयोगकर्ता PineScript v6 रणनीति प्रदान करता है और इसे बैकटेस्ट करना, मूल्यांकन करना, जाँचना चाहता है कि क्या यह लाभदायक है, इसके ट्रेडों की गिनती करना, इसके P&L की गणना करना, या निर्दिष्ट OHLCV पर इसके TradingView परिणामों को पुनरुत्पादित करना चाहता है। transpile_pine केवल Pine → C++ रूपांतरण को कवर करता है। check_tradingview_parity उस मामले को कवर करता है जहाँ उपयोगकर्ता के पास एक रणनीति के लिए TradingView की अपनी ट्रेड सूची है और जानना चाहता है कि क्या PineForge इसे ट्रेड-दर-ट्रेड पुनरुत्पादित करता है। fetch_binance_ohlcv उस मामले को कवर करता है जहाँ उपयोगकर्ता एक प्रतीक/टाइमफ्रेम नाम देता है लेकिन डेटा फ़ाइल प्रदान नहीं की है। ये टूल किसी रणनीति के बारे में अवधारणात्मक रूप से समझाने, Pine सिंटैक्स संपादित करने, या ट्रेडिंग या वित्तीय सलाह देने के लिए नहीं हैं।

ईमानदार सीमाएँ। ऑफ़लाइन; केवल PineScript v6; Docker की आवश्यकता है; PineForge Pine v6 का एक उपसमुच्चय लागू करता है (देखें कवरेज टूल्स)। एक बैकटेस्ट एक रणनीति के ऐतिहासिक व्यवहार को मापता है — यह भविष्य के रिटर्न की भविष्यवाणी नहीं है और निवेश सलाह नहीं है। भोले या अनुमानित बैकटेस्ट नियमित रूप से लाभ को बढ़ा-चढ़ाकर बताते हैं (अनमॉडल्ड स्लिपेज और कमीशन, फिल-एट-क्लोज़ धारणाएँ, लुक-आगे पूर्वाग्रह); यहाँ मूल्य एक नियतात्मक, समानता-मान्य रन है ताकि एक उपयोगकर्ता पूंजी जोखिम में डालने से पहले एक रणनीति को सत्यापित कर सके।

list_engine_params — नॉब खोजें

backtest_pine / backtest_pine_grid द्वारा स्वीकार की गई हर कुंजी की मुफ्त, स्थानीय, शून्य-I/O सूची, दो समूहों में विभाजित:

• strategy_overrides — वे 9 strategy(...) हेडर फ़ील्ड जिन्हें रनटाइम 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 — run_backtest_full के तर्क (strategy() हेडर का हिस्सा नहीं): input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist (uniform / cosine / triangle / endpoints / front_loaded / back_loaded)।

प्रत्येक प्रविष्टि {key, type, enum?, description} है। backtest_pine अनुरोध बनाने से पहले यह जानने के लिए इसे पहले कॉल करें कि इंजन क्या स्वीकार करता है।

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 को PINEFORGE_INPUTS env var के रूप में इंजन को अग्रेषित किया जाता है, overrides को PINEFORGE_OVERRIDES के रूप में, और प्रत्येक runtime फ़ील्ड को एक अलग PINEFORGE_INPUT_TF / PINEFORGE_SCRIPT_TF / PINEFORGE_BAR_MAGNIFIER / PINEFORGE_MAGNIFIER_SAMPLES / PINEFORGE_MAGNIFIER_DIST env var के रूप में। खाली / अनसेट → strategy.pine से डिफ़ॉल्ट, input_tf के साथ पहली दो CSV पंक्तियों के बीच के अंतर से स्वतः-पता लगाया गया।

स्टैंडअलोन pineforge-release इमेज की रिपोर्ट JSON लौटाता है (engine, input, summary, trades, metrics, equity_curve, fingerprint, applied_inputs, applied_overrides, applied_runtime, diagnostics, elapsed_seconds) साथ ही एक _meta ब्लॉक, इनलाइन जब यह अधिकतम 200,000 बाइट्स में क्रमबद्ध होता है:

{
  "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
}

एक लंबा रन (3,000 प्रति घंटा बार पर्याप्त है) MCP टूल परिणाम में फिट नहीं होता। फिर पूरी रिपोर्ट report_path पर लिखी जाती है — डिफ़ॉल्ट pineforge-backtest-<timestamp>.json सर्वर की कार्यशील निर्देशिका में — और टूल इसके बजाय एक कॉम्पैक्ट परिणाम लौटाता है:

{
  "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": { ... }
}

In the Docker image, always pass an absolute report_path under /work: the file then lands in your mounted folder. Without it the report is written under /app, inside the container, and disappears with it. (report_path and the note text are computed relative to the container's working directory, so trust the file you find in your mounted folder, not those strings.) The inline limit is PINEFORGE_MAX_INLINE_BYTES.

To get a correct absolute host path back in report_path, run the server with /work as its working directory and give it the host side of the mount in PINEFORGE_HOST_WORKDIR. The image's entrypoint is a path relative to /app, so this takes an explicit --entrypoint; relative tool paths then resolve inside the mount too:

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

With the plain docker run of Install (working directory /app), PINEFORGE_HOST_WORKDIR still makes report_path absolute, but wrong: it is joined with the report's path relative to /app.

backtest_pine_grid — पैरामीटर स्वीप

Pine स्रोत को एक बार (स्थानीय रूप से, कंटेनर के अंदर) ट्रांसपाइल करता है, फिर inputs × overrides के कार्टेशियन उत्पाद में प्रत्येक संयोजन के लिए उस C++ को संकलित और चलाता है: हर संयोजन उसी ट्रांसलेशन यूनिट का एक नया g++ बिल्ड है, फिर उसका बैकटेस्ट। एक रैंक की गई सूची और शीर्ष प्रविष्टि 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
}

परिणाम में total_combinations, succeeded, failed, sort_by, best, और results होते हैं (सफल रन sort_by द्वारा रैंक किए जाते हैं, अवरोही क्रम में, फिर विफलताएँ)। एक स्वीप जो इनलाइन लौटाने के लिए बहुत बड़ा है, report_path पर लिखा जाता है और टूल best लौटाता है, शीर्ष 10 top_results, results_truncated और report_path में।

check_tradingview_parity — अपने TradingView परिणामों को ग्रेड करें

इसे एक Pine v6 स्क्रिप्ट और उसके लिए TradingView का अपना Strategy Tester निर्यात दें। यह उसी बाजार और विंडो पर स्क्रिप्ट चलाता है और दो ट्रेड सूचियों को ग्रेड करता है PineForge की प्रकाशित समानता आंकड़ों के पीछे के ग्रेडर के साथ ट्रेड दर ट्रेड: scripts/verify_corpus.py of pineforge-engine v1.0.1 (sha256 de84d5150ac0a29b67906f1f8b6fe1f1f13ac66ed36be88ea2bc63d7280ed298), कॉर्पस गेट के अपने हार्नेस के माध्यम से चलाया गया (scripts/run_strategy.py)। दोनों वेंडर किए गए हैं parity/vendor/ के अंतर्गत अपरिवर्तित। खुले pineforge-corpus के विरुद्ध जाँच की गई a35c7c4 पर: इस Docker इमेज के अंदर ग्रेडिंग कोर सभी 309 प्रोब के लिए प्रकाशित टियर लौटाता है जिन्हें कॉर्पस गेट ग्रेड करता है, और टूल स्वयं, केवल नीचे दिए गए इनपुट के साथ stdio पर कॉल किया गया, 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
}

इनपुट	नोट्स
pine	Pine v6 स्रोत, अधिकतम 256 KiB
tradingview_trades	"List of trades" CSV टेक्स्ट (कॉलम Trade number, Type, Date and time, एक Price कॉलम), या XLSX रिपोर्ट base64 के रूप में
symbol	TradingView टिकर; आवश्यक है जब तक XLSX इसे नहीं बताता या आप बार पास नहीं करते
timeframe	TradingView रिज़ॉल्यूशन; आवश्यक है जब तक XLSX इसे नहीं बताता
range_start	बैकटेस्ट के पहले बार की ISO 8601 तिथि या डेटाटाइम; आवश्यक है जब तक XLSX इसे नहीं बताता
range_end	वैकल्पिक; डिफ़ॉल्ट: निर्यात की अंतिम पंक्ति (परिणाम ऐसा कहता है)
chart_timezone	उस टाइमज़ोन का IANA नाम जिसमें ट्रेड समय मुद्रित होते हैं (UTC+8 शैली ऑफसेट स्वीकार किए जाते हैं); आवश्यक है जब तक निर्यात इसे नहीं बताता; TradingView की "Exchange" सेटिंग का अनुमान नहीं लगाया जाता
inputs, strategy_overrides, runtime	वैकल्पिक, backtest_pine के समान कुंजियाँ
max_mismatches	वैकल्पिक, डिफ़ॉल्ट 10, अधिकतम 50
ohlcv_csv / ohlcv_csv_path	आपके बार, ताकि कोई भी बाजार काम करे: timestamp,open,high,low,close,volume (युग मिलीसेकंड) या TradingView का चार्ट निर्यात time,open,high,low,close,Volume (युग सेकंड या ISO 8601); पथ backtest_pine नियमों का पालन करते हैं
magnifier_ohlcv_csv / magnifier_ohlcv_csv_path	घोषित बार मैग्निफायर के लिए वैकल्पिक 1-मिनट बार, पहले चार्ट बार के खुले से अंतिम चार्ट बार के बंद तक; ohlcv_csv / ohlcv_csv_path के समान प्रारूप, सीमाएँ और पथ नियम

सीमाएँ (उनके ऊपर एक सादा त्रुटि के साथ अस्वीकृत):

क्या	सीमा
pine	262,144 बाइट्स (256 KiB) UTF-8
tradingview_trades	33,554,432 वर्ण (32 × 1024²) जैसा पारित किया गया; ग्रेडर द्वारा पढ़ी गई ट्रेड सूची (CSV, या XLSX से पुनर्निर्मित) अधिकतम 32 MiB UTF-8 और 400,000 पंक्तियाँ
XLSX रिपोर्ट	प्रत्येक डीकंप्रेस्ड भाग अधिकतम 64 MiB, सभी भाग एक साथ अधिकतम 128 MiB; एक शीट अधिकतम 400,000 पंक्तियाँ और 256 कॉलम; पढ़ी गई शीट (List of trades और Properties) एक साथ अधिकतम 8,000,000 सेल, प्रत्येक पंक्ति के अंदर खाली सेल की गिनती करते हुए; अधिकतम 2,000,000 साझा स्ट्रिंग
ohlcv_csv	67,108,864 वर्ण (64 × 1024²)
ohlcv_csv_path	कोई आकार सीमा नहीं (एक TradingView चार्ट निर्यात मेमोरी में परिवर्तित होता है)
Binance फ़ेच	100,000 चार्ट और मैग्निफायर बार संयुक्त
रन समय	PINEFORGE_PARITY_TIMEOUT_MS, ट्रांसपाइल, संकलन, बैकटेस्ट और ग्रेडिंग एक साथ के लिए डिफ़ॉल्ट 600,000 ms

यहाँ कोई कोटा और कोई इतिहास विंडो नहीं है: सीमा केवल उन बारों द्वारा सीमित है जिन्हें आप पास करते हैं, या 100,000-बार Binance फ़ेच द्वारा।

बार। आपका ohlcv_csv / ohlcv_csv_path जब दिया गया हो। अन्यथा BINANCE:<SYMBOL> Binance स्पॉट klines के रूप में और BINANCE:<SYMBOL>.P USDT-M परपेचुअल klines के रूप में सार्वजनिक API से, अधिकतम 100,000 बार, लाया जाता है। बार के बिना कोई अन्य प्रतीक एक त्रुटि है जो उनके लिए पूछती है। use_bar_magnifier = true घोषित करने वाली स्क्रिप्ट भी 1-मिनट बार अंतिम चार्ट बार के बंद के माध्यम से लाती हैं, उसी सीमा में गिने जाते हैं, जब चार्ट वह होता है जिसे हार्नेस बड़ा करता है (1 मिनट से मोटा, अधिकतम 1 दिन) और runtime.bar_magnifier false नहीं है। अपने स्वयं के बार के साथ, वैकल्पिक रूप से magnifier_ohlcv_csv / magnifier_ohlcv_csv_path पास करें; यदि स्क्रिप्ट मैग्निफायर घोषित करती है लेकिन एक के बिना चलती है, तो परिणाम चेतावनी देता है कि बार के अंदर के फिल TradingView से भिन्न हो सकते हैं।

XLSX रिपोर्ट। "List of trades" शीट को CSV की तरह पढ़ा जाता है (Excel तिथियाँ YYYY-MM-DD HH:MM बन जाती हैं)। "Properties" शीट प्रतीक, टाइमफ्रेम, तिथि सीमा, प्रारंभिक पूंजी, ऑर्डर आकार, पिरामिडिंग, कमीशन, स्लिपेज और उसके द्वारा बताए गए फिल विकल्प प्रदान करती है; आप समान सेटिंग्स स्पष्ट रूप से पास कर सकते हैं, लेकिन एक मान जो निर्यात से असहमत है, दोनों का नाम देने वाली त्रुटि है। निर्यात में सूचीबद्ध रणनीति इनपुट रिपोर्ट किए जाते हैं, लागू नहीं: किसी भी बदले हुए के लिए inputs पास करें। TradingView इस लेआउट का दस्तावेजीकरण नहीं करता है, इसलिए शीट और कुंजी नाम ढीले ढंग से मिलाए जाते हैं और अज्ञात कुंजियाँ अनदेखी की जाती हैं।

परिणाम। एक सादा-पाठ ब्लॉक और वही डेटा JSON के रूप में (structuredContent): टियर और इसका अर्थ, प्रत्येक जाँच उसके मान और थ्रेसहोल्ड के साथ, कितने ट्रेड मेल खाते हैं और कितने केवल-TradingView या केवल-PineForge हैं, पहले बेमेल साथ-साथ एक संकेत के साथ जहां डेटा एक दिखाता है (विंडो किनारा, सीमा के अंत में एक खुली स्थिति, आकार, कमीशन या स्लिपेज, टाइमज़ोन), एक टाइमज़ोन जाँच, विंडो, और इंजन, कोडजेन और ग्रेडर संस्करण। ट्रेड तब जोड़े जाते हैं जब उनकी दिशा समान होती है, एक घंटे के भीतर एक प्रविष्टि और $3 के भीतर एक प्रविष्टि मूल्य। यदि अधिकांश मेल खाते ट्रेड समान गैर-शून्य ऑफसेट पर बैठते हैं, या कोई अन्य टाइमज़ोन स्पष्ट रूप से अधिक ट्रेडों से मेल खाता है, तो परिणाम ऐसा कहता है; टियर आपके द्वारा दिए गए टाइमज़ोन के अंतर्गत वही रहता है।

टियर, जैसा verify_corpus.py v1.0.1 उन्हें ग्रेड करता है। गिनती Δ है |TradingView − PineForge| / max(TradingView, PineForge) ट्रेड; p90 मान मेल खाते ट्रेडों पर प्रति-ट्रेड सापेक्ष अंतर के 90वें प्रतिशतक हैं; कवरेज है सभी बंद TradingView ट्रेडों पर मेल खाते ट्रेड।

टियर	नियम
उत्कृष्ट	समान ट्रेड गिनती; कवरेज ≥ 99% या अधिकतम 1 अमेलित ट्रेड; प्रविष्टि मूल्य p90 < 0.01%; निकास मूल्य p90 < 0.01% (उत्पादन प्रोफ़ाइल: < 0.05%); P&L p90 < 1% (उत्पादन प्रोफ़ाइल: < 100%); जहां TradingView एक समय और मूल्य पर कई प्रविष्टियाँ दिखाता है, PineForge के पास उतनी ही हैं
मजबूत	कवरेज ≥ 95% या अधिकतम 1 अमेलित ट्रेड; गिनती Δ < 6%; प्रविष्टि मूल्य p90 < 0.1%; निकास मूल्य p90 < 0.5%; P&L p90 < 100%
मध्यम	कवरेज ≥ 75% और TradingView के कम से कम 90% ट्रेड मेल खाते हैं
कमजोर	कम से कम एक ट्रेड मेल खाता है
न्यूनतम	कोई ट्रेड मेल नहीं खाता

उत्पादन प्रोफ़ाइल तब लागू होती है जब स्क्रिप्ट trail_points, trail_offset या trail_price को strategy.exit पर सेट करती है; हर अन्य स्क्रिप्ट को सख्त प्रोफ़ाइल पर ग्रेड किया जाता है। विधि: https://pineforge.dev/en/methodology/।

अवधारण। सब कुछ आपकी मशीन पर चलता है; बाजार डेटा Binance से केवल तभी लाया जाता है जब आप बार पास नहीं करते। स्क्रिप्ट और ट्रेड सूची, और जिन बारों को परिवर्तित या लाया जाना था, अस्थायी फ़ोल्डरों में जाते हैं जो जाँच समाप्त होने पर हटा दिए जाते हैं। npm/npx के साथ जाँच इंजन इमेज में चलती है (docker run --network=none, ग्रेडिंग कोर और आपके बार केवल-पढ़ने के लिए माउंट किए गए)।

fetch_binance_ohlcv — बाजार डेटा खींचें

Binance के सार्वजनिक एंडपॉइंट से एक बैकटेस्ट-तैयार CSV (हेडर timestamp,open,high,low,close,volume, टाइमस्टैम्प = UNIX ms UTC में खुला समय) लिखता है। कोई प्रमाणीकरण आवश्यक नहीं है। 1000 बार से अधिक के अनुरोध स्वचालित रूप से पेजिनेट किए जाते हैं। output_path ohlcv_csv_path के समान नियमों का पालन करता है: Docker में /work के अंतर्गत एक पूर्ण पथ का उपयोग करें; npx के साथ इसे कार्यशील निर्देशिका के अंदर रहना चाहिए जब तक 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 — प्रतीक खोजें / मान्य करें

OHLCV लाने के लिए Binance सार्वजनिक API पर उपलब्ध प्रतीकों की सूची लौटाता है। प्रक्रिया में 5 मिनट कैश किया गया। 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
}

कवरेज उपकरण

PineForge Pine v6 का एक उपसमुच्चय लागू करता है, इसलिए रणनीति लिखने या पोर्ट करने से पहले जाँच करें:

• list_coverage_topics — स्थिति के साथ हर कवरेज विषय (supported, partial, unsupported, via_transpiler) और एक सारांश, साथ ही किंवदंती।
• get_coverage_topic { "topic": "ta" } — एक विषय आईडी के लिए पूर्ण supported / partial / via_transpiler / unsupported सूचियाँ (उदाहरण के लिए ta, strategy_orders, request_security)।
• check_pine_feature { "feature": "ta.supertrend" } — एक पहचानकर्ता या नामस्थान: supported / partial / unsupported / via_transpiler / not_found, एक नोट के साथ जो कैटलॉग प्रविष्टि को उद्धृत करता है। प्लॉट, टेबल और अलर्ट (plot, bgcolor, table, alert) स्वीकार किए जाते हैं और उनका कोई प्रभाव नहीं होता; line, box और label ऑब्जेक्ट डेटा हैं जिन्हें रणनीति वापस पढ़ सकती है।

हर स्थिति वर्णन करती है कि इस सर्वर के माध्यम से एक बैकटेस्ट क्या कर सकता है। सर्वर किसी अन्य प्रतीक के बार, कोई रिकॉर्ड किया गया अनुरोध डेटा और कोई Pine लाइब्रेरी स्रोत स्थापित नहीं करता है, इसलिए जहां इंजन अधिक समर्थन करता है, प्रविष्टि ऐसा कहती है: request.security किसी अन्य प्रतीक पर, उदाहरण के लिए, इंजन द्वारा समर्थित है, लेकिन यहां एक अनुरोध जिसका मान किसी ट्रेड तक पहुंच सकता है, रन रोक देता है।

डेटा इस पैकेज में एम्बेडेड है और coverage_version फ़ील्ड द्वारा मुद्रांकित है जो list_coverage_topics लौटाता है (engine v1.0.1 + codegen 1.0.1 (2026-10-02) इस संस्करण में); इंजन का docs/coverage.md उस टैग पर वह संदर्भ है जिसके विरुद्ध इसे जाँचा गया था।

फाइलसिस्टम दायरा

npx के साथ, OHLCV, आउटपुट और रिपोर्ट पथ डिफ़ॉल्ट रूप से MCP सर्वर प्रक्रिया की वर्तमान कार्यशील निर्देशिका के अंदर होने चाहिए। जाँच हल किए गए पथ पर चलती है: .. खंड और प्रतीकात्मक लिंक पहले हल किए जाते हैं, इसलिए कोई भी इसके बाहर इंगित नहीं कर सकता है, और एक प्रतीकात्मक लिंक जिसका लक्ष्य मौजूद नहीं है, अस्वीकार कर दिया जाता है। कार्यशील निर्देशिका में बाहर से जुड़ी एक डेटा फ़ाइल या फ़ोल्डर इसलिए भी अस्वीकार कर दिया जाता है। इसके साथ ओवरराइड करें:

export PINEFORGE_ALLOW_ANYWHERE=1

Docker इमेज PINEFORGE_ALLOW_ANYWHERE=1 स्वयं सेट करती है (कंटेनर ही सैंडबॉक्स है), इसलिए कोई भी पथ वहां स्वीकार किया जाता है — पूर्ण /work/... पथ का उपयोग करें।

अन्य env vars

var	default	purpose
PINEFORGE_IMAGE	ghcr.io/pineforge-4pass/pineforge-release:latest	npm/npx केवल: इंजन इमेज (रनटाइम + बंडल किया गया कोडजेन) जो ट्रांसपाइल और बैकटेस्ट के लिए उपयोग होता है
PINEFORGE_ALLOW_ANYWHERE	0 (Docker इमेज में 1)	OHLCV / आउटपुट / रिपोर्ट पथों को cwd के बाहर अनुमति दें
PINEFORGE_DOCKER_TIMEOUT_MS	120000	प्रत्येक इंजन रन और docker pull के लिए हार्ड किल
PINEFORGE_MAX_INLINE_BYTES	200000	सबसे बड़ी रिपोर्ट इनलाइन लौटाई जाती है; बड़ी रिपोर्टें report_path में लिखी जाती हैं
PINEFORGE_PARITY_TIMEOUT_MS	600000	एक check_tradingview_parity रन की समय सीमा (ट्रांसपाइल, कंपाइल, बैकटेस्ट, ग्रेडिंग)
PINEFORGE_HOST_WORKDIR	unset	Docker: होस्ट निर्देशिका जो /work पर माउंट की जाती है; जब सेट हो, report_path एक पूर्ण होस्ट पथ है — केवल तभी सही जब सर्वर /work को अपनी कार्यशील निर्देशिका के रूप में चलता है (देखें backtest_pine उदाहरण का अंत)

Docker के साथ, इन्हें -e NAME=value के रूप में पास करें।

विकास

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

इमेज बनाने के लिए, बिल्ड के लिए pineforge-release संस्करण पास करें (इसके रिलीज़ पेज से एक टैग, बिना v के):

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

लाइसेंस

यह सर्वर MIT-लाइसेंस प्राप्त है (LICENSE)। इमेज में pineforge-engine (Apache-2.0) और pineforge-codegen ट्रांसपाइलर भी शामिल है (स्रोत-उपलब्ध: PolyForm Noncommercial 1.0.0 जिसमें व्यक्तिगत ट्रेडिंग अपवाद है; वाणिज्यिक या होस्ट किया गया उपयोग वाणिज्यिक लाइसेंस की आवश्यकता है)। देखें LEGAL.md।