app.py

#!/usr/bin/env python3
"""
Real MCP with Gradio Agent - Stock Analysis Platform
Comprehensive implementation with MCP server and Gradio interface
"""

import asyncio
import json
import logging
import os
from datetime import datetime, timedelta
from typing import Dict, List, Any, Optional
import traceback

# MCP and async imports
from mcp.server import Server
from mcp.server.models import InitializationOptions
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
import mcp.types as types

# Data analysis imports
import yfinance as yf
import pandas as pd
import numpy as np
from dataclasses import dataclass

# Gradio for web interface
import gradio as gr
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots

# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class StockAnalysis:
    """Data class for stock analysis results"""
    symbol: str
    company_name: str
    current_price: float
    ytd_return: float
    volatility: float
    investment_score: int
    recommendation: str
    risk_level: str
    sector: str
    market_cap: int

class StockAnalyzer:
    """Advanced stock analysis engine"""
    
    def __init__(self):
        self.cache = {}
        self.cache_timeout = 300  # 5 minutes
    
    def get_stock_data(self, symbol: str, period: str = "1y") -> Optional[pd.DataFrame]:
        """Get stock data with caching"""
        cache_key = f"{symbol}_{period}"
        current_time = datetime.now()
        
        if cache_key in self.cache:
            data, timestamp = self.cache[cache_key]
            if (current_time - timestamp).seconds < self.cache_timeout:
                return data
        
        try:
            stock = yf.Ticker(symbol)
            data = stock.history(period=period)
            self.cache[cache_key] = (data, current_time)
            return data
        except Exception as e:
            logger.error(f"Error fetching data for {symbol}: {e}")
            return None
    
    def calculate_technical_indicators(self, data: pd.DataFrame) -> Dict:
        """Calculate technical indicators"""
        if data.empty:
            return {}
        
        # Moving averages
        data['MA20'] = data['Close'].rolling(window=20).mean()
        data['MA50'] = data['Close'].rolling(window=50).mean()
        data['MA200'] = data['Close'].rolling(window=200).mean()
        
        # RSI
        delta = data['Close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
        rs = gain / loss
        data['RSI'] = 100 - (100 / (1 + rs))
        
        # Bollinger Bands
        data['BB_Middle'] = data['Close'].rolling(window=20).mean()
        bb_std = data['Close'].rolling(window=20).std()
        data['BB_Upper'] = data['BB_Middle'] + (bb_std * 2)
        data['BB_Lower'] = data['BB_Middle'] - (bb_std * 2)
        
        # MACD
        exp1 = data['Close'].ewm(span=12).mean()
        exp2 = data['Close'].ewm(span=26).mean()
        data['MACD'] = exp1 - exp2
        data['MACD_Signal'] = data['MACD'].ewm(span=9).mean()
        
        return {
            'rsi': data['RSI'].iloc[-1] if not data['RSI'].empty else 0,
            'macd': data['MACD'].iloc[-1] if not data['MACD'].empty else 0,
            'macd_signal': data['MACD_Signal'].iloc[-1] if not data['MACD_Signal'].empty else 0,
            'ma20': data['MA20'].iloc[-1] if not data['MA20'].empty else 0,
            'ma50': data['MA50'].iloc[-1] if not data['MA50'].empty else 0,
            'current_price': data['Close'].iloc[-1] if not data['Close'].empty else 0
        }
    
    def calculate_investment_score(self, symbol: str) -> Dict:
        """Calculate comprehensive investment score"""
        try:
            stock = yf.Ticker(symbol)
            info = stock.info
            
            # Get YTD data
            ytd_start = datetime(2025, 1, 1)
            ytd_data = stock.history(start=ytd_start.strftime("%Y-%m-%d"))
            
            if ytd_data.empty:
                return {'error': f'No YTD data available for {symbol}'}
            
            # Calculate YTD return
            ytd_return = ((ytd_data['Close'].iloc[-1] - ytd_data['Close'].iloc[0]) / 
                         ytd_data['Close'].iloc[0]) * 100
            
            # Get 1-year data for volatility
            year_data = self.get_stock_data(symbol, "1y")
            volatility = 0
            max_drawdown = 0
            
            if year_data is not None and not year_data.empty:
                returns = year_data['Close'].pct_change().dropna()
                volatility = returns.std() * np.sqrt(252) * 100  # Annualized volatility
                
                # Calculate max drawdown
                rolling_max = year_data['Close'].expanding().max()
                drawdown = (year_data['Close'] - rolling_max) / rolling_max
                max_drawdown = drawdown.min() * 100
            
            # Technical indicators
            technical = self.calculate_technical_indicators(year_data) if year_data is not None else {}
            
            # Fundamental metrics
            pe_ratio = info.get('trailingPE', 0) or 0
            forward_pe = info.get('forwardPE', 0) or 0
            peg_ratio = info.get('pegRatio', 0) or 0
            roe = info.get('returnOnEquity', 0) or 0
            profit_margin = info.get('profitMargins', 0) or 0
            revenue_growth = info.get('revenueGrowth', 0) or 0
            
            # Calculate investment score (0-100)
            score = 50  # Base score
            
            # YTD Performance (30% weight)
            if ytd_return > 25:
                score += 25
            elif ytd_return > 15:
                score += 20
            elif ytd_return > 5:
                score += 15
            elif ytd_return > 0:
                score += 10
            elif ytd_return > -10:
                score += 5
            else:
                score -= 15
            
            # Technical indicators (25% weight)
            rsi = technical.get('rsi', 50)
            if 30 <= rsi <= 70:  # Not oversold or overbought
                score += 12
            elif rsi < 30:  # Oversold - potential buy
                score += 8
            elif rsi > 70:  # Overbought - caution
                score -= 5
            
            # MACD signal
            macd = technical.get('macd', 0)
            macd_signal = technical.get('macd_signal', 0)
            if macd > macd_signal:  # Bullish signal
                score += 8
            else:
                score -= 3
            
            # Valuation (25% weight)
            if pe_ratio and 8 < pe_ratio < 20:
                score += 15
            elif pe_ratio and pe_ratio < 8:
                score += 20  # Very undervalued
            elif pe_ratio and 20 < pe_ratio < 30:
                score += 5
            elif pe_ratio and pe_ratio > 35:
                score -= 10
            
            # Growth and profitability (20% weight)
            if revenue_growth and revenue_growth > 0.20:
                score += 15
            elif revenue_growth and revenue_growth > 0.10:
                score += 10
            elif revenue_growth and revenue_growth > 0.05:
                score += 5
            
            if profit_margin and profit_margin > 0.15:
                score += 5
            elif profit_margin and profit_margin > 0.10:
                score += 3
            
            # Risk adjustment
            if volatility < 15:
                score += 5
            elif volatility > 35:
                score -= 10
            
            if max_drawdown > -15:
                score += 5
            elif max_drawdown < -30:
                score -= 8
            
            # Ensure score bounds
            score = max(0, min(100, score))
            
            # Determine risk level and recommendation
            if volatility < 15:
                risk_level = "Low"
            elif volatility < 25:
                risk_level = "Medium"
            else:
                risk_level = "High"
            
            if score >= 80:
                recommendation = "Strong Buy"
            elif score >= 70:
                recommendation = "Buy"
            elif score >= 60:
                recommendation = "Hold"
            elif score >= 50:
                recommendation = "Weak Hold"
            else:
                recommendation = "Sell"
            
            return {
                'symbol': symbol.upper(),
                'company_name': info.get('longName', 'N/A'),
                'current_price': ytd_data['Close'].iloc[-1],
                'ytd_return': ytd_return,
                'volatility': volatility,
                'max_drawdown': max_drawdown,
                'pe_ratio': pe_ratio,
                'forward_pe': forward_pe,
                'peg_ratio': peg_ratio,
                'roe': roe * 100 if roe else 0,
                'profit_margin': profit_margin * 100 if profit_margin else 0,
                'revenue_growth': revenue_growth * 100 if revenue_growth else 0,
                'investment_score': score,
                'recommendation': recommendation,
                'risk_level': risk_level,
                'sector': info.get('sector', 'N/A'),
                'industry': info.get('industry', 'N/A'),
                'market_cap': info.get('marketCap', 0),
                'technical_indicators': technical,
                'analysis_date': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
            
        except Exception as e:
            logger.error(f"Error calculating investment score for {symbol}: {e}")
            return {'error': f'Error analyzing {symbol}: {str(e)}'}

# Initialize the stock analyzer
analyzer = StockAnalyzer()

# MCP Server Setup
server = Server("stock-analysis-mcp")

@server.list_tools()
async def handle_list_tools() -> List[Tool]:
    """List available MCP tools"""
    return [
        Tool(
            name="get_stock_price",
            description="Get current stock price and basic info",
            inputSchema={
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Stock symbol (e.g., AAPL)"}
                },
                "required": ["symbol"]
            }
        ),
        Tool(
            name="analyze_stock_comprehensive",
            description="Comprehensive stock analysis with technical and fundamental metrics",
            inputSchema={
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Stock symbol (e.g., AAPL)"}
                },
                "required": ["symbol"]
            }
        ),
        Tool(
            name="compare_stocks_ytd",
            description="Compare multiple stocks for YTD 2025 performance",
            inputSchema={
                "type": "object",
                "properties": {
                    "symbols": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "List of stock symbols to compare"
                    }
                },
                "required": ["symbols"]
            }
        ),
        Tool(
            name="get_market_sector_analysis",
            description="Analyze stocks by sector performance",
            inputSchema={
                "type": "object",
                "properties": {
                    "symbols": {
                        "type": "array",
                        "items": {"type": "string"},
                        "description": "List of stock symbols to analyze by sector"
                    }
                },
                "required": ["symbols"]
            }
        )
    ]

