Skip to main content
Glama
Jesse MCP Server
by bkuri

Jesse MCP Server

PyPI version Python 3.10+ License: MIT

An MCP (Model Context Protocol) server that exposes Jesse's algorithmic trading framework capabilities to LLM agents.

Status: Feature Complete ✅

All planned features implemented and tested. 32 tools available (17 core + 15 agent).

Related MCP server: TradeMCP

Installation

PyPI

pip install jesse-mcp
uvx jesse-mcp

Arch Linux (AUR)

yay -S jesse-mcp
# or
paru -S jesse-mcp

From Source

git clone https://github.com/bkuri/jesse-mcp.git
cd jesse-mcp
pip install -e .

Usage

# stdio transport (default, for MCP clients)
jesse-mcp

# HTTP transport (for remote access)
jesse-mcp --transport http --port 8100

# Show help
jesse-mcp --help

Environment Variables

Variable

Description

Default

JESSE_URL

Jesse REST API URL

http://server2:9100

JESSE_PASSWORD

Jesse UI password

(required)

JESSE_API_TOKEN

Pre-generated API token

(alternative to password)

JESSE_TRADE_API_KEY

jesse.trade community API Bearer token

(optional)

Features

  • Backtesting - Single and batch backtest execution via Jesse REST API

  • Optimization - Hyperparameter tuning with walk-forward validation

  • Monte Carlo Analysis - Statistical robustness testing

  • Pairs Trading - Cointegration testing and strategy generation

  • Strategy Management - CRUD operations for trading strategies

  • Risk Analysis - VaR, stress testing, comprehensive risk reports

  • Agent Tools - 15 specialized tools for autonomous trading workflows

  • Community Browsing - Browse, compare, and inspect jesse.trade community strategies

Architecture

LLM Agent ←→ MCP Protocol ←→ jesse-mcp ←→ Jesse REST API (localhost:9000)
                                    ↓
                            Mock Fallbacks (when Jesse unavailable)

Available Tools

Core Tools (17)

Phase 1: Backtesting

Tool

Description

backtest

Run single backtest with specified parameters

strategy_list

List available strategies

strategy_read

Read strategy source code

strategy_validate

Validate strategy code

Phase 2: Data & Analysis

Tool

Description

candles_import

Download candle data from exchanges

backtest_batch

Run concurrent multi-asset backtests

analyze_results

Extract insights from backtest results

walk_forward

Walk-forward analysis for overfitting detection

Phase 3: Optimization

Tool

Description

optimize

Optimize hyperparameters using Optuna

Phase 4: Risk Analysis

Tool

Description

monte_carlo

Monte Carlo simulations for risk analysis

var_calculation

Value at Risk (historical, parametric, Monte Carlo)

stress_test

Test under extreme market scenarios

risk_report

Comprehensive risk assessment

Phase 5: Pairs Trading

Tool

Description

correlation_matrix

Cross-asset correlation analysis

pairs_backtest

Backtest pairs trading strategies

factor_analysis

Decompose returns into systematic factors

regime_detector

Identify market regimes and transitions

Agent Tools (15)

Specialized tools for autonomous trading workflows:

Tool

Description

strategy_suggest_improvements

AI-powered strategy enhancement suggestions

strategy_compare_strategies

Compare multiple strategies side-by-side

strategy_optimize_pair_selection

Optimize pairs trading selection

strategy_analyze_optimization_impact

Analyze impact of optimization changes

risk_analyze_portfolio

Portfolio-level risk analysis

risk_stress_test

Advanced stress testing

risk_assess_leverage

Leverage risk assessment

risk_recommend_hedges

Hedging recommendations

risk_analyze_drawdown_recovery

Drawdown recovery analysis

backtest_comprehensive

Full backtest with all metrics

backtest_compare_timeframes

Compare performance across timeframes

backtest_optimize_parameters

Quick parameter optimization

backtest_monte_carlo

Backtest with Monte Carlo analysis

backtest_analyze_regimes

Regime-aware backtest analysis

backtest_validate_significance

Statistical significance validation

Community Tools (5)

Browse, compare, and inspect community strategies from jesse.trade:

Tool

Description

list_periods

List available backtest periods on jesse.trade

browse_community_strategies

Browse strategies sorted by performance metrics

get_strategy_metrics

Detailed backtest metrics for a specific strategy

get_strategy_code

Full Python source code for a strategy

compare_community_strategies

