trading-mcp-server 0.1.0__tar.gz

trading_mcp_server-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+.env
+storage/
+.pytest_cache/

trading_mcp_server-0.1.0/CLAUDE.md

@@ -0,0 +1,71 @@
+# CLAUDE.md — trading-mcp-server
+
+## Project context
+
+This repo is a **standalone, pip-installable Python package** that implements
+a local MCP server with safe trading tools (NSE / Angel One). It is consumed
+by trading workspaces (e.g. the sibling `TradingAgent` repo) but must never
+depend on them. The agent using the tools lives elsewhere — this package only
+provides data, validation, simulation, and a guarded broker layer.
+
+## Package structure rules
+
+- `src/` layout, import package `trading_mcp_server`, distribution name
+  `trading-mcp-server`. Do not break this naming or move out of `src/`.
+- `server.py` only wires things together (`create_server()`); logic lives in
+  `services/`, tool registration in `tools/` (one module per category, each
+  exposing `register(mcp)`), MCP resources/prompts in their packages.
+- `broker/smartapi_adapter.py` is the ONLY module that talks to the real
+  broker, and `services/broker_service.py` is the ONLY caller of its order
+  methods. Keep it that way — that's what makes the safety layer auditable.
+- All filesystem state goes under `get_storage_dir()`; all config through
+  `config.get_config()`. Both resolve from `TRADING_MCP_HOME` (or cwd).
+  **Never hardcode a repo path, user path, or absolute path.**
+- Heavy/optional imports (SmartApi, bs4) stay lazy so paper-mode users and
+  tests run without the `[broker,scanners]` extras.
+
+## MCP tool design rules
+
+- Tools return plain JSON-serializable dicts; errors as `{"error": ...}` via
+  `tools/_common.make_tool` — never let raw tracebacks reach the agent.
+- Docstrings are the agent-facing contract: state what the tool does, its
+  enums (e.g. timeframes), and any safety behavior.
+- Every order path — paper or live — must pass
+  `order_validation_service.validate_order`. Never add a tool that bypasses it.
+- Tools must never return secrets; config goes out via `to_safe_dict()` only.
+- Logs go to stderr (`utils/logger.py`); stdout belongs to the MCP transport.
+
+## Safety invariants (do not weaken)
+
+1. Paper mode is the default; live requires `TRADING_MODE=live` AND
+   `ALLOW_LIVE_TRADING=true`, and the latter is not runtime-updatable.
+2. Delivery sell is hard-blocked at prepare time, at execute time, and in the
+   permission checks. Three layers — keep all three.
+3. Live execution requires the prepare → approval-token → execute flow.
+4. Every order decision is audited via `log_trade_event`.
+5. No main-trading-app business logic in this package — keep it a generic,
+   reusable toolbox.
+6. No hardcoded broker secrets, API keys, tokens, or account numbers — ever,
+   including in tests and docs.
+
+## Testing
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests -q
+```
+
+- Tests are network-free and broker-free; keep them that way (the safety tests
+  prove the broker is never reached — that's the point).
+- Safety behaviors are covered in `test_broker_safety.py`,
+  `test_order_validation.py`, `test_config.py`. Never delete or weaken these
+  to make a change pass. New tools need tests where logic is non-trivial.
+
+## Packaging expectations
+
+- `pyproject.toml` (hatchling) is the build source of truth; console script
+  `trading-mcp-server` must keep working.
+- Keep the package importable on a clean `pip install trading-mcp-server`
+  (core deps only). Broker/scanner deps stay in extras.
+- Version lives in `pyproject.toml` + `trading_mcp_server.__version__` — bump
+  both together. Future publish: `python -m build` + `twine upload`.

trading_mcp_server-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mukul Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

trading_mcp_server-0.1.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: trading-mcp-server
+Version: 0.1.0
+Summary: Local MCP server exposing safe trading tools (market data, indicators, risk, paper trading, broker) for AI agents like Claude Code
+Project-URL: Repository, https://github.com/mukul8896/trading-mcp-server
+Author: Mukul Kumar
+License: MIT
+License-File: LICENSE
+Keywords: claude,mcp,nse,paper-trading,trading
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: numpy
+Requires-Dist: pandas>=2.0
+Requires-Dist: requests
+Provides-Extra: broker
+Requires-Dist: logzero; extra == 'broker'
+Requires-Dist: pyotp; extra == 'broker'
+Requires-Dist: smartapi-python; extra == 'broker'
+Requires-Dist: websocket-client; extra == 'broker'
+Provides-Extra: dev
+Requires-Dist: bs4; extra == 'dev'
+Requires-Dist: logzero; extra == 'dev'
+Requires-Dist: lxml; extra == 'dev'
+Requires-Dist: pyotp; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: smartapi-python; extra == 'dev'
+Requires-Dist: websocket-client; extra == 'dev'
+Provides-Extra: scanners
+Requires-Dist: bs4; extra == 'scanners'
+Requires-Dist: lxml; extra == 'scanners'
+Description-Content-Type: text/markdown
+
+# trading-mcp-server
+
+A local **MCP (Model Context Protocol) server** that exposes safe trading tools for AI agents such as **Claude Code** and **Copilot CLI**. The agent does the reasoning; this server provides market data, technical indicators, news, risk management, a paper-trading engine, backtesting, and a heavily guarded broker layer (Angel One SmartAPI, NSE).
+
+**Safety model (non-negotiable):**
+
+- Paper trading is the default. Real orders require `TRADING_MODE=live` **and** `ALLOW_LIVE_TRADING=true` (the latter can only be set by a human editing `.env` — no tool can change it).
+- Every order passes a full validation checklist (stop-loss required, risk:reward minimum, position-size / daily-loss / open-position limits, market-hours check).
+- Live orders use a **prepare → human approval → execute** token flow.
+- **Delivery (CNC) sell orders are always blocked** — the server only records a recommendation.
+- Every decision is appended to an audit log (`storage/trade_logs.jsonl`).
+
+> Nothing produced by this server is financial advice.
+
+## Installation
+
+```bash
+# local development (editable, from a sibling checkout)
+pip install -e ../trading-mcp-server
+
+# with broker + scanner extras (needed for live data / Chartink watchlist)
+pip install -e "../trading-mcp-server[broker,scanners]"
+
+# future, once published to PyPI
+pip install trading-mcp-server
+```
+
+Requires Python 3.10+.
+
+## Running the server
+
+The server speaks MCP over stdio:
+
+```bash
+trading-mcp-server
+# or
+python -m trading_mcp_server.server
+```
+
+It resolves its configuration and state from a **home directory**:
+
+1. `TRADING_MCP_HOME` environment variable, if set
+2. otherwise the current working directory
+
+There it reads `<home>/.env` (trading mode, permissions, risk limits, broker credentials) and writes `<home>/storage/` (paper-trading state, pending orders, audit log). This keeps the package independent of any repo path — point `TRADING_MCP_HOME` at your trading project.
+
+Register in a client (e.g. `.mcp.json` for Claude Code):
+
+```json
+{
+  "mcpServers": {
+    "trading-agent": {
+      "command": "trading-mcp-server",
+      "env": { "TRADING_MCP_HOME": "C:\\path\\to\\your\\trading-repo" }
+    }
+  }
+}
+```
+
+## What it exposes
+
+### Tools (by category)
+
+| Category | Tools |
+|---|---|
+| Config | `get_trading_config`, `get_current_trading_mode`, `update_trading_config`, `switch_to_paper_mode`, `switch_to_live_mode`, `validate_trading_permissions` |
+| Market data | `fetch_live_price`, `fetch_historical_data`, `fetch_market_status`, `fetch_symbol_metadata`, `fetch_watchlist` |
+| Indicators | `calculate_sma/ema/rsi/macd/bollinger_bands/atr/volume_analysis`, `detect_support_resistance`, `detect_trend`, `get_indicator_snapshot` |
+| News | `fetch_latest_news`, `fetch_market_news`, `analyze_news_sentiment` |
+| Portfolio | `fetch_portfolio`, `fetch_order_history`, `calculate_portfolio_exposure`, `calculate_unrealized_pnl` |
+| Risk | `calculate_position_size`, `calculate_stop_loss`, `calculate_target_price`, `check_max_daily_loss`, `check_portfolio_concentration`, `validate_trade_against_risk_rules` |
+| Strategy | `evaluate_intraday_trade_setup`, `evaluate_swing_trade_setup`, `compare_multiple_symbols`, `scan_watchlist_for_intraday_opportunities`, `scan_watchlist_for_swing_opportunities`, `run_strategy_backtest` |
+| Paper trading | `place_paper_order`, `close_paper_position`, `fetch_paper_trades`, `fetch_paper_portfolio`, `calculate_paper_trading_performance`, `generate_paper_trading_report`, `reset_paper_account` |
+| Broker (guarded) | `prepare_order`, `validate_order_before_execution`, `execute_intraday_order_after_validation`, `execute_delivery_buy_after_validation`, `block_delivery_sell_order`, `list_pending_live_orders`, `cancel_pending_live_order`, `fetch_broker_funds/positions/holdings/order_status` |
+
+### Resources
+
+- `trading://config` — current configuration (secrets redacted)
+- `trading://safety-rules` — the safety rules the server enforces
+
+### Prompts
+
+- `intraday_trade_analysis(symbol)` — disciplined intraday workflow
+- `swing_trade_analysis(symbol)` — swing/delivery workflow
+- `paper_trading_review()` — profitability review workflow
+
+Backtest strategies built in: `ma_crossover`, `rsi_reversal`, `macd_trend`, `breakout_volume`.
+
+## Package structure
+
+```
+src/trading_mcp_server/
+├── server.py        # FastMCP entry point (create_server, main)
+├── config.py        # .env-backed TradingConfig — single source of truth
+├── tools/           # MCP tool modules (one per category, register(mcp))
+├── resources/       # MCP resources
+├── prompts/         # MCP prompts
+├── services/        # data provider, indicators, risk, validation, paper engine, broker safety layer
+├── broker/          # SmartAPI adapter — the ONLY module talking to the real broker
+├── backtest/        # engine + built-in strategies
+└── utils/           # logging/audit, market hours, instrument lookup
+tests/               # pytest suite (config, safety, paper engine, indicators, backtest)
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests -q          # run tests (no network, no broker needed)
+python -m trading_mcp_server.server  # run server from source
+```
+
+## Configuration reference
+
+See `.env.example` in the consuming repo. Key flags: `TRADING_MODE` (paper|live), `ALLOW_LIVE_TRADING`, `REQUIRE_MANUAL_APPROVAL_FOR_LIVE_ORDERS`, `ALLOW_INTRADAY_BUY/SELL`, `ALLOW_DELIVERY_BUY`, `ALLOW_DELIVERY_SELL` (keep `false`), `MAX_RISK_PER_TRADE_PERCENT`, `MAX_DAILY_LOSS_PERCENT`, `MAX_OPEN_POSITIONS`, `MAX_POSITION_SIZE_PERCENT`, `MIN_RISK_REWARD_RATIO`, `PAPER_STARTING_CAPITAL`, `BROKER_*` credentials.
+
+## Publishing to PyPI (future)
+
+1. Bump `version` in `pyproject.toml` and `src/trading_mcp_server/__init__.py`.
+2. `python -m build` (requires `pip install build`).
+3. `python -m twine upload dist/*` (requires a PyPI account + API token).
+4. Consumers then switch from `pip install -e ../trading-mcp-server` to `pip install trading-mcp-server` — no other change needed.
+
+## License
+
+MIT

