PineForge Codegen

@pineforge/backtest-mcp

Servidor MCP stdio autocontenido: un agente de IA escribe PineScript v6, y la imagen pineforge-release incluida lo transpila a C++ y realiza un backtest contra un CSV OHLCV (el tuyo propio, o uno obtenido de la API pública de Binance), todo en un solo contenedor, en proceso. Totalmente local — la imagen incluye el transpilador pineforge-codegen, por lo que Pine → C++ → backtest se ejecutan sin demonio Docker del host. Sin clave API. Tu código fuente de la estrategia y tus CSVs nunca salen de la máquina; solo las herramientas de Binance, y check_tradingview_parity cuando no pasas barras, realizan solicitudes salientes (endpoints públicos).

Herramientas

nombre	se ejecuta en	propósito
transpile_pine	en proceso	Pine v6 → unidad de traducción C++ (solo transpilación)
list_engine_params	local (sin E/S)	Catálogo de cada parámetro overrides + runtime aceptado por los backtests
backtest_pine	en proceso	Backtest único de un código Pine contra un CSV OHLCV
backtest_pine_grid	en proceso	Barrido cartesiano de inputs × overrides: una transpilación, luego una compilación y un backtest por combinación
check_tradingview_parity	en proceso (solo API pública de Binance sin tus barras)	Califica tu exportación del Strategy Tester de TradingView contra la ejecución de PineForge del mismo script, operación por operación
fetch_binance_ohlcv	API pública de Binance	Escribe un CSV listo para backtest desde klines de spot o USDT-perp de Binance
binance_symbols	API pública de Binance	Lista / filtra símbolos de Binance (caché en proceso de 5 minutos)
list_coverage_topics	local (sin E/S)	Cada tema de cobertura de Pine v6 con un estado de una línea + resumen
check_pine_feature	local (sin E/S)	Consulta si un identificador/espacio de nombres de Pine es compatible con PineForge
get_coverage_topic	local (sin E/S)	Detalle completo + listas de compatible/parcial/vía_transpilador/no compatible para un tema
engine_info	local (sin E/S)	Solo imagen Docker: modo, indicador integrado y la versión pineforge-release incluida (por ejemplo 1.0.0)

La tabla es la lista de herramientas de la imagen Docker (11 herramientas). El paquete npm sirve las primeras diez, más pull_engine_image (docker pull la imagen del motor) y check_engine_image en lugar de engine_info (12 herramientas).

En tools/list cada herramienta también tiene un título y las cuatro pistas de anotación MCP (src/tool-meta.ts). Solo lectura: las búsquedas y check_tradingview_parity (funciona en un directorio temporal que elimina), y en la imagen Docker transpile_pine. No solo lectura: backtest_pine y backtest_pine_grid (un informe demasiado grande para devolverlo se escribe en un archivo), fetch_binance_ohlcv (escribe su CSV) y las dos herramientas de imagen; en el paquete npm también transpile_pine, ya que allí él y los backtests toman un image que Docker descarga cuando falta. Destructivas: las herramientas que escriben un archivo en una ruta que tú nombras, ya que reemplazan un archivo ya existente. De mundo abierto: las herramientas que acceden a la API pública de Binance o a un registro de imágenes.

Instalación

Se ejecuta como un contenedor autocontenido sobre stdio — motor incluido, en proceso, sin demonio Docker del host, sin clave API. Monta la carpeta que contiene tus CSVs en /work:

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

Único requisito: Docker, y red saliente para las herramientas de descarga de Binance. Conéctalo a tu cliente MCP a continuación.

• Usa rutas /work/... absolutas en los argumentos de las herramientas (ohlcv_csv_path, output_path, report_path). El directorio de trabajo del servidor dentro del contenedor es /app, no el montaje, por lo que una ruta relativa como ./btc.csv apunta dentro del contenedor y se pierde cuando este sale (--rm).
• En Linux, agrega --user "$(id -u):$(id -g)" para que los archivos que el servidor escribe en /work tengan tu propiedad.
• -i es obligatorio; nunca agregues -t — una TTY corrompe el flujo JSON-RPC de stdio.