Side-by-side metric comparison of multiple strategies

Testing

# Install dev dependencies
pip install jesse-mcp[dev]

# Run all tests
pytest -v

# Run with coverage
pytest --cov=jesse_mcp

Status: 49 tests passing

Local Development

Prerequisites

  • Python 3.10+

  • Jesse 1.13.x running on localhost:9000

  • PostgreSQL on localhost:5432

  • Redis on localhost:6379

Start Jesse Stack (Podman)

# Start infrastructure
podman run -d --name jesse-postgres --network host \
  -e POSTGRES_USER=jesse_user -e POSTGRES_PASSWORD=password -e POSTGRES_DB=jesse_db \
  docker.io/library/postgres:14-alpine

podman run -d --name jesse-redis --network host \
  docker.io/library/redis:6-alpine redis-server --save "" --appendonly no

# Start Jesse
podman run -d --name jesse --network host \
  -v /path/to/jesse-bot:/home:z \
  docker.io/salehmir/jesse:latest bash -c "cd /home && jesse run"

Start Dev MCP Server

./scripts/start-dev-server.sh   # Start on port 8100
./scripts/stop-dev-server.sh    # Stop server

Add to OpenCode

Add to ~/.config/opencode/opencode.json:

{
  "mcp": {
    "jesse-mcp-dev": {
      "type": "remote",
      "url": "http://localhost:8100/mcp",
      "enabled": true
    }
  }
}

Documentation

API Reference

Jesse REST Client

The jesse_rest_client.py module provides direct access to Jesse's REST API:

from jesse_mcp.core.jesse_rest_client import get_jesse_rest_client

client = get_jesse_rest_client()

# Run backtest
result = client.backtest(
    strategy="OctopusStrategy",
    symbol="BTC-USDT", 
    timeframe="1h",
    start_date="2024-01-01",
    end_date="2024-01-31"
)

Mock Implementations

When Jesse is unavailable, all tools gracefully fall back to mock implementations that return realistic synthetic data. This enables development and testing without a full Jesse installation.

Key Dependencies

Package

Version

Purpose

fastmcp

>=0.3.0

MCP server framework

numpy

>=1.24.0

Numerical computations

pandas

>=2.0.0

Data manipulation

scipy

>=1.10.0

Statistical functions

scikit-learn

>=1.3.0

ML utilities

optuna

>=3.0.0

Hyperparameter optimization

Project Structure

jesse_mcp/
├── server.py            # FastMCP server with 17 core tools
├── optimizer.py         # Phase 3: Optimization tools
├── risk_analyzer.py     # Phase 4: Risk analysis tools
├── pairs_analyzer.py    # Phase 5: Pairs trading tools
├── agent_tools.py       # 15 agent-specific tools
├── core/
│   ├── integrations.py  # Jesse framework integration
│   ├── jesse_rest_client.py  # REST API client
│   └── mock.py          # Mock implementations
├── agents/
│   ├── base.py          # Base agent class
│   ├── backtester.py    # Backtesting specialist
│   └── risk_manager.py  # Risk management specialist
└── scripts/
    ├── start-dev-server.sh
    └── stop-dev-server.sh

License

MIT License - see LICENSE file for details.

Publishing

This package uses GitHub Actions with PyPI trusted publishing. To release a new version:

  1. Update version in pyproject.toml and jesse_mcp/__init__.py

  2. Create a git tag: git tag v1.x.x

  3. Push tag: git push origin v1.x.x

  4. Create GitHub release - automatically publishes to PyPI

Available Tools

69 tools
alerts_send_notificationA

Send a notification alert via ntfy.sh.

Args: message: Alert message to send priority: Priority level (default, low, high, urgent) tags: Comma-separated tags for the alert

Returns: Send result with status and timestamp

Inputs: message (required), priority, tags. Returns: object

backtest_analyze_regimesB

Analyze strategy performance in different market regimes.

Tests performance in trending, ranging, and volatile markets.

Args: strategy_name: Strategy to analyze pair: Trading pair

Returns: Regime-dependent performance analysis with adaptation suggestions

Inputs: strategy_name (required), pair (required). Returns: result

backtest_compare_timeframesA

Compare strategy performance across different timeframes.

Tests 1m, 5m, 15m, 1h, 4h, 1d to find optimal timeframe.

Args: strategy_name: Strategy to test pair: Trading pair

Returns: Cross-timeframe comparison with optimal timeframe recommendation

