Spaces:
Running
Running
| import sys | |
| import json | |
| import logging | |
| from typing import Dict, Any, List | |
| # Load environment | |
| from dotenv import load_dotenv | |
| load_dotenv() | |
| from backend.alpaca_helper import AlpacaHelper | |
| from backend.risk_engine import RiskEngine | |
| from backend.agent import SentryThetaAgent | |
| # Configure basic logging to stderr so it doesn't corrupt stdout (which is used for JSON-RPC messages) | |
| logging.basicConfig( | |
| level=logging.INFO, | |
| format="%(asctime)s [%(levelname)s] %(name)s: %(message)s", | |
| stream=sys.stderr | |
| ) | |
| logger = logging.getLogger("SentryTheta.MCP") | |
| # Initialize backends | |
| alpaca = AlpacaHelper() | |
| risk_engine = RiskEngine() | |
| agent = SentryThetaAgent(alpaca, risk_engine) | |
| def get_tools_list() -> List[Dict[str, Any]]: | |
| return [ | |
| { | |
| "name": "get_portfolio_status", | |
| "description": "Fetch portfolio metrics (equity, cash, P&L) and current active options positions.", | |
| "inputSchema": { | |
| "type": "object", | |
| "properties": {} | |
| } | |
| }, | |
| { | |
| "name": "analyze_and_propose_trade", | |
| "description": "Analyze sentiment for a target stock and search options chains to propose a risk-checked option trade strategy.", | |
| "inputSchema": { | |
| "type": "object", | |
| "properties": { | |
| "ticker": { | |
| "type": "string", | |
| "description": "The stock ticker symbol (e.g. AAPL, MSFT, NVDA, SPY, QQQ)" | |
| } | |
| }, | |
| "required": ["ticker"] | |
| } | |
| }, | |
| { | |
| "name": "execute_option_order", | |
| "description": "Directly place an option contract trade order (buy/sell). Evaluates risk gates first.", | |
| "inputSchema": { | |
| "type": "object", | |
| "properties": { | |
| "symbol": { | |
| "type": "string", | |
| "description": "The OCC Option Symbol (e.g., AAPL260904C00220000)" | |
| }, | |
| "qty": { | |
| "type": "integer", | |
| "description": "Quantity of contracts to trade (each contract represents 100 shares)" | |
| }, | |
| "side": { | |
| "type": "string", | |
| "enum": ["buy", "sell"], | |
| "description": "Order side (buy to open/close or sell to open/close)" | |
| }, | |
| "price": { | |
| "type": "number", | |
| "description": "Approximate current premium price per contract (for risk engine evaluation)" | |
| } | |
| }, | |
| "required": ["symbol", "qty", "side", "price"] | |
| } | |
| }, | |
| { | |
| "name": "update_sentry_settings", | |
| "description": "Dynamically adjust options strategy risk engine thresholds.", | |
| "inputSchema": { | |
| "type": "object", | |
| "properties": { | |
| "max_position_size_pct": { | |
| "type": "number", | |
| "description": "Maximum size of a single trade as percentage of equity" | |
| }, | |
| "max_daily_drawdown_pct": { | |
| "type": "number", | |
| "description": "Maximum daily loss percentage threshold before trading is blocked" | |
| }, | |
| "stop_loss_pct": { | |
| "type": "number", | |
| "description": "Percentage loss threshold to auto-liquidate active positions" | |
| }, | |
| "take_profit_pct": { | |
| "type": "number", | |
| "description": "Percentage gain target to auto-harvest profits" | |
| } | |
| } | |
| } | |
| } | |
| ] | |
| def handle_tool_call(name: str, arguments: Dict[str, Any]) -> Dict[str, Any]: | |
| logger.info(f"Handling tool call: {name} with args {arguments}") | |
| if name == "get_portfolio_status": | |
| acc = alpaca.get_account_info() | |
| positions = alpaca.get_active_positions() | |
| status_txt = ( | |
| f"=== Portfolio Status (Mock Mode: {acc['is_mock']}) ===\n" | |
| f"Total Equity: ${acc['equity']:.2f}\n" | |
| f"Cash Balance: ${acc['cash']:.2f}\n" | |
| f"Buying Power: ${acc['buying_power']:.2f}\n" | |
| f"Today's P&L: ${acc['today_pl']:.2f} ({acc['today_plpc']*100:+.2f}%)\n\n" | |
| f"Active Options Contracts ({len(positions)}):\n" | |
| ) | |
| if not positions: | |
| status_txt += "- No active options positions." | |
| for pos in positions: | |
| status_txt += ( | |
| f"- {pos['symbol']}: {pos['side'].upper()} {pos['qty']}x {pos['type'].upper()} " | |
| f"Entry: ${pos['entry_price']:.2f} | Current: ${pos['current_price']:.2f} | " | |
| f"P&L: {pos['unrealized_pl']:+.2f} ({pos['unrealized_plpc']*100:+.1f}%)\n" | |
| ) | |
| return { | |
| "content": [{"type": "text", "text": status_txt}] | |
| } | |
| elif name == "analyze_and_propose_trade": | |
| ticker = arguments.get("ticker", "").upper().strip() | |
| if not ticker: | |
| return {"content": [{"type": "text", "text": "Error: Ticker symbol is required."}]} | |
| sentiment, analysis = agent.analyze_market_sentiment(ticker) | |
| proposal = agent.propose_options_trade(ticker, sentiment) | |
| result_txt = ( | |
| f"=== Market Analysis for {ticker} ===\n" | |
| f"Market Sentiment Score: {sentiment:+.2f}\n" | |
| f"LLM Sentiment Driver: {analysis}\n\n" | |
| ) | |
| if proposal: | |
| result_txt += ( | |
| f"=== Proposed Option Strategy ===\n" | |
| f"Strategy: {proposal['strategy']}\n" | |
| f"Contract Symbol: {proposal['symbol']}\n" | |
| f"Leg action: {proposal['side'].upper()} {proposal['qty']} contract(s)\n" | |
| f"Strike Price: ${proposal['strike']}\n" | |
| f"Expiration Date: {proposal['expiration']}\n" | |
| f"Est. Premium per Contract: ${proposal['premium']:.2f}\n" | |
| f"Total Capital Committed: ${proposal['total_value']:.2f}\n\n" | |
| ) | |
| # Check Risk | |
| acc = alpaca.get_account_info() | |
| approved, risk_reason = risk_engine.evaluate_trade( | |
| symbol=proposal["symbol"], | |
| qty=proposal["qty"], | |
| premium_per_contract=proposal["premium"], | |
| side=proposal["side"], | |
| account_info=acc | |
| ) | |
| result_txt += ( | |
| f"=== Sentry Risk Assessment ===\n" | |
| f"Status: {'APPROVED' if approved else 'REJECTED'}\n" | |
| f"Assessment Detail: {risk_reason}\n" | |
| ) | |
| else: | |
| result_txt += f"=== Proposed Option Strategy ===\nNo viable option strategy found in current chain for {ticker}." | |
| return { | |
| "content": [{"type": "text", "text": result_txt}] | |
| } | |
| elif name == "execute_option_order": | |
| symbol = arguments.get("symbol") | |
| qty = arguments.get("qty") | |
| side = arguments.get("side") | |
| price = arguments.get("price") | |
| # Check risk | |
| acc = alpaca.get_account_info() | |
| approved, risk_reason = risk_engine.evaluate_trade( | |
| symbol=symbol, | |
| qty=qty, | |
| premium_per_contract=price, | |
| side=side, | |
| account_info=acc | |
| ) | |
| if not approved: | |
| return { | |
| "content": [{"type": "text", "text": f"Execution Blocked by Risk Sentry. Reason: {risk_reason}"}] | |
| } | |
| # Execute | |
| res = alpaca.execute_options_trade( | |
| symbol=symbol, | |
| qty=qty, | |
| side=side, | |
| strategy_name="MCP Manual Order" | |
| ) | |
| if res["success"]: | |
| msg = ( | |
| f"Order successfully transmitted and filled!\n" | |
| f"Order ID: {res['order_id']}\n" | |
| f"Contract: {res['symbol']}\n" | |
| f"Action: {res['side'].upper()} {res['qty']} contract(s) filled (Status: {res['status']})." | |
| ) | |
| else: | |
| msg = f"Order execution failed on Alpaca: {res.get('error')}" | |
| return { | |
| "content": [{"type": "text", "text": msg}] | |
| } | |
| elif name == "update_sentry_settings": | |
| if "max_position_size_pct" in arguments: | |
| risk_engine.max_position_size_pct = float(arguments["max_position_size_pct"]) | |
| if "max_daily_drawdown_pct" in arguments: | |
| risk_engine.max_daily_drawdown_pct = float(arguments["max_daily_drawdown_pct"]) | |
| if "stop_loss_pct" in arguments: | |
| risk_engine.stop_loss_pct = float(arguments["stop_loss_pct"]) | |
| if "take_profit_pct" in arguments: | |
| risk_engine.take_profit_pct = float(arguments["take_profit_pct"]) | |
| msg = ( | |
| f"Risk settings updated successfully:\n" | |
| f"- Max Pos Size: {risk_engine.max_position_size_pct}%\n" | |
| f"- Max Daily Drawdown: {risk_engine.max_daily_drawdown_pct}%\n" | |
| f"- Stop Loss: {risk_engine.stop_loss_pct}%\n" | |
| f"- Take Profit: {risk_engine.take_profit_pct}%" | |
| ) | |
| return { | |
| "content": [{"type": "text", "text": msg}] | |
| } | |
| else: | |
| return {"content": [{"type": "text", "text": f"Error: Tool '{name}' not found."}]} | |
| def main(): | |
| logger.info("SentryTheta MCP Stdio Server started.") | |
| for line in sys.stdin: | |
| if not line.strip(): | |
| continue | |
| try: | |
| request = json.loads(line) | |
| # Ensure JSON-RPC protocol | |
| if "jsonrpc" not in request: | |
| continue | |
| req_id = request.get("id") | |
| method = request.get("method") | |
| # 1. Initialize | |
| if method == "initialize": | |
| response = { | |
| "jsonrpc": "2.0", | |
| "id": req_id, | |
| "result": { | |
| "protocolVersion": "2024-11-05", | |
| "capabilities": { | |
| "tools": {} | |
| }, | |
| "serverInfo": { | |
| "name": "sentrytheta-mcp", | |
| "version": "1.0.0" | |
| } | |
| } | |
| } | |
| # 2. List tools | |
| elif method == "tools/list": | |
| response = { | |
| "jsonrpc": "2.0", | |
| "id": req_id, | |
| "result": { | |
| "tools": get_tools_list() | |
| } | |
| } | |
| # 3. Call tool | |
| elif method == "tools/call": | |
| params = request.get("params", {}) | |
| tool_name = params.get("name") | |
| tool_args = params.get("arguments", {}) | |
| result = handle_tool_call(tool_name, tool_args) | |
| response = { | |
| "jsonrpc": "2.0", | |
| "id": req_id, | |
| "result": result | |
| } | |
| else: | |
| response = { | |
| "jsonrpc": "2.0", | |
| "id": req_id, | |
| "error": { | |
| "code": -32601, | |
| "message": f"Method '{method}' not found" | |
| } | |
| } | |
| # Send response to stdout | |
| sys.stdout.write(json.dumps(response) + "\n") | |
| sys.stdout.flush() | |
| except Exception as e: | |
| logger.error(f"Error handling JSON-RPC message: {e}") | |
| try: | |
| # Attempt to return general parse error | |
| sys.stdout.write(json.dumps({ | |
| "jsonrpc": "2.0", | |
| "error": { | |
| "code": -32700, | |
| "message": f"Parse error or execution failure: {str(e)}" | |
| } | |
| }) + "\n") | |
| sys.stdout.flush() | |
| except: | |
| pass | |
| if __name__ == "__main__": | |
| main() | |