trading_mcp_server-0.1.0/README.md

@@ -0,0 +1,126 @@
+# trading-mcp-server
+
+A local **MCP (Model Context Protocol) server** that exposes safe trading tools for AI agents such as **Claude Code** and **Copilot CLI**. The agent does the reasoning; this server provides market data, technical indicators, news, risk management, a paper-trading engine, backtesting, and a heavily guarded broker layer (Angel One SmartAPI, NSE).
+
+**Safety model (non-negotiable):**
+
+- Paper trading is the default. Real orders require `TRADING_MODE=live` **and** `ALLOW_LIVE_TRADING=true` (the latter can only be set by a human editing `.env` — no tool can change it).
+- Every order passes a full validation checklist (stop-loss required, risk:reward minimum, position-size / daily-loss / open-position limits, market-hours check).
+- Live orders use a **prepare → human approval → execute** token flow.
+- **Delivery (CNC) sell orders are always blocked** — the server only records a recommendation.
+- Every decision is appended to an audit log (`storage/trade_logs.jsonl`).
+
+> Nothing produced by this server is financial advice.
+
+## Installation
+
+```bash
+# local development (editable, from a sibling checkout)
+pip install -e ../trading-mcp-server
+
+# with broker + scanner extras (needed for live data / Chartink watchlist)
+pip install -e "../trading-mcp-server[broker,scanners]"
+
+# future, once published to PyPI
+pip install trading-mcp-server
+```
+
+Requires Python 3.10+.
+
+## Running the server
+
+The server speaks MCP over stdio:
+
+```bash
+trading-mcp-server
+# or
+python -m trading_mcp_server.server
+```
+
+It resolves its configuration and state from a **home directory**:
+
+1. `TRADING_MCP_HOME` environment variable, if set
+2. otherwise the current working directory
+
+There it reads `<home>/.env` (trading mode, permissions, risk limits, broker credentials) and writes `<home>/storage/` (paper-trading state, pending orders, audit log). This keeps the package independent of any repo path — point `TRADING_MCP_HOME` at your trading project.
+
+Register in a client (e.g. `.mcp.json` for Claude Code):
+
+```json
+{
+  "mcpServers": {
+    "trading-agent": {
+      "command": "trading-mcp-server",
+      "env": { "TRADING_MCP_HOME": "C:\\path\\to\\your\\trading-repo" }
+    }
+  }
+}
+```
+
+## What it exposes
+
+### Tools (by category)
+
+| Category | Tools |
+|---|---|
+| Config | `get_trading_config`, `get_current_trading_mode`, `update_trading_config`, `switch_to_paper_mode`, `switch_to_live_mode`, `validate_trading_permissions` |
+| Market data | `fetch_live_price`, `fetch_historical_data`, `fetch_market_status`, `fetch_symbol_metadata`, `fetch_watchlist` |
+| Indicators | `calculate_sma/ema/rsi/macd/bollinger_bands/atr/volume_analysis`, `detect_support_resistance`, `detect_trend`, `get_indicator_snapshot` |
+| News | `fetch_latest_news`, `fetch_market_news`, `analyze_news_sentiment` |
+| Portfolio | `fetch_portfolio`, `fetch_order_history`, `calculate_portfolio_exposure`, `calculate_unrealized_pnl` |
+| Risk | `calculate_position_size`, `calculate_stop_loss`, `calculate_target_price`, `check_max_daily_loss`, `check_portfolio_concentration`, `validate_trade_against_risk_rules` |
+| Strategy | `evaluate_intraday_trade_setup`, `evaluate_swing_trade_setup`, `compare_multiple_symbols`, `scan_watchlist_for_intraday_opportunities`, `scan_watchlist_for_swing_opportunities`, `run_strategy_backtest` |
+| Paper trading | `place_paper_order`, `close_paper_position`, `fetch_paper_trades`, `fetch_paper_portfolio`, `calculate_paper_trading_performance`, `generate_paper_trading_report`, `reset_paper_account` |
+| Broker (guarded) | `prepare_order`, `validate_order_before_execution`, `execute_intraday_order_after_validation`, `execute_delivery_buy_after_validation`, `block_delivery_sell_order`, `list_pending_live_orders`, `cancel_pending_live_order`, `fetch_broker_funds/positions/holdings/order_status` |
+
+### Resources
+
+- `trading://config` — current configuration (secrets redacted)
+- `trading://safety-rules` — the safety rules the server enforces
+
+### Prompts
+
+- `intraday_trade_analysis(symbol)` — disciplined intraday workflow
+- `swing_trade_analysis(symbol)` — swing/delivery workflow
+- `paper_trading_review()` — profitability review workflow
+
+Backtest strategies built in: `ma_crossover`, `rsi_reversal`, `macd_trend`, `breakout_volume`.
+
+## Package structure
+
+```
+src/trading_mcp_server/
+├── server.py        # FastMCP entry point (create_server, main)
+├── config.py        # .env-backed TradingConfig — single source of truth
+├── tools/           # MCP tool modules (one per category, register(mcp))
+├── resources/       # MCP resources
+├── prompts/         # MCP prompts
+├── services/        # data provider, indicators, risk, validation, paper engine, broker safety layer
+├── broker/          # SmartAPI adapter — the ONLY module talking to the real broker
+├── backtest/        # engine + built-in strategies
+└── utils/           # logging/audit, market hours, instrument lookup
+tests/               # pytest suite (config, safety, paper engine, indicators, backtest)
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+python -m pytest tests -q          # run tests (no network, no broker needed)
+python -m trading_mcp_server.server  # run server from source
+```
+
+## Configuration reference
+
+See `.env.example` in the consuming repo. Key flags: `TRADING_MODE` (paper|live), `ALLOW_LIVE_TRADING`, `REQUIRE_MANUAL_APPROVAL_FOR_LIVE_ORDERS`, `ALLOW_INTRADAY_BUY/SELL`, `ALLOW_DELIVERY_BUY`, `ALLOW_DELIVERY_SELL` (keep `false`), `MAX_RISK_PER_TRADE_PERCENT`, `MAX_DAILY_LOSS_PERCENT`, `MAX_OPEN_POSITIONS`, `MAX_POSITION_SIZE_PERCENT`, `MIN_RISK_REWARD_RATIO`, `PAPER_STARTING_CAPITAL`, `BROKER_*` credentials.
+
+## Publishing to PyPI (future)
+
+1. Bump `version` in `pyproject.toml` and `src/trading_mcp_server/__init__.py`.
+2. `python -m build` (requires `pip install build`).
+3. `python -m twine upload dist/*` (requires a PyPI account + API token).
+4. Consumers then switch from `pip install -e ../trading-mcp-server` to `pip install trading-mcp-server` — no other change needed.
+
+## License
+
+MIT