Inputs: strategy_name (required), pair (required). Returns: result

backtest_comprehensiveB

Run a comprehensive backtest of a trading strategy.

Tests performance, extracts metrics, and provides analysis.

Args: strategy_name: Strategy to backtest pair: Trading pair (e.g., 'BTCUSDT') start_date: Start date in YYYY-MM-DD format end_date: End date in YYYY-MM-DD format

Returns: Comprehensive backtest results and analysis

Inputs: strategy_name (required), pair (required), start_date (required), end_date (required). Returns: result

backtesting_exchangesA

Get list of supported exchanges in Jesse.

Returns a list of exchange names that Jesse supports for trading and backtesting. Use this to validate exchange names before creating trading workflows or backtests.

Returns: Dict with 'exchanges' list of supported exchange names and 'exchange_configs' with details

Inputs: no named parameters. Returns: object

backtesting_import_candlesC

Download candle data from exchange via Jesse REST API

Inputs: exchange (required), symbol (required), start_date (required), end_date. Returns: object

backtesting_list_strategiesA

List all available trading strategies.

Use this as the FIRST step to see what strategies are available to test. Returns list of strategy names that can be passed to backtest(), analyze_results(), etc.

Inputs: include_test_strategies. Returns: object

backtesting_read_strategyC

Read strategy source code

Inputs: name (required). Returns: object

backtesting_runA

Run a single backtest on a strategy with specified parameters.

Returns metrics: total_return, sharpe_ratio, max_drawdown, win_rate, total_trades, etc.

Use this to:

  • Test a single strategy version

  • Get baseline metrics for comparison

  • As first step before analyze_results, monte_carlo, or risk_report

  • For A/B testing: run backtest twice with different parameters/strategies

Example flow for A/B testing:

  1. backtest(strategy="EMA_original", ...)

  2. backtest(strategy="EMA_with_filter", ...)

  3. analyze_results() on both to compare

Inputs: strategy (required), symbol (required), timeframe (required), start_date (required), +10 more. Returns: object

backtesting_statusA

Check Jesse REST API health and connection status.

Returns connection status, Jesse version, and available strategies count. Use this to verify Jesse is reachable before running backtests or optimizations.

Inputs: no named parameters. Returns: object

backtesting_validateB

Validate strategy code without saving

Inputs: code (required). Returns: object

backtest_monte_carloB

Perform Monte Carlo simulation for strategy robustness analysis.

Tests many outcome variations to assess robustness.

Args: strategy_name: Strategy to analyze pair: Trading pair

Returns: Monte Carlo analysis with confidence intervals and risk assessment

Inputs: strategy_name (required), pair (required). Returns: result

backtest_optimize_parametersB

Find optimal parameter values through systematic testing.

Tests parameter ranges to identify best settings.

Args: strategy_name: Strategy with parameter to optimize pair: Trading pair param_name: Parameter name (e.g., 'period', 'threshold') param_range: Range to test (e.g., '10-100')

Returns: Parameter optimization results with sensitivity analysis

Inputs: strategy_name (required), pair (required), param_name (required), param_range (required). Returns: result

backtest_validate_significanceA

Validate that backtest results are statistically significant.

Ensures results are real, not luck or overfitting.

Args: strategy_name: Strategy to validate pair: Trading pair

Returns: Statistical significance assessment and confidence metrics

Inputs: strategy_name (required), pair (required). Returns: result

benchmark_runA

Run a benchmark backtest to measure performance metrics.

Measures backtest execution time and calculates candles/second performance. Useful for understanding how long different backtests will take.

Args: symbol: Trading symbol (default: BTC-USDT) timeframe: Candle timeframe (default: 1h) days: Number of days to backtest (default: 30) exchange: Exchange name (default: Binance Spot)

Returns: Dict with benchmark results including execution time and candles/second

Inputs: symbol, timeframe, days, exchange. Returns: object

cache_clearA

Clear cache(s) to free memory or force fresh data.

Args: cache_name: Specific cache to clear (strategy_list, backtest). If None, clears all caches.

Returns: Dict with number of entries cleared per cache

Inputs: cache_name. Returns: object

cache_statsA

Get cache statistics including hit/miss ratio and cache sizes.

Returns: Dict with cache status, hit rates, and sizes for all caches

Inputs: no named parameters. Returns: object

jobs_listB

List recent jobs.

Args: job_type: Filter by job type (optional) limit: Maximum number of jobs to return (default: 50)