El :latest de la imagen y el latest de npm siempre llevan una versión estable. Una versión preliminar pineforge-release (como 1.0.0-rc.1) produce una versión preliminar de este servidor (X.Y.Z-alpha.N, -beta.N o -rc.N): la imagen :vX.Y.Z-rc.N, construida FROM esa versión preliminar pineforge-release, y npm @pineforge/backtest-mcp@next, que, como cualquier instalación npm, ejecuta la imagen del motor nombrada por PINEFORGE_IMAGE (por defecto ghcr.io/pineforge-4pass/pineforge-release:latest, el motor estable). Las versiones preliminares no se listan en el Registro MCP. La primera, 0.9.32-rc.1 en pineforge-release 1.0.0-rc.1, se publicó el 2026-09-30 (imagen :v0.9.32-rc.1, npm next).

npm / npx

npx -y @pineforge/backtest-mcp

Requiere Node ≥ 20 y un demonio Docker en ejecución: cada transpilación y backtest es un docker run --rm --network=none de la imagen del motor (PINEFORGE_IMAGE, por defecto ghcr.io/pineforge-4pass/pineforge-release:latest). docker pull primero: la descarga propia del servidor (implícita en la primera llamada, o pull_engine_image) se corta después de PINEFORGE_DOCKER_TIMEOUT_MS (120 s por defecto). Las rutas son relativas al directorio de trabajo del servidor y, por defecto, confinadas a él (consulta Alcance del sistema de archivos).

Alternativa alojada (sin instalación)

¿Quieres la prueba más rápida sin Docker y sin clave API? Pega el endpoint Streamable HTTP en cualquier cliente MCP:

https://mcp.pineforge.dev/mcp

Compensación frente a este repositorio: el servidor alojado está medido (100 ejecuciones backtest_pine por semana por IP, más límites de tasa en el borde) y se ejecuta contra OHLCV que él mismo resuelve — solo cripto, siete exchanges (spot y USDT-perp de Binance, Bybit y OKX; spot de Coinbase), los últimos 365 días, la barra más reciente aproximadamente una hora detrás del tiempo real. Sus 11 herramientas difieren de las de este servidor: sin transpile_pine, sin backtest_pine_grid, y toma symbol / interval / venue en lugar de una ruta CSV. Este repositorio local es sin medición, funciona sin conexión y te permite traer tus propios CSVs y ejecutar barridos de cuadrícula. El código fuente del servicio alojado es privado.

Configuración del cliente

Monta un directorio en /work; apunta fetch_binance_ohlcv / backtest_pine a rutas absolutas debajo de él (/work/btc.csv). (-i es obligatorio; nunca agregues -t — una TTY corrompe el flujo JSON-RPC de stdio.)

Claude Desktop

Edita ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json (Windows) y usa una ruta absoluta del host para el montaje:

{
  "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 en el proyecto (o ~/.cursor/mcp.json para cada proyecto). Cursor expande ${workspaceFolder}:

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

CLI de Claude Code

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

Para agentes de IA — usa mediante MCP

La brecha de capacidad que esto cierra. Un modelo de lenguaje no puede hacer un backtest preciso de una estrategia PineScript v6 razonando sobre ella. La semántica de series de PineScript, el orden de llenado intrabarra, las reglas de look-ahead y la lógica de orden/posición strategy.* no se reproducen por aproximación, por lo que un modelo que simula un backtest en su cabeza — o lo hace a mano en Python (backtrader/vectorbt) — alucinará operaciones y P&L y no puede garantizar paridad con TradingView. PineForge ejecuta el motor C++ determinista real en su lugar, calificado operación por operación contra las propias listas de operaciones de TradingView. En el motor 35db01c8 (2026-09-29; el motor 1.0.0 incluye ese commit y no cambió ninguna calificación): 7,989 sondas calificadas, 7,905 excelentes (98.95 %) y 84 fuertes (1.05 %), ninguna por debajo de fuerte, más 17 sondas adicionales excluidas como defectos del lado de TradingView. Por separado, la propia puerta de paridad del motor verifica el corpus abierto pineforge-corpus, que cualquiera puede reproducir: 312 estrategias de referencia, 311 excelentes y 1 sonda que declara expected_tier: anomaly en su inputs.json (reportada como anomaly, no como un fallo). Excelente significa el mismo número de operaciones, al menos el 99 % de las operaciones de TradingView coincidentes, precios de entrada y salida dentro del 0.01 % y P&L por operación dentro del 1 % en el percentil 90 (los scripts con trailing-stop usan un perfil de salida/P&L más flexible); fuerte es un envolvente más relajado — ambos están definidos en el README del corpus en "Umbrales de paridad".

Un backtest de PineScript es dato externo calculado, no conocimiento estable — depende del código fuente de la estrategia del usuario y de su OHLCV, y debe ser reproducible. Eso es una llamada a herramienta, no una tarea de recuerdo.

Cuándo estas herramientas son la opción correcta. backtest_pine (o backtest_pine_grid para un barrido de parámetros) cubre el caso donde un usuario proporciona una estrategia PineScript v6 y quiere hacerle backtest, evaluarla, verificar si es rentable, contar sus operaciones, calcular su P&L o reproducir sus resultados de TradingView en OHLCV especificado. transpile_pine cubre solo la conversión Pine → C++. check_tradingview_parity cubre el caso donde el usuario tiene la propia lista de operaciones de TradingView para una estrategia y quiere saber si PineForge la reproduce, operación por operación. fetch_binance_ohlcv cubre el caso donde el usuario nombra un símbolo/marco temporal pero no ha proporcionado un archivo de datos. Estas herramientas no son para explicar conceptualmente qué hace una estrategia, editar sintaxis de Pine o dar consejos de trading o financieros.

Límites honestos. Sin conexión; solo PineScript v6; necesita Docker; PineForge implementa un subconjunto de Pine v6 (consulta Herramientas de cobertura). Un backtest mide el comportamiento histórico de una estrategia — no es una predicción de retornos futuros ni consejo de inversión. Los backtests ingenuos o aproximados rutinariamente sobreestiman las ganancias (slippage y comisiones no modelados, supuestos de llenado al cierre, sesgo de look-ahead); el valor aquí es una ejecución determinista y validada por paridad para que un usuario pueda verificar una estrategia antes de arriesgar capital.

list_engine_params — descubre parámetros

Catálogo gratuito, local y sin E/S de cada clave aceptada por backtest_pine / backtest_pine_grid, dividido en dos grupos:

• strategy_overrides — los 9 campos de cabecera strategy(...) que el runtime lee mediante 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 — argumentos para run_backtest_full (NO parte de la cabecera strategy()): input_tf, script_tf, bar_magnifier, magnifier_samples, magnifier_dist (uniform / cosine / triangle / endpoints / front_loaded / back_loaded).

Cada entrada es {key, type, enum?, description}. Llama a esto primero para aprender qué acepta el motor antes de componer una solicitud backtest_pine.

Ejemplo de 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 se reenvía como la variable de entorno PINEFORGE_INPUTS al motor, overrides como PINEFORGE_OVERRIDES, y cada campo runtime como una variable de entorno PINEFORGE_INPUT_TF / PINEFORGE_SCRIPT_TF / PINEFORGE_BAR_MAGNIFIER / PINEFORGE_MAGNIFIER_SAMPLES / PINEFORGE_MAGNIFIER_DIST separada. Vacío / sin establecer → valores por defecto de strategy.pine, con input_tf auto-detectado desde el espacio entre las dos primeras filas del CSV.

Devuelve el JSON de informe de la imagen independiente pineforge-release (engine, input, summary, trades, metrics, equity_curve, fingerprint, applied_inputs, applied_overrides, applied_runtime, diagnostics, elapsed_seconds) más un bloque _meta, en línea cuando se serializa a como máximo 200,000 bytes:

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

Una ejecución larga (3,000 barras horarias son suficientes) no cabe en un resultado de herramienta MCP. Entonces el informe completo se escribe en report_path — por defecto pineforge-backtest-<timestamp>.json en el directorio de trabajo del servidor — y la herramienta devuelve un resultado compacto en su lugar:

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

En la imagen de Docker, pasa siempre una report_path absoluta bajo /work: el archivo entonces aterriza en tu carpeta montada. Sin ella, el informe se escribe bajo /app, dentro del contenedor, y desaparece con él. (report_path y el texto note se calculan relativos al directorio de trabajo del contenedor, así que confía en el archivo que encuentres en tu carpeta montada, no en esas cadenas.) El límite en línea es PINEFORGE_MAX_INLINE_BYTES.

Para obtener una ruta de host absoluta correcta de vuelta en report_path, ejecuta el servidor con /work como su directorio de trabajo y dale el lado del host del montaje en PINEFORGE_HOST_WORKDIR. El entrypoint de la imagen es una ruta relativa a /app, así que esto toma un --entrypoint explícito; las rutas de herramientas relativas entonces se resuelven dentro del montaje también:

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

Con el docker run simple de Install (directorio de trabajo /app), PINEFORGE_HOST_WORKDIR todavía hace report_path absoluto, pero incorrecto: se une con la ruta del informe relativa a /app.

backtest_pine_grid — barrido de parámetros

Transpila el código fuente de Pine una vez (localmente, en el contenedor), luego compila y ejecuta ese C++ para cada combinación en el producto cartesiano de inputs × overrides: cada combinación es una compilación g++ nueva de la misma unidad de traducción, luego su backtest. Devuelve una lista clasificada más la entrada superior bajo 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
}