trading_mcp_server-0.1.0/agent-register.md

@@ -0,0 +1,32 @@
+# Agent register — trading-mcp-server
+
+## A. MCP Server Agent
+
+**Role:** Maintains the MCP server package.
+
+**Responsibilities:**
+- Create and maintain MCP tools, resources, and prompts under
+  `src/trading_mcp_server/` (tools in `tools/`, one module per category).
+- Keep the MCP server independent from any consuming trading repo — paths
+  resolve via `TRADING_MCP_HOME`/cwd, never a hardcoded repo location.
+- Ensure the package always installs with `pip install -e .` and the console
+  script `trading-mcp-server` keeps working.
+- Keep the code ready for future PyPI publishing (pyproject metadata, src/
+  layout, version sync between `pyproject.toml` and `__init__.py`).
+- Maintain clean package structure under `src/trading_mcp_server/`.
+- Add tests for MCP tools and services (`tests/`, pytest, network-free);
+  preserve the safety test suite (paper default, delivery-sell block,
+  approval flow, risk limits).
+
+**Restrictions:**
+- Do not add main trading app business logic into the MCP server — it is a
+  generic, reusable toolbox.
+- Do not hardcode broker secrets, API keys, tokens, or account numbers.
+- Do not make the MCP server dependent on one specific repo path.
+- Do not break future pip packaging compatibility (src/ layout, extras,
+  lazy optional imports).
+- Do not weaken the safety invariants listed in CLAUDE.md.
+
+**When to use:** modifying MCP tools/resources/prompts, server startup,
+package metadata, `pyproject.toml`, services, the broker safety layer, or
+reusable trading utilities.