Returns: Dict with list of jobs containing id, type, status, progress, current_step, started_at

Inputs: job_type, limit. Returns: object

logs_analyze_historyA

Analyze recent backtest history from Jesse database.

Args: days: Number of days to analyze (default: 30)

Returns: Backtest history with metrics and trends

Inputs: days. Returns: object

logs_strategy_performanceB

Analyze strategy performance across all backtests.

Returns: Performance metrics aggregated by strategy

Inputs: no named parameters. Returns: object

logs_weekly_reportB

Generate weekly backtest activity report.

Returns: Formatted weekly report with summaries and insights

Inputs: no named parameters. Returns: result

monitor_daily_scanB

Run daily market scan to identify trading opportunities.

Scans multiple symbols and strategies to find signals.

Args: symbols: Comma-separated list of symbols to scan

Returns: Daily report with opportunities, risks, and recommendations

Inputs: symbols. Returns: object

monitor_get_risksB

Identify current market risks and warning signs.

Returns: List of identified risks with severity levels

Inputs: no named parameters. Returns: object

monitor_get_sentimentA

Get current market sentiment from Fear & Greed Index.

Returns: Fear & Greed score and rating with historical context

Inputs: no named parameters. Returns: object

monitor_scan_opportunitiesB

Scan for trading opportunities across symbols and strategies.

Args: symbols: Comma-separated list of symbols strategies: Comma-separated list of strategies

Returns: List of trading opportunities with signals and confidence

Inputs: symbols, strategies. Returns: object

optimization_analyzeA

Extract deep insights from backtest results.

Takes backtest result dict and returns detailed analysis including:

  • Trade metrics (win rate, avg return, etc.)

  • Performance breakdown

  • Risk metrics summary

Use this after backtest() to understand strategy performance better. Common workflow:

  1. backtest() -> get result

  2. analyze_results(result) -> understand what happened

  3. monte_carlo() -> validate with simulation

  4. risk_report() -> comprehensive assessment

Inputs: backtest_result (required), analysis_type, include_trade_analysis, include_correlation, +1 more. Returns: object

optimization_batchC

Run multiple backtests concurrently for strategy comparison

Inputs: strategy (required), symbols (required), timeframes (required), start_date (required), +3 more. Returns: object

optimization_runB

Auto-optimize strategy hyperparameters using Bayesian optimization.

Automatically tests many parameter combinations to find best metrics.

Example: Improve Sharpe ratio by optimizing EMA periods

  • param_space: {"ema_fast": [5, 30], "ema_slow": [20, 100]}

  • metric: "sharpe_ratio"

Returns best parameters found and their performance metrics.

Inputs: strategy (required), symbol (required), timeframe (required), start_date (required), +10 more. Returns: object

optimization_walk_forwardD

Perform walk-forward analysis to detect overfitting

Inputs: strategy (required), symbol (required), timeframe (required), start_date (required), +6 more. Returns: object

pairs_backtestD

Backtest pairs trading strategies

Inputs: pair (required), backtest_result_1 (required), backtest_result_2 (required), strategy, +5 more. Returns: object

pairs_correlationC

Analyze cross-asset correlations and identify pairs trading opportunities

Inputs: backtest_results (required), lookback_period, correlation_threshold, include_rolling, +2 more. Returns: object

pairs_factorsC

Decompose returns into systematic factors

Inputs: backtest_result (required), factors, factor_returns, include_residuals, +2 more. Returns: object

pairs_regimesC

Identify market regimes and transitions

Inputs: backtest_results (required), lookback_period, detection_method, n_regimes, +2 more. Returns: object

rate_limit_statusA

Get current rate limiter status for Jesse API calls.

Returns: Dict with rate limit configuration and statistics: - enabled: Whether rate limiting is active - rate_per_second: Configured requests per second - available_tokens: Current tokens available - wait_mode: Whether to wait or reject when limited - stats: Total requests, waits, rejections, wait time

Inputs: no named parameters. Returns: object

risk_analyze_drawdown_recoveryB

Analyze historical drawdowns and recovery patterns.

Examines when and why losses occur and recovery timelines.

Args: strategy_name: Strategy to analyze

Returns: Drawdown analysis with recovery insights and improvement suggestions

Inputs: strategy_name (required). Returns: result

risk_analyze_portfolioB

Analyze risk profile of a trading portfolio.

Evaluates correlation, concentration, and diversification.