El resultado tiene total_combinations, succeeded, failed, sort_by, best y results (ejecuciones exitosas clasificadas por sort_by, descendente, luego fallos). Un barrido demasiado grande para devolverlo en línea se escribe en report_path y la herramienta devuelve best, los 10 principales en top_results, results_truncated y report_path.

check_tradingview_parity — califica tus resultados de TradingView

Dale un script de Pine v6 y la exportación del propio Strategy Tester de TradingView para él. Ejecuta el script en el mismo mercado y ventana y califica las dos listas de operaciones operación por operación con el calificador detrás de las cifras de paridad publicadas de PineForge: scripts/verify_corpus.py de pineforge-engine v1.0.1 (sha256 de84d5150ac0a29b67906f1f8b6fe1f1f13ac66ed36be88ea2bc63d7280ed298), ejecutado a través del propio harness de la puerta del corpus (scripts/run_strategy.py). Ambos están incluidos sin cambios bajo parity/vendor/. Verificado contra el pineforge-corpus abierto en a35c7c4: dentro de esta imagen de Docker el núcleo de calificación devuelve el nivel publicado para las 309 sondas que la puerta del corpus califica, y la herramienta misma, llamada sobre stdio con solo las entradas a continuación, lo devuelve para una muestra estratificada 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
}

entrada	notas
pine	Código fuente de Pine v6, como máximo 256 KiB
tradingview_trades	Texto CSV de "Lista de operaciones" (columnas Trade number, Type, Date and time, una columna Price), o el informe XLSX como base64
symbol	Ticker de TradingView; requerido a menos que el XLSX lo indique o pases barras
timeframe	Resolución de TradingView; requerida a menos que el XLSX la indique
range_start	Fecha u hora ISO 8601 de la primera barra del backtest; requerida a menos que el XLSX la indique
range_end	opcional; predeterminado: la última fila de la exportación (el resultado lo dice)
chart_timezone	Nombre IANA de la zona horaria en la que se imprimen los tiempos de operación (se aceptan compensaciones de estilo UTC+8); requerido a menos que la exportación lo indique; el ajuste "Exchange" de TradingView no se adivina
inputs, strategy_overrides, runtime	opcional, las mismas claves que backtest_pine
max_mismatches	opcional, predeterminado 10, como máximo 50
ohlcv_csv / ohlcv_csv_path	tus barras, para que cualquier mercado funcione: timestamp,open,high,low,close,volume (ms de época) o la exportación de gráfico de TradingView time,open,high,low,close,Volume (segundos de época o ISO 8601); las rutas siguen las reglas de backtest_pine
magnifier_ohlcv_csv / magnifier_ohlcv_csv_path	barras de 1 minuto opcionales para un magnificador de barras declarado, que cubren la apertura de la primera barra del gráfico hasta el cierre de la última barra del gráfico; mismos formatos, límites y reglas de ruta que ohlcv_csv / ohlcv_csv_path

Límites (rechazados con un error simple por encima de ellos):

qué	límite
pine	262,144 bytes (256 KiB) de UTF-8
tradingview_trades	33,554,432 caracteres (32 × 1024²) como se pasa; la lista de operaciones que lee el calificador (el CSV, o la reconstruida desde el XLSX) como máximo 32 MiB de UTF-8 y 400,000 filas
Informe XLSX	cada parte descomprimida como máximo 64 MiB, todas las partes juntas como máximo 128 MiB; una hoja como máximo 400,000 filas y 256 columnas; las hojas leídas (Lista de operaciones y Propiedades) como máximo 8,000,000 celdas juntas, contando las celdas vacías dentro de cada fila; como máximo 2,000,000 cadenas compartidas
ohlcv_csv	67,108,864 caracteres (64 × 1024²)
ohlcv_csv_path	sin límite de tamaño (una exportación de gráfico de TradingView se convierte en memoria)
Obtención de Binance	100,000 barras de gráfico y magnificador combinadas
tiempo de ejecución	PINEFORGE_PARITY_TIMEOUT_MS, predeterminado 600,000 ms para transpilación, compilación, backtest y calificación juntos

No hay cuota ni ventana de historial aquí: el rango está limitado solo por las barras que pases, o por la obtención de Binance de 100,000 barras.