trading_mcp_server-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "trading-mcp-server"
+version = "0.1.0"
+description = "Local MCP server exposing safe trading tools (market data, indicators, risk, paper trading, broker) for AI agents like Claude Code"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Mukul Kumar" }]
+keywords = ["mcp", "trading", "paper-trading", "nse", "claude"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+
+dependencies = [
+    "mcp>=1.2.0",
+    "pandas>=2.0",
+    "numpy",
+    "requests",
+]
+
+[project.optional-dependencies]
+# Live broker connectivity (Angel One SmartAPI) — not needed for paper-only use
+broker = [
+    "smartapi-python",
+    "pyotp",
+    "logzero",
+    "websocket-client",
+]
+# Chartink watchlist scanning
+scanners = [
+    "bs4",
+    "lxml",
+]
+dev = [
+    "pytest",
+    "trading-mcp-server[broker,scanners]",
+]
+
+[project.scripts]
+trading-mcp-server = "trading_mcp_server.server:main"
+
+[project.urls]
+Repository = "https://github.com/mukul8896/trading-mcp-server"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/trading_mcp_server"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

trading_mcp_server-0.1.0/src/trading_mcp_server/__init__.py

@@ -0,0 +1,3 @@
+"""trading-mcp-server: safe trading tools for AI agents over MCP."""
+
+__version__ = "0.1.0"

trading_mcp_server-0.1.0/src/trading_mcp_server/backtest/engine.py

@@ -0,0 +1,111 @@
+"""Minimal long-only backtest engine over signal series (1=long, 0=flat).
+
+Entries/exits execute at the NEXT bar's open to avoid look-ahead bias.
+"""
+from __future__ import annotations
+
+import pandas as pd
+
+from trading_mcp_server.backtest.strategies import STRATEGIES
+
+
+def run_backtest(
+    df: pd.DataFrame,
+    strategy_name: str,
+    initial_capital: float = 100_000.0,
+    strategy_params: dict | None = None,
+) -> dict:
+    if strategy_name not in STRATEGIES:
+        return {"error": f"Unknown strategy '{strategy_name}'. Available: {sorted(STRATEGIES)}"}
+    if len(df) < 60:
+        return {"error": f"Not enough candles ({len(df)}) — need at least 60."}
+
+    signal = STRATEGIES[strategy_name](df, **(strategy_params or {}))
+
+    trades: list[dict] = []
+    in_position = False
+    entry_price = 0.0
+    entry_date = None
+    quantity = 0
+    cash = initial_capital
+
+    for i in range(len(df) - 1):
+        next_open = float(df["open"].iloc[i + 1])
+        next_date = df.index[i + 1]
+        want_long = bool(signal.iloc[i])
+
+        if want_long and not in_position:
+            quantity = int(cash // next_open)
+            if quantity > 0:
+                in_position = True
+                entry_price = next_open
+                entry_date = next_date
+                cash -= quantity * next_open
+        elif not want_long and in_position:
+            cash += quantity * next_open
+            trades.append(
+                {
+                    "entry_date": str(entry_date),
+                    "exit_date": str(next_date),
+                    "entry_price": round(entry_price, 2),
+                    "exit_price": round(next_open, 2),
+                    "quantity": quantity,
+                    "pnl": round((next_open - entry_price) * quantity, 2),
+                    "return_pct": round((next_open / entry_price - 1) * 100, 2),
+                }
+            )
+            in_position = False
+
+    # Close any open position at the final close
+    if in_position:
+        last_close = float(df["close"].iloc[-1])
+        cash += quantity * last_close
+        trades.append(
+            {
+                "entry_date": str(entry_date),
+                "exit_date": str(df.index[-1]),
+                "entry_price": round(entry_price, 2),
+                "exit_price": round(last_close, 2),
+                "quantity": quantity,
+                "pnl": round((last_close - entry_price) * quantity, 2),
+                "return_pct": round((last_close / entry_price - 1) * 100, 2),
+                "closed_at_end": True,
+            }
+        )
+
+    return _metrics(trades, initial_capital, cash, strategy_name, df)
+
+
+def _metrics(trades: list[dict], initial: float, final: float, strategy: str, df: pd.DataFrame) -> dict:
+    pnls = [t["pnl"] for t in trades]
+    wins = [p for p in pnls if p > 0]
+    losses = [p for p in pnls if p <= 0]
+
+    equity, peak, max_dd = initial, initial, 0.0
+    for p in pnls:
+        equity += p
+        peak = max(peak, equity)
+        max_dd = max(max_dd, (peak - equity) / peak * 100 if peak else 0)
+
+    total_return_pct = (final / initial - 1) * 100
+    buy_hold_pct = (float(df["close"].iloc[-1]) / float(df["close"].iloc[0]) - 1) * 100
+
+    return {
+        "strategy": strategy,
+        "period": {"start": str(df.index[0]), "end": str(df.index[-1]), "bars": len(df)},
+        "initial_capital": initial,
+        "final_capital": round(final, 2),
+        "total_return_pct": round(total_return_pct, 2),
+        "buy_and_hold_return_pct": round(buy_hold_pct, 2),
+        "num_trades": len(trades),
+        "win_rate_pct": round(len(wins) / len(trades) * 100, 1) if trades else None,
+        "total_pnl": round(sum(pnls), 2),
+        "avg_pnl_per_trade": round(sum(pnls) / len(trades), 2) if trades else None,
+        "avg_win": round(sum(wins) / len(wins), 2) if wins else 0,
+        "avg_loss": round(sum(losses) / len(losses), 2) if losses else 0,
+        "profit_factor": round(sum(wins) / abs(sum(losses)), 2) if losses and sum(losses) else None,
+        "max_drawdown_pct": round(max_dd, 2),
+        "profitable": total_return_pct > 0,
+        "beats_buy_and_hold": total_return_pct > buy_hold_pct,
+        "trades": trades[-20:],  # last 20 trades for inspection
+    }

trading_mcp_server-0.1.0/src/trading_mcp_server/backtest/strategies.py

@@ -0,0 +1,57 @@
+"""Built-in backtest strategies. Each returns a Series of signals per bar:
+1 = enter/hold long, 0 = flat. The engine trades the transitions."""
+from __future__ import annotations
+
+import pandas as pd
+
+from trading_mcp_server.services import indicator_service as ind
+
+
+def ma_crossover(df: pd.DataFrame, fast: int = 20, slow: int = 50) -> pd.Series:
+    fast_ma = ind.sma(df["close"], fast)
+    slow_ma = ind.sma(df["close"], slow)
+    return (fast_ma > slow_ma).astype(int)
+
+
+def rsi_reversal(df: pd.DataFrame, period: int = 14, oversold: int = 30, exit_level: int = 60) -> pd.Series:
+    rsi = ind.rsi(df, period)
+    signal = pd.Series(0, index=df.index)
+    holding = False
+    for i in range(len(df)):
+        value = rsi.iloc[i]
+        if not holding and value < oversold:
+            holding = True
+        elif holding and value > exit_level:
+            holding = False
+        signal.iloc[i] = int(holding)
+    return signal
+
+
+def macd_trend(df: pd.DataFrame) -> pd.Series:
+    m = ind.macd(df)
+    above_ema200 = df["close"] > ind.ema(df["close"], 200)
+    return ((m["macd"] > m["signal"]) & above_ema200).astype(int)
+
+
+def breakout_volume(df: pd.DataFrame, lookback: int = 20, volume_mult: float = 2.0) -> pd.Series:
+    rolling_high = df["high"].rolling(lookback).max().shift(1)
+    vol_ema = df["volume"].ewm(span=20, adjust=False).mean()
+    entry = (df["close"] > rolling_high) & (df["volume"] > vol_ema * volume_mult)
+    exit_ = df["close"] < ind.ema(df["close"], 20)
+    signal = pd.Series(0, index=df.index)
+    holding = False
+    for i in range(len(df)):
+        if not holding and bool(entry.iloc[i]):
+            holding = True
+        elif holding and bool(exit_.iloc[i]):
+            holding = False
+        signal.iloc[i] = int(holding)
+    return signal
+
+
+STRATEGIES = {
+    "ma_crossover": ma_crossover,
+    "rsi_reversal": rsi_reversal,
+    "macd_trend": macd_trend,
+    "breakout_volume": breakout_volume,
+}