Jesse MCP Server

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.

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

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

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.

Read strategy source code

Validate strategy code without saving

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

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)

Cancel async strategy creation job.

Args: job_id: Job identifier to cancel

Returns: Dict with status, job_id

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

Delete a strategy.

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

Returns: Dict with status, name

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

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

Download candle data from exchange via Jesse REST API

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

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.

Perform walk-forward analysis to detect overfitting

Run multiple backtests concurrently for strategy comparison

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

Generate Monte Carlo simulations for comprehensive risk analysis

Calculate Value at Risk using multiple methods

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

Generate comprehensive risk assessment and recommendations

Analyze cross-asset correlations and identify pairs trading opportunities

Backtest pairs trading strategies

Decompose returns into systematic factors

Identify market regimes and transitions

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

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

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

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

Check if jesse-live plugin is installed and available.

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

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

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

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

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

Get status of a specific live trading session.

Args: session_id: Session ID to check

Returns: Dict with session details and current status

Get orders from a live trading session.

Args: session_id: Session ID

Returns: Dict with orders list

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

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

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

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

Get current status of a paper trading session.

Args: session_id: Session ID to check

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

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

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

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.

List all paper trading sessions.

Returns: Dict with sessions list and total count

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Get current market sentiment from Fear & Greed Index.

Returns: Fear & Greed score and rating with historical context

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

Identify current market risks and warning signs.

Returns: List of identified risks with severity levels

Analyze recent backtest history from Jesse database.

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

Returns: Backtest history with metrics and trends

Analyze strategy performance across all backtests.

Returns: Performance metrics aggregated by strategy

Generate weekly backtest activity report.

Returns: Formatted weekly report with summaries and insights

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