Args: pairs: List of trading pairs to analyze

Returns: Portfolio risk analysis with recommendations

Inputs: pairs (required). Returns: result

risk_assess_leverageB

Assess the risks of trading with leverage.

Evaluates liquidation risk, margin requirements, and safe levels.

Args: strategy_name: Strategy using leverage leverage: Leverage multiplier (e.g., 2.0 for 2x)

Returns: Leverage risk assessment with recommendations

Inputs: strategy_name (required), leverage (required). Returns: result

risk_monte_carloC

Generate Monte Carlo simulations for comprehensive risk analysis

Inputs: backtest_result (required), simulations, confidence_levels, resample_method, +3 more. Returns: object

risk_recommend_hedgesA

Recommend hedging strategies for specific risks.

Suggests hedging instruments and positioning.

Args: pair: Trading pair to hedge (e.g., 'BTCUSDT') risk_type: Type of risk (e.g., 'downside', 'volatility', 'correlation')

Returns: Hedging strategy recommendations with sizing and cost-benefit analysis

Inputs: pair (required), risk_type (required). Returns: result

risk_reportC

Generate comprehensive risk assessment and recommendations

Inputs: backtest_result (required), include_monte_carlo, include_var_analysis, include_stress_test, +2 more. Returns: object

risk_stress_testB

Stress test a portfolio under extreme market scenarios.

Tests resilience to market crashes, liquidity crises, etc.

Args: pairs: Trading pairs to stress test scenario: Market scenario (e.g., 'market crash', 'flash crash')

Returns: Stress test results and risk mitigation strategies

Inputs: pairs (required), scenario (required). Returns: result

risk_varC

Calculate Value at Risk using multiple methods

Inputs: backtest_result (required), confidence_levels, time_horizons, method, +1 more. Returns: object

strategy_analyze_optimization_impactC

Estimate the impact of a proposed strategy change.

Analyzes expected benefits, risks, and testing methodology.

Args: change_description: Description of the proposed change

Returns: Impact analysis with testing recommendations

Inputs: change_description (required). Returns: result

strategy_compare_strategiesC

Compare two strategies to identify best practices.

Analyzes performance differences and key differentiators.

Args: strategy1: First strategy name strategy2: Second strategy name

Returns: Comparative analysis with insights on what makes one perform better

Inputs: strategy1 (required), strategy2 (required). Returns: result

strategy_createA

Create strategy with iterative refinement (Ralph Wiggum loop).

If async_mode=True, creates a Job and returns job_id immediately. Otherwise runs synchronously with progress logging.

Args: name: Strategy name (used as class name) description: Human-readable description of the strategy indicators: List of technical indicators to use (optional) strategy_type: Type classification (default: trend_following) risk_per_trade: Risk percentage per trade (default: 0.02 = 2%) timeframe: Primary trading timeframe (default: 1h) max_iterations: Maximum refinement iterations (default: 5) overwrite: Overwrite existing strategy (default: False) async_mode: Run asynchronously (default: False) skip_backtest: Skip dry-run backtest validation (default: False)

Returns: Dict with status, name, iterations, validation_history, path, code, ready_for_backtest

Inputs: name (required), description (required), indicators, strategy_type, +6 more. Returns: object

strategy_create_cancelA

Cancel async strategy creation job.

Args: job_id: Job identifier to cancel

Returns: Dict with status, job_id

Inputs: job_id (required). Returns: object

strategy_create_statusA

Poll async job progress for strategy creation.

Args: job_id: Job identifier from strategy_create

Returns: Dict with job_id, status, progress_percent, current_step, iterations_completed, iterations_total, elapsed_seconds, result (when complete)

Inputs: job_id (required). Returns: object

strategy_deleteB

Delete a strategy.

Args: name: Strategy name to delete confirm: Must be True to actually delete (default: False)

Returns: Dict with status, name

Inputs: name (required), confirm. Returns: object

strategy_metadataB

Get metadata and version info for a strategy.

Args: name: Strategy name

Returns: Dict with strategy metadata including version, test_count, test_pass_count, certified status, and certification thresholds

Inputs: name (required). Returns: object

strategy_optimize_pair_selectionB

Find the best trading pairs for a given strategy.

Analyzes performance across pairs to recommend the best ones.

Args: strategy_name: Strategy to optimize pair selection for

Returns: Ranked list of pairs with performance metrics and recommendations