Barras. Tus ohlcv_csv / ohlcv_csv_path cuando se dan. De lo contrario, BINANCE:<SYMBOL> se obtiene como klines spot de Binance y BINANCE:<SYMBOL>.P como klines perpetuos USDT-M, de la API pública, como máximo 100,000 barras. Cualquier otro símbolo sin barras es un error que las pide. Los scripts que declaran use_bar_magnifier = true también obtienen barras de 1 minuto hasta el cierre de la última barra del gráfico, contadas en el mismo límite, cuando el gráfico es uno que el harness magnifica (más grueso que 1 minuto, como máximo 1 día) y runtime.bar_magnifier no es false. Con tus propias barras, opcionalmente pasa magnifier_ohlcv_csv / magnifier_ohlcv_csv_path; si el script declara el magnificador pero se ejecuta sin uno, el resultado advierte que los rellenos dentro de las barras pueden diferir de los de TradingView.

Informe XLSX. La hoja "Lista de operaciones" se lee como se leería el CSV (las fechas de Excel se convierten en YYYY-MM-DD HH:MM). La hoja "Propiedades" suministra el símbolo, el marco temporal, el rango de fechas, el capital inicial, el tamaño de orden, la piramidación, la comisión, el deslizamiento y las opciones de relleno que indica; puedes pasar la misma configuración explícitamente, pero un valor que no esté de acuerdo con la exportación es un error que nombra ambos. Las entradas de estrategia listadas en la exportación se informan, no se aplican: pasa inputs para cualquier que hayas cambiado. TradingView no documenta este diseño, por lo que los nombres de hojas y claves se comparan de manera flexible y las claves desconocidas se ignoran.

Resultado. Un bloque de texto plano y los mismos datos como JSON (structuredContent): el nivel y lo que significa, cada verificación con su valor y umbrales, cuántas operaciones coincidieron y cuántas son solo de TradingView o solo de PineForge, los primeros desajustes lado a lado con una pista donde los datos muestran uno (borde de ventana, una posición abierta al final del rango, tamaño, comisión o deslizamiento, zona horaria), una verificación de zona horaria, la ventana y las versiones del motor, codegen y calificador. Las operaciones se emparejan cuando tienen la misma dirección, una entrada dentro de una hora y un precio de entrada dentro de $3. Si la mayoría de las operaciones coincidentes se encuentran en el mismo desplazamiento no nulo, u otra zona horaria coincide claramente con más operaciones, el resultado lo dice; el nivel permanece el de la zona horaria que diste.

Niveles, como los califica verify_corpus.py v1.0.1. El conteo Δ es |TradingView − PineForge| / max(TradingView, PineForge) operaciones; los valores p90 son percentiles 90 de diferencias relativas por operación sobre operaciones coincidentes; la cobertura es operaciones coincidentes sobre todas las operaciones cerradas de TradingView.

nivel	regla
excelente	conteos de operaciones iguales; cobertura ≥ 99 % o como máximo 1 operación sin coincidir; p90 de precio de entrada < 0.01 %; p90 de precio de salida < 0.01 % (perfil de producción: < 0.05 %); p90 de P&L < 1 % (perfil de producción: < 100 %); donde TradingView muestra varias entradas en un tiempo y precio, PineForge tiene tantas
fuerte	cobertura ≥ 95 % o como máximo 1 operación sin coincidir; conteo Δ < 6 %; p90 de precio de entrada < 0.1 %; p90 de precio de salida < 0.5 %; p90 de P&L < 100 %
moderado	cobertura ≥ 75 % y al menos 90 % de las operaciones de TradingView coinciden
débil	al menos una operación coincide
mínimo	ninguna operación coincide

El perfil de producción se aplica cuando el script establece trail_points, trail_offset o trail_price en strategy.exit; cada otro script se califica con el perfil estricto. Método: https://pineforge.dev/en/methodology/.

Retención. Todo se ejecuta en tu máquina; los datos de mercado se obtienen de Binance solo cuando no pasas barras. El script y la lista de operaciones, y las barras que tuvieron que convertirse u obtenerse, van a carpetas temporales que se eliminan cuando la verificación termina. Con npm/npx la verificación se ejecuta en la imagen del motor (docker run --network=none, el núcleo de calificación y tus barras montadas de solo lectura).

fetch_binance_ohlcv — obtener datos de mercado

