Jesse MCP Server

# Jesse-MCP Project Status - December 2025 ## Overview **Status**: ✅ **COMPLETE & READY FOR LLM INTEGRATION** Jesse-MCP is a production-ready MCP (Model Context Protocol) server that provides transparent access to Jesse's trading framework via **any LLM chat interface that supports MCP**. --- ## What We Have ### 17 Fully Implemented MCP Tools **Phase 1: Backtesting & Strategy** (6 tools) - ✅ `backtest` - Run single backtest - ✅ `strategy_list` - List available strategies - ✅ `strategy_read` - Read strategy code - ✅ `strategy_validate` - Validate code - ✅ `candles_import` - Download market data - ✅ `analyze_results` - Extract insights **Phase 3: Optimization** (4 tools) - ✅ `optimize` - Hyperparameter optimization - ✅ `walk_forward` - Overfitting detection - ✅ `backtest_batch` - Concurrent backtests - (analyze_results also used here) **Phase 4: Risk Analysis** (4 tools) - ✅ `monte_carlo` - Simulation analysis - ✅ `var_calculation` - Value at Risk - ✅ `stress_test` - Scenario testing - ✅ `risk_report` - Risk assessment **Phase 5: Pairs Trading & Advanced** (4 tools) - ✅ `correlation_matrix` - Asset correlations - ✅ `pairs_backtest` - Pairs trading - ✅ `factor_analysis` - Factor decomposition - ✅ `regime_detector` - Market regimes ### Infrastructure **✅ REST API Client** - Connects to Jesse on server2:8000 - Supports password-based and token-based authentication - All tools use REST API (no local imports needed) **✅ FastMCP Server** - Modern MCP protocol implementation - Async/await support - Proper tool discovery and invocation - Error handling and logging **✅ Environment Configuration** - `JESSE_URL` - Jesse API endpoint - `JESSE_PASSWORD` or `JESSE_API_TOKEN` - Authentication --- ## Recent Improvements (This Session) ### 1. Fixed Test Infrastructure **Issue**: Tests were using deprecated FastMCP Client API **Solution**: Updated to use `StdioTransport` with new API **Files**: `tests/test_server.py`, `tests/test_e2e.py` **Commit**: e74f227 ### 2. Enhanced Tool Documentation **Issue**: Tool docstrings weren't helpful for LLM orchestration **Solution**: Added detailed docstrings explaining: - What each tool does - When to use it - Typical workflow patterns - Example parameters **Files**: `jesse_mcp/server.py` **Commit**: 0d53539 ### 3. Created LLM Integration Guide **Issue**: No clear explanation of how to use with LLMs **Solution**: Comprehensive guide explaining: - Architecture (MCP as transparent layer) - Typical conversation workflows - Tool sequences - Integration points **File**: `docs/USING_WITH_LLMS.md` **Commit**: e6420c1 --- ## Key Architecture ``` Any LLM (Claude, ChatGPT, etc.) ↓ MCP Protocol ↓ Jesse-MCP Server (17 tools) ↓ Jesse REST API (server2:8000) ``` **Critical Insight**: The MCP server is a **transparent protocol layer**. The LLM does the intelligent orchestration. **Example Flow**: ``` User: "Can you test if adding a volatility filter improves my EMA?" ↓ LLM decides to: 1. strategy_read("EMA") → understand current code 2. backtest("EMA", ...) → baseline metrics 3. backtest("EMA_vol", ...) → new variant 4. analyze_results() on both → compare ↓ LLM: "Yes! Volatility filter improved Sharpe from 1.2 to 1.45 (+20.8%)" ``` --- ## Workflow Examples ### Strategy Improvement ``` User → "Improve my strategy" LLM: strategy_read() → backtest() → analyze_results() → optimize() → backtest() → monte_carlo() → risk_report() → Recommendation ``` ### Risk Assessment ``` User → "Is my strategy risky?" LLM: backtest() → monte_carlo() → var_calculation() → stress_test() → risk_report() → "Here's your risk assessment..." ``` ### A/B Testing ``` User → "Test volatility filter vs original" LLM: backtest(original) → backtest(with_filter) → analyze_results(both) → "Winner: with_filter (+20%)" ``` --- ## What's NOT Here (And Why) ### No Separate Conversational Agent ❌ We didn't build a dedicated agent framework ✅ **Why**: Any MCP-compatible LLM IS the agent ✅ Users can use Claude, ChatGPT, or any MCP-supporting interface ### No New Strategy Tools ❌ We didn't add strategy_make() or strategy_write() ✅ **Why**: The REST API doesn't support dynamic strategy creation ✅ Focus on what Jesse actually provides ### No Anthropic-Specific Code ❌ We didn't hardcode Claude integration ✅ **Why**: MCP is language-agnostic ✅ Any LLM can use these tools --- ## Current Deliverables | Component | Status | Location | |-----------|--------|----------| | 17 MCP Tools | ✅ Complete | `jesse_mcp/server.py` | | REST API Client | ✅ Complete | `jesse_mcp/core/jesse_rest_client.py` | | Tool Documentation | ✅ Complete | Improved docstrings in server.py | | LLM Integration Guide | ✅ Complete | `docs/USING_WITH_LLMS.md` | | Test Suite | ✅ Fixed | `tests/` | | Authentication | ✅ Dual Method | Password or API token | | Error Handling | ✅ Robust | Try/except on all tools | --- ## How to Use ### 1. Start the MCP Server ```bash python -m jesse_mcp ``` ### 2. Configure Environment Variables ```bash JESSE_URL=http://server2:8000 JESSE_API_TOKEN=<your_token> ``` ### 3. Use with Any MCP-Compatible LLM - Claude with MCP support - ChatGPT with MCP support - Any future LLM that supports MCP protocol ### 4. Have Conversational Exchanges ``` You: "Can you improve my EMA strategy toward Sharpe 2.0?" LLM: [Calls tools to analyze, test, optimize, report] LLM: "Here's what I found..." ``` --- ## Quality Metrics ✅ **17/17 tools implemented** (100%) ✅ **All tools use REST API** (no local dependency) ✅ **Async/await support** for concurrent operations ✅ **Error handling** on all tool calls ✅ **Detailed docstrings** for LLM guidance ✅ **Dual authentication** methods supported ✅ **MCP protocol compliant** (works with any MCP client) --- ## The Badass Part The beauty of this architecture: 1. **Transparent**: MCP server is just a protocol bridge 2. **Language-Agnostic**: Works with any LLM that supports MCP 3. **Scalable**: Multiple users, one server, many different LLMs 4. **Simple**: No complex agent framework needed 5. **Powerful**: LLMs naturally orchestrate these tools through conversation **User talks naturally** → **LLM figures out which tools to call** → **Gets smart responses** --- ## Next Steps for Users ### Option A: Use with Claude 1. Install `npx -g mcp` 2. Configure jesse-mcp in MCP settings 3. Talk to Claude about your strategies ### Option B: Use with ChatGPT+ 1. Set up MCP server 2. Configure in ChatGPT settings 3. Same conversation interface ### Option C: Custom Integration 1. Implement MCP client in your language 2. Connect to jesse-mcp server 3. Send tool calls via MCP protocol --- ## Summary **jesse-mcp is a solid, transparent, MCP-compliant layer that gives any LLM the ability to help improve trading strategies through natural conversation.** The 17 tools are ready. The infrastructure is solid. The documentation is clear. All that's needed is an LLM with MCP support to orchestrate them. No complex agents. No proprietary frameworks. Just tools, protocols, and natural conversation. --- ## References - **Architecture**: See `docs/USING_WITH_LLMS.md` - **Tools**: See tool docstrings in `jesse_mcp/server.py` - **REST Client**: See `jesse_mcp/core/jesse_rest_client.py` - **Configuration**: See environment variable documentation