Inputs: strategy_name (required). Returns: result

strategy_refineB

Refine existing strategy based on feedback.

Reads strategy, refines based on feedback, re-validates.

Args: name: Strategy name to refine feedback: Feedback/issues to address focus_area: Area to focus refinement (default: general) max_iterations: Maximum refinement iterations (default: 3)

Returns: Dict with status, name, iterations, changes

Inputs: name (required), feedback (required), focus_area, max_iterations. Returns: object

strategy_suggest_improvementsB

Get specific improvement suggestions for a trading strategy.

Analyzes current performance and recommends concrete changes to test.

Args: strategy_name: Name of the strategy to analyze pair: Trading pair to test on (e.g., 'BTCUSDT')

Returns: Detailed improvement recommendations with expected impact

Inputs: strategy_name (required), pair (required). Returns: result

trading_live_cancelB

Cancel a running live/paper trading session.

Args: session_id: Session ID to cancel paper_mode: True if paper trading session, False if live

Returns: Dict with cancellation status

Inputs: session_id (required), paper_mode. Returns: object

trading_live_checkA

Check if jesse-live plugin is installed and available.

Returns: Dict with 'available' boolean and optional 'error' message

Inputs: no named parameters. Returns: object

trading_live_equityA

Get real-time equity curve (P&L) for a session.

Args: session_id: Session ID from_ms: Start time in milliseconds (optional) to_ms: End time in milliseconds (optional)

Returns: Dict with equity curve data points

Inputs: session_id (required), from_ms, to_ms. Returns: object

trading_live_logsC

Get logs from a live trading session.

Args: session_id: Session ID log_type: Log type filter ("all", "info", "error", "warning")

Returns: Dict with log entries

Inputs: session_id (required), log_type. Returns: object

trading_live_ordersC

Get orders from a live trading session.

Args: session_id: Session ID

Returns: Dict with orders list

Inputs: session_id (required). Returns: object

trading_live_paperA

Start a PAPER trading session (simulated, no real money).

Paper trading simulates trades without using real funds. Use this to test strategies before going live.

Args: strategy: Strategy name (must exist in strategies directory) symbol: Trading symbol (e.g., "BTC-USDT") timeframe: Candle timeframe (e.g., "1h", "4h", "1d") exchange: Exchange name (e.g., "Binance", "Bybit") exchange_api_key_id: ID of stored exchange API key in Jesse notification_api_key_id: ID of stored notification config (optional) debug_mode: Enable debug logging

Returns: Dict with session_id and status, or error details

Inputs: strategy (required), symbol (required), timeframe (required), exchange (required), +3 more. Returns: object

trading_live_realA

Start LIVE trading with REAL MONEY.

⚠️ WARNING: This will execute real trades with real funds. ⚠️

RISKS:

  • Your funds are at risk of total loss

  • Automated trading can result in significant losses

  • No guarantee of profit

REQUIREMENTS:

  1. Thoroughly backtested strategy

  2. Successful paper trading first

  3. Understanding of strategy's risk profile

  4. Capital you can afford to lose

Args: strategy: Strategy name (must exist in strategies directory) symbol: Trading symbol (e.g., "BTC-USDT") timeframe: Candle timeframe (e.g., "1h", "4h", "1d") exchange: Exchange name (e.g., "Binance", "Bybit") exchange_api_key_id: ID of stored exchange API key in Jesse confirmation: REQUIRED: Must be exactly "I UNDERSTAND THE RISKS" notification_api_key_id: ID of stored notification config (optional) debug_mode: Enable debug logging permission: Agent permission level ("paper_only", "confirm_required", "full_autonomous")

Returns: Dict with session_id and status, or error details

Inputs: strategy (required), symbol (required), timeframe (required), exchange (required), +5 more. Returns: object

trading_live_sessionsB

Get list of live trading sessions.

Args: limit: Maximum number of sessions to return (default: 50) offset: Offset for pagination (default: 0)

Returns: Dict with sessions list

Inputs: limit, offset. Returns: object

trading_live_statusB

Get status of a specific live trading session.

Args: session_id: Session ID to check

Returns: Dict with session details and current status

Inputs: session_id (required). Returns: object

trading_paper_equity_historyB

Get equity curve data for a paper trading session.

Args: session_id: Session ID resolution: Resolution of equity curve data (default: '1h')

Returns: Dict with equity_curve containing timestamp, equity, drawdown data