Escribe un CSV listo para backtest (encabezado timestamp,open,high,low,close,volume, timestamp = tiempo de apertura en ms UNIX UTC) desde los endpoints públicos de Binance. Sin autenticación requerida. Las solicitudes > 1000 barras se paginan automáticamente. output_path sigue las mismas reglas que ohlcv_csv_path: en Docker usa una ruta absoluta bajo /work; con npx debe permanecer dentro del directorio de trabajo a menos que 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 — descubrir / validar símbolos

Devuelve la lista de símbolos disponibles en la API pública de Binance para la obtención de OHLCV. Cacheado 5 min en el proceso. Úsalo para validar un símbolo antes de llamar a 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
}

Herramientas de cobertura

PineForge implementa un subconjunto de Pine v6, así que verifica antes de escribir o portar una estrategia:

• list_coverage_topics — cada tema de cobertura con un estado (supported, partial, unsupported, via_transpiler) y un resumen, más la leyenda.
• get_coverage_topic { "topic": "ta" } — las listas completas de supported / partial / via_transpiler / unsupported para un id de tema (por ejemplo ta, strategy_orders, request_security).
• check_pine_feature { "feature": "ta.supertrend" } — un identificador o espacio de nombres: supported / partial / unsupported / via_transpiler / not_found, con una nota que cita la entrada del catálogo. Los plots, tablas y alertas (plot, bgcolor, table, alert) se aceptan y no tienen efecto; los objetos line, box y label son datos que la estrategia puede leer de vuelta.

Cada estado describe lo que un backtest a través de este servidor puede hacer. El servidor no instala barras de ningún otro símbolo, datos de solicitud registrados ni fuentes de bibliotecas de Pine, así que donde el motor soporta más, la entrada lo dice: request.security en otro símbolo, por ejemplo, es soportado por el motor, pero aquí una solicitud cuyo valor puede alcanzar una operación detiene la ejecución.

Los datos están incrustados en este paquete y sellados por el campo coverage_version que list_coverage_topics devuelve (engine v1.0.1 + codegen 1.0.1 (2026-10-02) en esta versión); el docs/coverage.md del motor en esa etiqueta es la referencia contra la que se verificó.

Alcance del sistema de archivos

Con npx, las rutas de OHLCV, salida e informe deben estar dentro del directorio de trabajo actual del proceso del servidor MCP por defecto. La verificación se ejecuta en la ruta resuelta: los segmentos .. y los enlaces simbólicos se resuelven primero, así que ninguno puede apuntar fuera de él, y un enlace simbólico cuyo destino no existe se rechaza. Un archivo de datos o carpeta enlazada al directorio de trabajo desde fuera de él se rechaza también. Anula con:

export PINEFORGE_ALLOW_ANYWHERE=1

La imagen de Docker establece PINEFORGE_ALLOW_ANYWHERE=1 por sí misma (el contenedor es el sandbox), así que cualquier ruta se acepta allí — usa rutas /work/... absolutas.

Otras variables de entorno

var	default	purpose
PINEFORGE_IMAGE	ghcr.io/pineforge-4pass/pineforge-release:latest	solo npm/npx: imagen del motor (runtime + codegen incluido) usada para transpilar y hacer backtest
PINEFORGE_ALLOW_ANYWHERE	0 (1 en la imagen Docker)	Permitir rutas de OHLCV / salida / reportes fuera del directorio de trabajo actual
PINEFORGE_DOCKER_TIMEOUT_MS	120000	Terminación forzada para cada ejecución del motor y para docker pull
PINEFORGE_MAX_INLINE_BYTES	200000	Reporte más grande devuelto en línea; los más grandes se escriben en report_path
PINEFORGE_PARITY_TIMEOUT_MS	600000	Límite de tiempo de una ejecución de check_tradingview_parity (transpilar, compilar, backtest, calificación)
PINEFORGE_HOST_WORKDIR	sin definir	Docker: el directorio del host montado en /work; cuando se define, report_path es una ruta absoluta del host — correcto solo cuando el servidor se ejecuta con /work como su directorio de trabajo (ver el final del ejemplo backtest_pine)

Con Docker, pásalos como -e NAME=value.

Desarrollo

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

Para construir la imagen, pasa la versión de pineforge-release sobre la que construir (una etiqueta de su página de Releases, sin el v):

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

Licencia

Este servidor tiene licencia MIT (LICENSE). La imagen también incluye pineforge-engine (Apache-2.0) y el transpilador pineforge-codegen (código fuente disponible: PolyForm Noncommercial 1.0.0 con una excepción de trading personal; el uso comercial o alojado requiere una licencia comercial). Ver LEGAL.md.