Jesse MCP Server
The Jesse MCP Server exposes Jesse's algorithmic trading framework to LLM agents via 47 tools, covering backtesting, strategy management, optimization, risk analysis, pairs trading, live/paper trading, and monitoring.
Backtesting & Data
Run single or batch (concurrent) backtests with configurable strategy, symbol, timeframe, leverage, fees, and hyperparameters
Import candle data from exchanges
Validate strategy code without saving
Check Jesse API health and supported exchanges
Run benchmarks to measure backtest execution performance
Strategy Management
Create, refine, and delete strategies with iterative AI-powered refinement
List strategies, read source code, and retrieve metadata (version, certification)
Manage async strategy creation jobs (poll status, cancel)
Optimization & Analysis
Bayesian hyperparameter optimization (Optuna)
Walk-forward analysis to detect overfitting
Deep backtest result analysis for performance insights
Risk Analysis
Monte Carlo simulations for statistical robustness testing
Value at Risk (VaR) via historical, parametric, and Monte Carlo methods
Stress testing under extreme scenarios (market crash, flash crash, etc.)
Comprehensive risk reports combining VaR, Monte Carlo, and stress tests
Portfolio risk analysis, leverage risk assessment, hedging recommendations, and drawdown recovery analysis
Pairs Trading & Market Analysis
Cross-asset correlation matrix analysis
Pairs trading backtests with mean reversion strategies
Factor decomposition and market regime detection (HMM)
Live & Paper Trading
Start/stop paper and real-money live trading sessions (with strict warnings for real trading)
Monitor sessions: status, orders, equity curve, logs, trades, and performance metrics
Check jesse-live plugin availability
AI-Powered Agent Tools
Strategy improvement suggestions and side-by-side strategy comparison
Pair selection optimization and optimization impact analysis
Comprehensive backtests, cross-timeframe comparisons, quick parameter optimization, regime-aware analysis, and statistical significance validation
Market Monitoring & Reporting
Daily market scans for trading opportunities
Fear & Greed Index sentiment monitoring
Current market risk identification with severity levels
Backtest history analysis, strategy performance aggregation, and weekly activity reports
Utilities
Send notifications via ntfy.sh
Cache management (stats, clear specific or all caches)
Rate limit monitoring and async job management
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Jesse MCP Server Run a backtest for my TrendFollower strategy on BTC/USDT for the last 6 months"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Jesse MCP Server
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-mcpuvx (recommended for running directly)
uvx jesse-mcpArch Linux (AUR)
yay -S jesse-mcp
# or
paru -S jesse-mcpFrom 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 --helpEnvironment Variables
Variable | Description | Default |
| Jesse REST API URL |
|
| Jesse UI password | (required) |
| Pre-generated API token | (alternative to password) |
| 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 |
| Run single backtest with specified parameters |
| List available strategies |
| Read strategy source code |
| Validate strategy code |
Phase 2: Data & Analysis
Tool | Description |
| Download candle data from exchanges |
| Run concurrent multi-asset backtests |
| Extract insights from backtest results |
| Walk-forward analysis for overfitting detection |
Phase 3: Optimization
Tool | Description |
| Optimize hyperparameters using Optuna |
Phase 4: Risk Analysis
Tool | Description |
| Monte Carlo simulations for risk analysis |
| Value at Risk (historical, parametric, Monte Carlo) |
| Test under extreme market scenarios |
| Comprehensive risk assessment |
Phase 5: Pairs Trading
Tool | Description |
| Cross-asset correlation analysis |
| Backtest pairs trading strategies |
| Decompose returns into systematic factors |
| Identify market regimes and transitions |
Agent Tools (15)
Specialized tools for autonomous trading workflows:
Tool | Description |
| AI-powered strategy enhancement suggestions |
| Compare multiple strategies side-by-side |
| Optimize pairs trading selection |
| Analyze impact of optimization changes |
| Portfolio-level risk analysis |
| Advanced stress testing |
| Leverage risk assessment |
| Hedging recommendations |
| Drawdown recovery analysis |
| Full backtest with all metrics |
| Compare performance across timeframes |
| Quick parameter optimization |
| Backtest with Monte Carlo analysis |
| Regime-aware backtest analysis |
| Statistical significance validation |
Community Tools (5)
Browse, compare, and inspect community strategies from jesse.trade:
Tool | Description |
| List available backtest periods on jesse.trade |
| Browse strategies sorted by performance metrics |
| Detailed backtest metrics for a specific strategy |
| Full Python source code for a strategy |
| 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_mcpStatus: 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 serverAdd to OpenCode
Add to ~/.config/opencode/opencode.json:
{
"mcp": {
"jesse-mcp-dev": {
"type": "remote",
"url": "http://localhost:8100/mcp",
"enabled": true
}
}
}Documentation
Using with LLMs - How to use with MCP-compatible LLMs
Production Deployment - Production deployment guide
Jesse Setup - Jesse integration setup
Agent System - Agent architecture
AGENTS.md - Development guidelines for AI agents
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.shLicense
MIT License - see LICENSE file for details.
Publishing
This package uses GitHub Actions with PyPI trusted publishing. To release a new version:
Update version in
pyproject.tomlandjesse_mcp/__init__.pyCreate a git tag:
git tag v1.x.xPush tag:
git push origin v1.x.xCreate GitHub release - automatically publishes to PyPI
Available Tools
69 toolsalerts_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:
backtest(strategy="EMA_original", ...)
backtest(strategy="EMA_with_filter", ...)
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:
backtest() -> get result
analyze_results(result) -> understand what happened
monte_carlo() -> validate with simulation
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:
Thoroughly backtested strategy
Successful paper trading first
Understanding of strategy's risk profile
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
Scored across 69 tools
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 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.
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.
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
Related MCP Connectors
MCP server exposing the Backtest360 engine API as tools for AI agents.
Trading MCP server for AI agents, with live market data, account reads and controlled execution.
MCP server for OpenMM — exposes market data, account, trading, and strategy tools to AI agents
Research-only MCP server: your AI as a quant research desk. 90 tools, no trades, no brokers.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that provides AI agents with financial tools including real-time quotes, backtesting, technical analysis, and multi-exchange data via a simple CLI interface.2MIT
- AlicenseAqualityDmaintenanceAn MCP server that exposes trading analytics — technical indicators, portfolio state, risk metrics, and backtest results — as tools an LLM agent can call.5MIT

backtest360-mcpofficial
AlicenseAqualityCmaintenanceMCP 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.1482 PyPIMIT- AlicenseNot gradedqualityCmaintenanceAn 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