@server.call_tool()
async def handle_call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextContent]:
    """Handle MCP tool calls"""
    try:
        if name == "get_stock_price":
            symbol = arguments.get("symbol", "").upper()
            if not symbol:
                return [TextContent(type="text", text="Error: Symbol is required")]
            
            stock = yf.Ticker(symbol)
            info = stock.info
            hist = stock.history(period="2d")
            
            if hist.empty:
                return [TextContent(type="text", text=f"Error: No data found for {symbol}")]
            
            current_price = hist['Close'].iloc[-1]
            prev_close = hist['Close'].iloc[-2] if len(hist) > 1 else current_price
            change = current_price - prev_close
            change_percent = (change / prev_close) * 100
            
            result = {
                "symbol": symbol,
                "company_name": info.get('longName', 'N/A'),
                "current_price": round(current_price, 2),
                "change": round(change, 2),
                "change_percent": round(change_percent, 2),
                "previous_close": round(prev_close, 2),
                "market_cap": info.get('marketCap', 0),
                "volume": hist['Volume'].iloc[-1],
                "sector": info.get('sector', 'N/A')
            }
            
            return [TextContent(type="text", text=json.dumps(result, indent=2))]
        
        elif name == "analyze_stock_comprehensive":
            symbol = arguments.get("symbol", "").upper()
            if not symbol:
                return [TextContent(type="text", text="Error: Symbol is required")]
            
            analysis = analyzer.calculate_investment_score(symbol)
            return [TextContent(type="text", text=json.dumps(analysis, indent=2))]
        
        elif name == "compare_stocks_ytd":
            symbols = arguments.get("symbols", [])
            if not symbols:
                return [TextContent(type="text", text="Error: Symbols list is required")]
            
            comparisons = []
            for symbol in symbols:
                analysis = analyzer.calculate_investment_score(symbol)
                if 'error' not in analysis:
                    comparisons.append(analysis)
            
            # Sort by investment score
            comparisons.sort(key=lambda x: x.get('investment_score', 0), reverse=True)
            
            result = {
                "comparison_results": comparisons,
                "winner": comparisons[0] if comparisons else None,
                "analysis_date": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
            
            return [TextContent(type="text", text=json.dumps(result, indent=2))]
        
        elif name == "get_market_sector_analysis":
            symbols = arguments.get("symbols", [])
            if not symbols:
                return [TextContent(type="text", text="Error: Symbols list is required")]
            
            sector_data = {}
            for symbol in symbols:
                analysis = analyzer.calculate_investment_score(symbol)
                if 'error' not in analysis:
                    sector = analysis.get('sector', 'Unknown')
                    if sector not in sector_data:
                        sector_data[sector] = []
                    sector_data[sector].append(analysis)
            
            # Calculate sector averages
            sector_summary = {}
            for sector, stocks in sector_data.items():
                avg_score = sum(s['investment_score'] for s in stocks) / len(stocks)
                avg_ytd = sum(s['ytd_return'] for s in stocks) / len(stocks)
                sector_summary[sector] = {
                    "average_score": round(avg_score, 1),
                    "average_ytd_return": round(avg_ytd, 2),
                    "stock_count": len(stocks),
                    "stocks": [s['symbol'] for s in stocks]
                }
            
            result = {
                "sector_analysis": sector_summary,
                "detailed_stocks": sector_data,
                "analysis_date": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
            
            return [TextContent(type="text", text=json.dumps(result, indent=2))]
        
        else:
            return [TextContent(type="text", text=f"Error: Unknown tool '{name}'")]
    
    except Exception as e:
        error_msg = f"Error executing tool '{name}': {str(e)}"
        logger.error(error_msg)
        return [TextContent(type="text", text=error_msg)]

# Gradio Interface Functions
def create_stock_chart(symbol: str):
    """Create interactive stock chart"""
    try:
        data = analyzer.get_stock_data(symbol, "6mo")
        if data is None or data.empty:
            return None
        
        fig = make_subplots(
            rows=2, cols=1,
            shared_xaxes=True,
            vertical_spacing=0.1,
            subplot_titles=(f'{symbol.upper()} Stock Price', 'Volume'),
            row_width=[0.7, 0.3]
        )
        
        # Candlestick chart
        fig.add_trace(
            go.Candlestick(
                x=data.index,
                open=data['Open'],
                high=data['High'],
                low=data['Low'],
                close=data['Close'],
                name="Price"
            ),
            row=1, col=1
        )
        
        # Moving averages
        if len(data) >= 20:
            data['MA20'] = data['Close'].rolling(window=20).mean()
            fig.add_trace(
                go.Scatter(x=data.index, y=data['MA20'], name='MA20', line=dict(color='orange')),
                row=1, col=1
            )
        
        if len(data) >= 50:
            data['MA50'] = data['Close'].rolling(window=50).mean()
            fig.add_trace(
                go.Scatter(x=data.index, y=data['MA50'], name='MA50', line=dict(color='blue')),
                row=1, col=1
            )
        
        # Volume
        fig.add_trace(
            go.Bar(x=data.index, y=data['Volume'], name='Volume', marker_color='lightblue'),
            row=2, col=1
        )
        
        fig.update_layout(
            title=f'{symbol.upper()} - Stock Analysis',
            xaxis_rangeslider_visible=False,
            height=600,
            showlegend=True
        )
        
        return fig
    except Exception as e:
        logger.error(f"Error creating chart for {symbol}: {e}")
        return None

def analyze_single_stock(symbol: str) -> tuple:
    """Analyze a single stock and return results"""
    if not symbol:
        return "Please enter a stock symbol", None, None
    
    try:
        analysis = analyzer.calculate_investment_score(symbol.upper())
        
        if 'error' in analysis:
            return f"Error: {analysis['error']}", None, None
        
        # Create formatted analysis text
        analysis_text = f"""
# 📊 Stock Analysis for {analysis['symbol']}

## 🏢 Company Information
- **Company**: {analysis['company_name']}
- **Sector**: {analysis['sector']}
- **Industry**: {analysis['industry']}
- **Market Cap**: ${analysis['market_cap']/1e9:.2f}B

## 💰 Current Performance
- **Current Price**: ${analysis['current_price']:.2f}
- **YTD 2025 Return**: {analysis['ytd_return']:+.2f}%
- **Investment Score**: {analysis['investment_score']}/100

## 📈 Investment Recommendation
- **Recommendation**: {analysis['recommendation']}
- **Risk Level**: {analysis['risk_level']}
- **Volatility**: {analysis['volatility']:.1f}%

## 🔍 Fundamental Metrics
- **P/E Ratio**: {analysis['pe_ratio']:.1f if analysis['pe_ratio'] else 'N/A'}
- **Forward P/E**: {analysis['forward_pe']:.1f if analysis['forward_pe'] else 'N/A'}
- **ROE**: {analysis['roe']:.1f}%
- **Profit Margin**: {analysis['profit_margin']:.1f}%
- **Revenue Growth**: {analysis['revenue_growth']:.1f}%

## 📊 Technical Indicators
- **RSI**: {analysis['technical_indicators'].get('rsi', 0):.1f}
- **MACD**: {analysis['technical_indicators'].get('macd', 0):.3f}

---
*Analysis Date: {analysis['analysis_date']}*
        """
        
        # Create chart
        chart = create_stock_chart(symbol)
        
        # Create comparison data for table
        comparison_df = pd.DataFrame([{
            'Metric': 'Investment Score',
            'Value': f"{analysis['investment_score']}/100",
            'Interpretation': analysis['recommendation']
        }, {
            'Metric': 'YTD Return',
            'Value': f"{analysis['ytd_return']:+.2f}%",
            'Interpretation': 'Strong' if analysis['ytd_return'] > 10 else 'Moderate' if analysis['ytd_return'] > 0 else 'Weak'
        }, {
            'Metric': 'Risk Level',
            'Value': analysis['risk_level'],
            'Interpretation': f"Volatility: {analysis['volatility']:.1f}%"
        }])
        
        return analysis_text, chart, comparison_df
        
    except Exception as e:
        error_msg = f"Error analyzing {symbol}: {str(e)}"
        logger.error(error_msg)
        return error_msg, None, None

def compare_multiple_stocks(symbols_input: str) -> tuple:
    """Compare multiple stocks"""
    if not symbols_input:
        return "Please enter stock symbols separated by commas", None, None
    
    try:
        symbols = [s.strip().upper() for s in symbols_input.split(',') if s.strip()]
        
        if len(symbols) < 2:
            return "Please enter at least 2 stock symbols for comparison", None, None
        
        comparisons = []
        for symbol in symbols:
            analysis = analyzer.calculate_investment_score(symbol)
            if 'error' not in analysis:
                comparisons.append(analysis)
        
        if not comparisons:
            return "No valid stock data found for the provided symbols", None, None
        
        # Sort by investment score
        comparisons.sort(key=lambda x: x['investment_score'], reverse=True)
        
        # Create comparison text
        comparison_text = f"# 🏆 Stock Comparison Results\n\n"
        comparison_text += f"**Analysis of {len(comparisons)} stocks:**\n\n"
        
        for i, stock in enumerate(comparisons[:5]):  # Top 5
            rank_emoji = ["🥇", "🥈", "🥉", "4️⃣", "5️⃣"][i]
            comparison_text += f"""
## {rank_emoji} {stock['symbol']} - {stock['company_name']}
- **Score**: {stock['investment_score']}/100
- **Recommendation**: {stock['recommendation']}
- **YTD Return**: {stock['ytd_return']:+.2f}%
- **Current Price**: ${stock['current_price']:.2f}
- **Sector**: {stock['sector']}
- **Risk Level**: {stock['risk_level']}

"""
        
        # Create comparison DataFrame
        comparison_df = pd.DataFrame([{
            'Rank': i+1,
            'Symbol': stock['symbol'],
            'Company': stock['company_name'][:30] + '...' if len(stock['company_name']) > 30 else stock['company_name'],
            'Score': stock['investment_score'],
            'YTD Return %': f"{stock['ytd_return']:+.2f}",
            'Price': f"${stock['current_price']:.2f}",
            'Recommendation': stock['recommendation'],
            'Sector': stock['sector']
        } for i, stock in enumerate(comparisons)])
        
        # Create comparison chart
        fig = go.Figure()
        
        fig.add_trace(go.Bar(
            x=[s['symbol'] for s in comparisons],
            y=[s['investment_score'] for s in comparisons],
            text=[f"{s['investment_score']}" for s in comparisons],
            textposition='auto',
            marker_color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd'][:len(comparisons)]
        ))
        
        fig.update_layout(
            title='Investment Score Comparison',
            xaxis_title='Stock Symbol',
            yaxis_title='Investment Score (0-100)',
            height=400
        )
        
        return comparison_text, fig, comparison_df
        
    except Exception as e:
        error_msg = f"Error comparing stocks: {str(e)}"
        logger.error(error_msg)
        return error_msg, None, None

# Create Gradio Interface
def create_gradio_app():
    """Create the Gradio web interface"""
    
    with gr.Blocks(title="🚀 MCP Stock Analysis Agent", theme=gr.themes.Soft()) as app:
        gr.Markdown("""
        # 🚀 Real MCP with Gradio Agent - Stock Analysis Platform
        
        Advanced stock analysis powered by MCP (Model Context Protocol) with comprehensive technical and fundamental analysis.
        
        ## Features:
        - 📊 Real-time stock data analysis
        - 🎯 AI-powered investment scoring
        - 📈 Technical indicator analysis
        - 🏆 Multi-stock comparison
        - 📉 Interactive charts and visualizations
        """)
        
        with gr.Tabs():
            # Single Stock Analysis Tab
            with gr.Tab("📊 Single Stock Analysis"):
                with gr.Row():
                    with gr.Column(scale=1):
                        stock_input = gr.Textbox(
                            label="Stock Symbol",
                            placeholder="Enter symbol (e.g., AAPL, MSFT, GOOGL)",
                            value="AAPL"
                        )
                        analyze_btn = gr.Button("🔍 Analyze Stock", variant="primary")
                    
                with gr.Row():
                    with gr.Column(scale=2):
                        analysis_output = gr.Markdown(label="Analysis Results")
                    with gr.Column(scale=1):
                        metrics_table = gr.Dataframe(
                            label="Key Metrics",
                            headers=["Metric", "Value", "Interpretation"]
                        )
                
                stock_chart = gr.Plot(label="Stock Chart")
            
            # Stock Comparison Tab
            with gr.Tab("🏆 Stock Comparison"):
                with gr.Row():
                    with gr.Column():
                        stocks_input = gr.Textbox(
                            label="Stock Symbols (comma-separated)",
                            placeholder="Enter symbols (e.g., AAPL, MSFT, GOOGL, TSLA)",
                            value="AAPL, MSFT, GOOGL"
                        )
                        compare_btn = gr.Button("🔍 Compare Stocks", variant="primary")
                
                comparison_output = gr.Markdown(label="Comparison Results")
                comparison_chart = gr.Plot(label="Comparison Chart")
                comparison_table = gr.Dataframe(
                    label="Detailed Comparison",
                    headers=["Rank", "Symbol", "Company", "Score", "YTD Return %", "Price", "Recommendation", "Sector"]
                )
            
            # MCP Tools Tab
            with gr.Tab("🛠️ MCP Tools"):
                gr.Markdown("""
                ## Available MCP Tools:
                
                1. **get_stock_price** - Get current stock price and basic info
                2. **analyze_stock_comprehensive** - Comprehensive analysis with scoring
                3. **compare_stocks_ytd** - Compare multiple stocks for YTD performance
                4. **get_market_sector_analysis** - Analyze stocks by sector
                
                These tools can be called programmatically via the MCP protocol.
                """)
                
                with gr.Row():
                    mcp_tool_select = gr.Dropdown(
                        choices=["get_stock_price", "analyze_stock_comprehensive", "compare_stocks_ytd", "get_market_sector_analysis"],
                        label="Select MCP Tool",
                        value="get_stock_price"
                    )
                    mcp_symbol_input = gr.Textbox(
                        label="Symbol/Parameters",
                        placeholder="AAPL or AAPL,MSFT,GOOGL for comparison",
                        value="AAPL"
                    )
                
                mcp_execute_btn = gr.Button("⚡ Execute MCP Tool", variant="secondary")
                mcp_output = gr.JSON(label="MCP Tool Response")
        
        # Event handlers
        analyze_btn.click(
            fn=analyze_single_stock,
            inputs=[stock_input],
            outputs=[analysis_output, stock_chart, metrics_table]
        )
        
        compare_btn.click(
            fn=compare_multiple_stocks,
            inputs=[stocks_input],
            outputs=[comparison_output, comparison_chart, comparison_table]
        )
        
        def execute_mcp_tool(tool_name, params):
            """Execute MCP tool from Gradio interface"""
            try:
                if tool_name == "get_stock_price":
                    arguments = {"symbol": params.strip()}
                elif tool_name == "analyze_stock_comprehensive":
                    arguments = {"symbol": params.strip()}
                elif tool_name in ["compare_stocks_ytd", "get_market_sector_analysis"]:
                    symbols = [s.strip() for s in params.split(',')]
                    arguments = {"symbols": symbols}
                else:
                    return {"error": f"Unknown tool: {tool_name}"}
                
                # Simulate MCP tool execution
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                result = loop.run_until_complete(handle_call_tool(tool_name, arguments))
                loop.close()
                
                # Parse the result
                if result and len(result) > 0:
                    response_text = result[0].text
                    try:
                        return json.loads(response_text)
                    except json.JSONDecodeError:
                        return {"response": response_text}
                else:
                    return {"error": "No response from MCP tool"}
                    
            except Exception as e:
                return {"error": f"Error executing MCP tool: {str(e)}"}
        
        mcp_execute_btn.click(
            fn=execute_mcp_tool,
            inputs=[mcp_tool_select, mcp_symbol_input],
            outputs=[mcp_output]
        )
        
        # Add footer
        gr.Markdown("""
        ---
        ### 🔧 Technical Details:
        - **MCP Protocol**: Model Context Protocol for tool integration
        - **Data Source**: Yahoo Finance API via yfinance
        - **Analysis Engine**: Custom investment scoring algorithm
        - **Visualization**: Plotly interactive charts
        - **Interface**: Gradio web framework
        
        *This platform provides educational analysis and should not be considered financial advice.*
        """)
    
    return app

# MCP Server Runner
async def run_mcp_server():
    """Run the MCP server"""
    logger.info("Starting MCP Stock Analysis Server...")
    async with stdio_server() as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            InitializationOptions(
                server_name="stock-analysis-mcp",
                server_version="1.0.0",
                capabilities=server.get_capabilities()
            )
        )

# Enhanced Portfolio Analysis
class PortfolioAnalyzer:
    """Advanced portfolio analysis with risk metrics"""
    
    def __init__(self):
        self.analyzer = analyzer
    
    def calculate_portfolio_metrics(self, symbols: List[str], weights: List[float] = None) -> Dict:
        """Calculate comprehensive portfolio metrics"""
        try:
            if not weights:
                weights = [1.0 / len(symbols)] * len(symbols)  # Equal weights
            
            portfolio_data = []
            total_weight = sum(weights)
            weights = [w / total_weight for w in weights]  # Normalize weights
            
            # Get data for all stocks
            returns_data = []
            for symbol in symbols:
                data = self.analyzer.get_stock_data(symbol, "1y")
                if data is not None and not data.empty:
                    returns = data['Close'].pct_change().dropna()
                    returns_data.append(returns)
                    
                    # Individual stock analysis
                    analysis = self.analyzer.calculate_investment_score(symbol)
                    if 'error' not in analysis:
                        portfolio_data.append(analysis)
            
            if not returns_data:
                return {'error': 'No valid data for portfolio analysis'}
            
            # Calculate portfolio returns
            portfolio_returns = pd.DataFrame(returns_data).T
            portfolio_returns.columns = symbols[:len(returns_data)]
            
            # Portfolio daily returns
            weighted_returns = (portfolio_returns * weights[:len(returns_data)]).sum(axis=1)
            
            # Portfolio metrics
            portfolio_return = weighted_returns.mean() * 252 * 100  # Annualized return
            portfolio_volatility = weighted_returns.std() * np.sqrt(252) * 100  # Annualized volatility
            sharpe_ratio = portfolio_return / portfolio_volatility if portfolio_volatility > 0 else 0
            
            # Portfolio max drawdown
            cumulative_returns = (1 + weighted_returns).cumprod()
            rolling_max = cumulative_returns.expanding().max()
            drawdown = (cumulative_returns - rolling_max) / rolling_max
            max_drawdown = drawdown.min() * 100
            
            # Risk metrics
            var_95 = np.percentile(weighted_returns, 5) * 100  # 5% VaR
            
            # Correlation matrix
            correlation_matrix = portfolio_returns.corr().to_dict()
            
            # Weighted portfolio score
            portfolio_score = sum(stock['investment_score'] * weight 
                                for stock, weight in zip(portfolio_data, weights[:len(portfolio_data)]))
            
            return {
                'portfolio_return': portfolio_return,
                'portfolio_volatility': portfolio_volatility,
                'sharpe_ratio': sharpe_ratio,
                'max_drawdown': max_drawdown,
                'var_95': var_95,
                'portfolio_score': portfolio_score,
                'correlation_matrix': correlation_matrix,
                'individual_stocks': portfolio_data,
                'weights': dict(zip(symbols[:len(weights)], weights)),
                'analysis_date': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
            
        except Exception as e:
            logger.error(f"Error in portfolio analysis: {e}")
            return {'error': f'Portfolio analysis error: {str(e)}'}

# Enhanced Gradio Interface with Portfolio Analysis
def create_enhanced_gradio_app():
    """Create enhanced Gradio interface with portfolio analysis"""
    
    portfolio_analyzer = PortfolioAnalyzer()
    
    def analyze_portfolio(symbols_input: str, weights_input: str = "") -> tuple:
        """Analyze a portfolio of stocks"""
        try:
            if not symbols_input:
                return "Please enter stock symbols", None, None, None
            
            symbols = [s.strip().upper() for s in symbols_input.split(',') if s.strip()]
            
            # Parse weights if provided
            weights = None
            if weights_input.strip():
                try:
                    weights = [float(w.strip()) for w in weights_input.split(',')]
                    if len(weights) != len(symbols):
                        return "Number of weights must match number of symbols", None, None, None
                except ValueError:
                    return "Invalid weights format. Use comma-separated numbers (e.g., 0.4, 0.3, 0.3)", None, None, None
            
            # Analyze portfolio
            portfolio_analysis = portfolio_analyzer.calculate_portfolio_metrics(symbols, weights)
            
            if 'error' in portfolio_analysis:
                return f"Error: {portfolio_analysis['error']}", None, None, None
            
            # Create analysis text
            analysis_text = f"""
# 📊 Portfolio Analysis Results

## 🏦 Portfolio Overview
- **Number of Holdings**: {len(symbols)}
- **Portfolio Score**: {portfolio_analysis['portfolio_score']:.1f}/100
- **Analysis Date**: {portfolio_analysis['analysis_date']}

## 📈 Performance Metrics
- **Expected Annual Return**: {portfolio_analysis['portfolio_return']:+.2f}%
- **Annual Volatility**: {portfolio_analysis['portfolio_volatility']:.2f}%
- **Sharpe Ratio**: {portfolio_analysis['sharpe_ratio']:.2f}
- **Maximum Drawdown**: {portfolio_analysis['max_drawdown']:.2f}%
- **Value at Risk (95%)**: {portfolio_analysis['var_95']:.2f}%

## 🏭 Portfolio Composition
"""
            
            for symbol, weight in portfolio_analysis['weights'].items():
                analysis_text += f"- **{symbol}**: {weight:.1%}\n"
            
            analysis_text += "\n## 📊 Individual Stock Performance\n"
            
            for stock in portfolio_analysis['individual_stocks']:
                weight = portfolio_analysis['weights'].get(stock['symbol'], 0)
                analysis_text += f"""
### {stock['symbol']} - {stock['company_name']} ({weight:.1%})
- **Score**: {stock['investment_score']}/100 | **YTD**: {stock['ytd_return']:+.2f}%
- **Price**: ${stock['current_price']:.2f} | **Sector**: {stock['sector']}
"""
            
            # Create portfolio composition chart
            fig_composition = go.Figure(data=[go.Pie(
                labels=list(portfolio_analysis['weights'].keys()),
                values=list(portfolio_analysis['weights'].values()),
                hole=0.3
            )])
            fig_composition.update_layout(title="Portfolio Composition", height=400)
            
            # Create performance comparison chart
            stocks_data = portfolio_analysis['individual_stocks']
            fig_performance = go.Figure()
            
            fig_performance.add_trace(go.Bar(
                x=[s['symbol'] for s in stocks_data],
                y=[s['ytd_return'] for s in stocks_data],
                name='YTD Return %',
                text=[f"{s['ytd_return']:+.1f}%" for s in stocks_data],
                textposition='auto'
            ))
            
            fig_performance.update_layout(
                title='Individual Stock YTD Performance',
                xaxis_title='Stock Symbol',
                yaxis_title='YTD Return (%)',
                height=400
            )
            
            # Create portfolio metrics table
            metrics_df = pd.DataFrame([
                {'Metric': 'Portfolio Score', 'Value': f"{portfolio_analysis['portfolio_score']:.1f}/100"},
                {'Metric': 'Expected Return', 'Value': f"{portfolio_analysis['portfolio_return']:+.2f}%"},
                {'Metric': 'Volatility', 'Value': f"{portfolio_analysis['portfolio_volatility']:.2f}%"},
                {'Metric': 'Sharpe Ratio', 'Value': f"{portfolio_analysis['sharpe_ratio']:.2f}"},
                {'Metric': 'Max Drawdown', 'Value': f"{portfolio_analysis['max_drawdown']:.2f}%"},
                {'Metric': 'VaR (95%)', 'Value': f"{portfolio_analysis['var_95']:.2f}%"}
            ])
            
            return analysis_text, fig_composition, fig_performance, metrics_df
            
        except Exception as e:
            error_msg = f"Error analyzing portfolio: {str(e)}"
            logger.error(error_msg)
            return error_msg, None, None, None
    
    with gr.Blocks(title="🚀 Advanced MCP Stock Analysis Agent", theme=gr.themes.Soft()) as app:
        gr.Markdown("""
        # 🚀 Advanced MCP Stock Analysis Agent
        
        **Real Model Context Protocol (MCP) implementation with comprehensive stock analysis**
        
        Features: Real-time data • AI scoring • Technical analysis • Portfolio optimization • Risk metrics
        """)
        
        with gr.Tabs():
            # Single Stock Analysis Tab
            with gr.Tab("📊 Stock Analysis"):
                with gr.Row():
                    with gr.Column(scale=1):
                        stock_input = gr.Textbox(
                            label="📈 Stock Symbol",
                            placeholder="AAPL, MSFT, GOOGL, etc.",
                            value="AAPL"
                        )
                        analyze_btn = gr.Button("🔍 Analyze Stock", variant="primary", size="lg")
                    
                with gr.Row():
                    with gr.Column(scale=2):
                        analysis_output = gr.Markdown()
                    with gr.Column(scale=1):
                        metrics_table = gr.Dataframe(label="📊 Key Metrics")
                
                stock_chart = gr.Plot(label="📈 Interactive Chart")
            
            # Portfolio Analysis Tab
            with gr.Tab("🏦 Portfolio Analysis"):
                with gr.Row():
                    with gr.Column():
                        portfolio_symbols = gr.Textbox(
                            label="📊 Portfolio Symbols (comma-separated)",
                            placeholder="AAPL, MSFT, GOOGL, TSLA, NVDA",
                            value="AAPL, MSFT, GOOGL"
                        )
                        portfolio_weights = gr.Textbox(
                            label="⚖️ Weights (optional, comma-separated)",
                            placeholder="0.4, 0.3, 0.3 (leave empty for equal weights)",
                            value=""
                        )
                        portfolio_btn = gr.Button("🔍 Analyze Portfolio", variant="primary", size="lg")
                
                portfolio_output = gr.Markdown()
                
                with gr.Row():
                    portfolio_composition = gr.Plot(label="🥧 Portfolio Composition")
                    portfolio_performance = gr.Plot(label="📊 Performance Comparison")
                
                portfolio_metrics = gr.Dataframe(label="📈 Portfolio Metrics")
            
            # Stock Comparison Tab
            with gr.Tab("🏆 Stock Comparison"):
                with gr.Row():
                    with gr.Column():
                        stocks_input = gr.Textbox(
                            label="🔍 Stock Symbols (comma-separated)",
                            placeholder="AAPL, MSFT, GOOGL, TSLA, NVDA",
                            value="AAPL, MSFT, GOOGL"
                        )
                        compare_btn = gr.Button("⚡ Compare Stocks", variant="primary", size="lg")
                
                comparison_output = gr.Markdown()
                comparison_chart = gr.Plot(label="📊 Comparison Chart")
                comparison_table = gr.Dataframe(label="📋 Detailed Comparison")
            
            # MCP Server Tools Tab
            with gr.Tab("🛠️ MCP Server"):
                gr.Markdown("""
                ## 🔧 MCP (Model Context Protocol) Tools
                
                This tab demonstrates the MCP server capabilities:
                """)
                
                with gr.Row():
                    with gr.Column():
                        mcp_tool_select = gr.Dropdown(
                            choices=[
                                "get_stock_price",
                                "analyze_stock_comprehensive", 
                                "compare_stocks_ytd",
                                "get_market_sector_analysis"
                            ],
                            label="🛠️ Select MCP Tool",
                            value="analyze_stock_comprehensive"
                        )
                        mcp_symbol_input = gr.Textbox(
                            label="📊 Parameters",
                            placeholder="AAPL or AAPL,MSFT,GOOGL",
                            value="AAPL"
                        )
                        mcp_execute_btn = gr.Button("⚡ Execute MCP Tool", variant="secondary")
                
                mcp_output = gr.JSON(label="📋 MCP Response")
                
                gr.Markdown("""
                ### 📡 MCP Server Information:
                - **Server Name**: stock-analysis-mcp
                - **Version**: 1.0.0
                - **Protocol**: stdio
                - **Tools**: 4 available tools for stock analysis
                """)
        
        # Event handlers
        analyze_btn.click(
            fn=analyze_single_stock,
            inputs=[stock_input],
            outputs=[analysis_output, stock_chart, metrics_table]
        )
        
        portfolio_btn.click(
            fn=analyze_portfolio,
            inputs=[portfolio_symbols, portfolio_weights],
            outputs=[portfolio_output, portfolio_composition, portfolio_performance, portfolio_metrics]
        )
        
        compare_btn.click(
            fn=compare_multiple_stocks,
            inputs=[stocks_input],
            outputs=[comparison_output, comparison_chart, comparison_table]
        )
        
        def execute_mcp_tool(tool_name, params):
            """Execute MCP tool from Gradio interface"""
            try:
                if tool_name == "get_stock_price":
                    arguments = {"symbol": params.strip()}
                elif tool_name == "analyze_stock_comprehensive":
                    arguments = {"symbol": params.strip()}
                elif tool_name in ["compare_stocks_ytd", "get_market_sector_analysis"]:
                    symbols = [s.strip() for s in params.split(',') if s.strip()]
                    arguments = {"symbols": symbols}
                else:
                    return {"error": f"Unknown tool: {tool_name}"}
                
                # Execute MCP tool
                loop = asyncio.new_event_loop()
                asyncio.set_event_loop(loop)
                result = loop.run_until_complete(handle_call_tool(tool_name, arguments))
                loop.close()
                
                # Parse the result
                if result and len(result) > 0:
                    response_text = result[0].text
                    try:
                        parsed_result = json.loads(response_text)
                        parsed_result["_mcp_tool"] = tool_name
                        parsed_result["_execution_time"] = datetime.now().isoformat()
                        return parsed_result
                    except json.JSONDecodeError:
                        return {
                            "response": response_text,
                            "_mcp_tool": tool_name,
                            "_execution_time": datetime.now().isoformat()
                        }
                else:
                    return {"error": "No response from MCP tool"}
                    
            except Exception as e:
                return {
                    "error": f"Error executing MCP tool: {str(e)}",
                    "_mcp_tool": tool_name,
                    "_execution_time": datetime.now().isoformat()
                }
        
        mcp_execute_btn.click(
            fn=execute_mcp_tool,
            inputs=[mcp_tool_select, mcp_symbol_input],
            outputs=[mcp_output]
        )
        
        # Footer
        gr.Markdown("""
        ---
        ## 🚀 System Architecture
        
        **MCP Server**: Implements Model Context Protocol for tool integration  
        **Analysis Engine**: Advanced scoring algorithm with 15+ metrics  
        **Data Pipeline**: Real-time Yahoo Finance integration  
        **Risk Engine**: Portfolio optimization and risk analytics  
        **Visualization**: Interactive Plotly charts and dashboards  
        
        *Educational platform - not financial advice. Always consult professionals.*
        """)
    
    return app

# Main execution functions
def main():
    """Main function to run the application"""
    import argparse
    
    parser = argparse.ArgumentParser(description="MCP Stock Analysis Agent")
    parser.add_argument("--mode", choices=["mcp", "gradio", "both"], default="both",
                       help="Run mode: mcp (server only), gradio (web interface), or both")
    parser.add_argument("--port", type=int, default=7860, help="Gradio server port")
    parser.add_argument("--share", action="store_true", help="Share Gradio interface publicly")
    
    args = parser.parse_args()
    
    if args.mode == "mcp":
        # Run MCP server only
        asyncio.run(run_mcp_server())
    
    elif args.mode == "gradio":
        # Run Gradio interface only
        app = create_enhanced_gradio_app()
        app.launch(server_port=args.port, share=args.share)
    
    else:
        # Run both MCP server and Gradio interface
        print("🚀 Starting MCP Stock Analysis Agent...")
        print("📊 MCP Server will run in background")
        print(f"🌐 Gradio Interface will be available at http://localhost:{args.port}")
        
        # Start Gradio interface (MCP server runs on-demand)
        app = create_enhanced_gradio_app()
        app.launch(server_port=args.port, share=args.share)

if __name__ == "__main__":
    main()