Inputs: session_id (required), resolution. Returns: object

trading_paper_listA

List all paper trading sessions.

Returns: Dict with sessions list and total count

Inputs: no named parameters. Returns: object

trading_paper_metricsB

Get calculated performance metrics for a paper trading session.

Args: session_id: Session ID

Returns: Dict with metrics: total_return, sharpe_ratio, max_drawdown, win_rate, etc.

Inputs: session_id (required). Returns: object

trading_paper_startA

Start a paper trading session.

Paper trading simulates trades without using real funds. Use this to test strategies before going live.

Args: strategy: Strategy name (e.g., 'SMACrossover', 'DayTrader') symbol: Trading pair (e.g., 'BTC-USDT') timeframe: Candle timeframe (default: '1h') exchange: Exchange name (default: 'Binance') exchange_api_key_id: ID of stored exchange API key in Jesse starting_balance: Initial capital (default: 10000) leverage: Futures leverage (default: 1) fee: Trading fee rate (default: 0.001) session_id: Optional custom session ID (auto-generated if not provided)

Returns: Dict with session_id, status, and configuration

Inputs: strategy (required), symbol (required), timeframe, exchange, +5 more. Returns: object

trading_paper_statusB

Get current status of a paper trading session.

Args: session_id: Session ID to check

Returns: Dict with session status, equity, positions, and metrics

Inputs: session_id (required). Returns: object

trading_paper_stopA

Stop a paper trading session and return final metrics.

Args: session_id: Session ID to stop

Returns: Dict with stopped_at, duration, and final_metrics

Inputs: session_id (required). Returns: object

trading_paper_tradesB

Get trades executed in a paper trading session.

Args: session_id: Session ID limit: Maximum number of trades to return (default: 100) offset: Offset for pagination (default: 0)

Returns: Dict with total_trades and trades list

Inputs: session_id (required), limit, offset. Returns: object

trading_paper_updateC

Update session parameters (limited to safe modifications).

Args: session_id: Session ID to update notes: Notes text to associate with session

Returns: Dict with update status

Inputs: session_id (required), notes. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.8/5.0

    Scored across 69 tools

    Disambiguation3/5

    The tool set has clear thematic grouping (backtesting, optimization, risk, trading, etc.), but within groups there is significant overlap and ambiguity. For example, backtest_comprehensive, backtesting_run, and benchmark_run all involve running backtests with unclear distinctions, and pairs_backtest, pairs_correlation, pairs_factors, pairs_regimes seem to target similar pairs trading analysis with fuzzy boundaries. Descriptions help somewhat, but agents may struggle to choose the right tool for specific tasks due to redundant functionality.

    Naming Consistency4/5

    Naming follows a consistent snake_case pattern throughout, with a clear prefix structure (e.g., backtest_, optimization_, risk_, trading_) that groups tools by domain. However, there are minor deviations like backtesting_import_candles vs. backtest_analyze_regimes (inconsistent use of 'backtest' vs. 'backtesting'), and some tools like alerts_send_notification or rate_limit_status don't follow the prefix convention, slightly breaking consistency.

    Tool Count2/5

    With 69 tools, the count is excessive for a single MCP server, even for a comprehensive trading platform. This creates cognitive overload and likely includes many tools that could be consolidated or omitted. A well-scoped server should typically have 3-15 tools; 69 feels bloated and indicates poor scoping, making it difficult for agents to navigate and use effectively.

    Completeness5/5

    The tool surface is remarkably complete for the trading strategy development and execution domain. It covers the full lifecycle: strategy creation, refinement, backtesting, optimization, risk analysis, monitoring, and live/paper trading. There are no obvious gaps; tools support CRUD operations for strategies, comprehensive analysis, and real-time trading workflows, ensuring agents can handle end-to-end tasks without dead ends.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that provides AI agents with financial tools including real-time quotes, backtesting, technical analysis, and multi-exchange data via a simple CLI interface.
      2
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that exposes trading analytics — technical indicators, portfolio state, risk metrics, and backtest results — as tools an LLM agent can call.
      5
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      MCP server that exposes the Backtest360 backtesting engine API as tools, enabling AI agents to conversationally discover indicators, build and validate strategies, run backtests, and read results.
      14
      82 PyPI
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      An MCP server for cryptocurrency trading via Freqtrade, enabling trade management, balance checks, strategy configuration, backtesting, and bot lifecycle control from any MCP-compatible AI agent.
      MIT