fix: resolve MCP server tracking and risk metrics display issues

Resolved two critical UI display issues in the portfolio analysis application:

Issue 1: MCP Server Count Displaying as Zero
- Updated MCPCall model to accept both 'mcp' and 'mcp_server' field names
using Pydantic validation_alias for backwards compatibility
- Modified workflow to create proper MCPCall model instances instead of
plain dictionaries
- Added populate_by_name configuration to model for flexible field naming

Issue 2: Risk Metrics Showing Raw Dictionary Structures
- Implemented format_risk_metrics() function to properly handle nested
Pydantic model structures (VaRResult, CVaRResult, RiskMetrics)
- Added financial formatting following industry best practices:
* Currency values with commas and 2 decimal places
* Percentages with 2 decimal places
* Ratios with 3 decimal places
- Included user-friendly interpretations for VaR and CVaR metrics
- Added star rating system for Sharpe and Sortino ratios

Technical improvements:
- Applied Pydantic V2 best practices for model serialisation
- Added comprehensive test suite (test_fixes.py)
- Created documentation (FIXES_SUMMARY.md)
- Maintained backwards compatibility with existing data structures

Files modified:
- backend/models/agent_state.py: MCPCall model with validation_alias
- backend/agents/workflow.py: MCPCall instance creation
- app.py: Risk metrics formatting and display logic

FIXES_SUMMARY.md

@@ -0,0 +1,291 @@
+# Implementation Summary: MCP Tracking and Risk Metrics Fixes
+
+## Overview
+Successfully implemented two critical fixes to improve MCP server tracking and risk metrics display in the Portfolio Intelligence Platform.
+
+## Fix 1: MCP Tracking Field Name Mismatch
+
+### Problem
+- Workflow created dicts with `"mcp"` key
+- MCPCall model expected `"mcp_server"` field
+- app.py checked for `"mcp_server"` in dicts
+- Result: MCP server count always showed 0
+
+### Solution Implemented
+
+#### 1. Updated MCPCall Model (`backend/models/agent_state.py`)
+```python
+class MCPCall(BaseModel):
+    """Record of an MCP tool call.
+
+    Accepts both 'mcp_server' and 'mcp' field names for backward compatibility.
+    """
+
+    model_config = {"populate_by_name": True}
+
+    mcp_server: str = Field(..., validation_alias="mcp", description="MCP server name")
+    tool_name: str = Field(..., validation_alias="tool", description="Tool called")
+    # ... other fields
+```
+
+**Key Changes:**
+- Added `model_config = {"populate_by_name": True}` to enable alias support
+- Added `validation_alias="mcp"` to `mcp_server` field
+- Added `validation_alias="tool"` to `tool_name` field
+- Model now accepts both old (`"mcp"`) and new (`"mcp_server"`) field names
+
+#### 2. Updated Workflow (`backend/agents/workflow.py`)
+```python
+# Import MCPCall
+from backend.models.agent_state import AgentState, MCPCall
+
+# Phase 1: Create proper MCPCall instances
+state["mcp_calls"].extend([
+    MCPCall.model_validate({"mcp": "yahoo_finance", "tool": "get_quote"}).model_dump(),
+    MCPCall.model_validate({"mcp": "yahoo_finance", "tool": "get_historical_data"}).model_dump(),
+    MCPCall.model_validate({"mcp": "fmp", "tool": "get_company_profile"}).model_dump(),
+    MCPCall.model_validate({"mcp": "trading_mcp", "tool": "get_technical_indicators"}).model_dump(),
+    MCPCall.model_validate({"mcp": "fred", "tool": "get_economic_series"}).model_dump(),
+])
+
+# Phase 2: Create proper MCPCall instances
+state["mcp_calls"].extend([
+    MCPCall.model_validate({"mcp": "portfolio_optimizer_mcp", "tool": "optimize_hrp"}).model_dump(),
+    MCPCall.model_validate({"mcp": "portfolio_optimizer_mcp", "tool": "optimize_black_litterman"}).model_dump(),
+    MCPCall.model_validate({"mcp": "portfolio_optimizer_mcp", "tool": "optimize_mean_variance"}).model_dump(),
+    MCPCall.model_validate({"mcp": "risk_analyzer_mcp", "tool": "analyze_risk"}).model_dump(),
+])
+```
+
+**Key Changes:**
+- Changed from plain dicts to `MCPCall.model_validate()` calls
+- Model validates and converts `"mcp"` to `"mcp_server"`
+- `model_dump()` returns dict with proper `"mcp_server"` key
+- app.py can now correctly count unique MCP servers
+
+### Expected Output
+```
+🔧 MCP Servers Called
+Used 6 MCP servers: fmp, fred, portfolio_optimizer_mcp, risk_analyzer_mcp, trading_mcp, yahoo_finance
+```
+
+## Fix 2: Risk Metrics Formatting
+
+### Problem
+- Generic key-value display for risk metrics
+- Nested dict structures (VaR, CVaR) displayed as unhelpful text
+- No formatting for monetary values or percentages
+- No interpretations for risk metrics
+
+### Solution Implemented
+
+#### 1. Created `format_risk_metrics()` Function (`app.py`)
+```python
+def format_risk_metrics(risk_data: Dict[str, Any], portfolio_value: float) -> str:
+    """Format risk analysis metrics for financial UI display.
+
+    Args:
+        risk_data: Risk analysis results from risk_analyzer_mcp
+        portfolio_value: Total portfolio value for percentage calculations
+
+    Returns:
+        Formatted markdown string with risk metrics
+    """
+    # Handles nested VaR structure
+    # Handles nested CVaR structure
+    # Formats volatility, Sharpe ratio, Sortino ratio, max drawdown
+    # Adds star ratings for performance metrics
+    # Includes interpretations for each metric
+```
+
+**Key Features:**
+- Proper handling of nested dict structures
+- Monetary values formatted with $ and commas: `$1,119.58`
+- Percentages formatted with 2 decimals: `3.90%`
+- Star ratings for Sharpe/Sortino ratios: `⭐⭐⭐`
+- User-friendly interpretations for each metric
+
+#### 2. Created `get_rating_stars()` Helper Function (`app.py`)
+```python
+def get_rating_stars(value: float, metric_type: str = "sharpe") -> str:
+    """Get star rating for Sharpe or Sortino ratio.
+
+    Sharpe Ratio Thresholds:
+    - ⭐⭐⭐⭐⭐ >= 3.0 (Exceptional)
+    - ⭐⭐⭐⭐ >= 2.0 (Excellent)
+    - ⭐⭐⭐ >= 1.0 (Good)
+    - ⭐⭐ >= 0.5 (Fair)
+    - ⭐ > 0 (Poor)
+    """
+```
+
+#### 3. Updated Risk Analysis Section (`app.py`)
+```python
+# Risk Analysis
+if state.get('risk_analysis'):
+    output.append("\n## ⚠️ Risk Metrics\n")
+    risk = state['risk_analysis']
+    if isinstance(risk, dict):
+        # Calculate total portfolio value for percentage context
+        portfolio_value = sum(h.get('market_value', 0) for h in holdings)
+        formatted_risk = format_risk_metrics(risk, portfolio_value)
+        if formatted_risk:
+            output.append(formatted_risk)
+        else:
+            # Fallback to generic display if formatting returns nothing
+            # ... fallback code
+```
+
+### Expected Output
+```
+⚠️ Risk Metrics
+
+**Value at Risk (VaR) - 95% Confidence, 1-Day Horizon**
+- Maximum Expected Loss: $1,119.58 (3.90% of portfolio)
+- *Interpretation: With 95% confidence, maximum expected loss over 1 day is $1,119.58*
+
+**Conditional Value at Risk (CVaR) - 95% Confidence**
+- Expected Shortfall: $1,409.97 (4.91% of portfolio)
+- *Interpretation: If losses exceed VaR threshold, average expected loss is $1,409.97*
+
+**Risk-Adjusted Performance**
+- Annual Volatility: 39.30%
+- Sharpe Ratio: 0.839 ⭐⭐
+- Sortino Ratio: 1.256 ⭐⭐⭐
+- Maximum Drawdown: -39.10%
+```
+
+## Files Modified
+
+1. **backend/models/agent_state.py**
+   - Added Pydantic validation_alias to MCPCall model
+   - Enabled populate_by_name in model config
+   - Supports both old and new field names
+
+2. **backend/agents/workflow.py**
+   - Imported MCPCall model
+   - Changed from plain dicts to MCPCall instances
+   - Added get_historical_data to Phase 1 tracking
+   - Updated MCP server names for Phase 2
+
+3. **app.py**
+   - Created format_risk_metrics() function
+   - Created get_rating_stars() helper function
+   - Updated risk analysis section to use new formatter
+   - Added fallback for edge cases
+
+## Testing
+
+Created comprehensive test suite (`test_fixes.py`) that verifies:
+
+1. **MCPCall Validation Alias**
+   - Accepts both `"mcp"` and `"mcp_server"` field names
+   - model_dump() produces dicts with `"mcp_server"` key
+   - Backwards compatibility maintained
+
+2. **Risk Metrics Formatting**
+   - Nested VaR/CVaR structures formatted correctly
+   - Monetary values use $ and commas
+   - Percentages formatted with proper precision
+   - Star ratings display correctly
+   - All key sections present in output
+
+3. **Star Rating System**
+   - Sharpe ratio thresholds work correctly
+   - Sortino ratio thresholds work correctly
+   - Edge cases handled
+
+### Test Results
+```
+✅ All MCPCall validation tests passed!
+✅ All risk metrics formatting tests passed!
+✅ All star rating tests passed!
+```
+
+## Verification Steps
+
+To verify the fixes work in the live application:
+
+1. **Start the application:**
+   ```bash
+   python app.py
+   ```
+
+2. **Enter a test portfolio:**
+   ```
+   AAPL 50
+   TSLA 25
+   NVDA $5000
+   ```
+
+3. **Click "Analyse Portfolio"**
+
+4. **Verify MCP Tracking:**
+   - Look for "🔧 MCP Servers Called" section
+   - Should show: "Used 6 MCP servers: fmp, fred, portfolio_optimizer_mcp, risk_analyzer_mcp, trading_mcp, yahoo_finance"
+   - Previously showed: "Used 0 MCP servers"
+
+5. **Verify Risk Metrics:**
+   - Look for "⚠️ Risk Metrics" section
+   - Should show formatted VaR with dollar amount and percentage
+   - Should show formatted CVaR with interpretation
+   - Should show star ratings for Sharpe and Sortino ratios
+   - Previously showed: generic key-value pairs with dict objects as strings
+
+## Design Patterns Used
+
+1. **Pydantic Validation Alias Pattern**
+   - Enables field name migration without breaking changes
+   - Allows gradual refactoring of codebase
+   - Maintains backwards compatibility
+
+2. **Financial UI Formatting Pattern**
+   - Separates data structure from display format
+   - Handles nested structures gracefully
+   - Provides context and interpretation for users
+   - Follows financial industry best practices
+
+3. **Defensive Programming**
+   - Fallback to generic display if formatting fails
+   - Type checking for nested structures
+   - Handles missing or unexpected data gracefully
+
+## Follow-Up Recommendations
+
+1. **MCP Tracking Enhancements:**
+   - Add duration_ms tracking for performance monitoring
+   - Add error tracking for failed MCP calls
+   - Consider adding result size tracking
+
+2. **Risk Metrics Enhancements:**
+   - Add color coding for risk levels (red/yellow/green)
+   - Add comparison to benchmarks
+   - Add historical risk trends
+   - Consider adding risk score visualisations
+
+3. **Testing:**
+   - Add integration tests with actual MCP calls
+   - Add UI snapshot tests for Gradio interface
+   - Add performance benchmarks
+
+4. **Documentation:**
+   - Add user guide for interpreting risk metrics
+   - Add developer guide for adding new MCP servers
+   - Add architecture diagram showing data flow
+
+## Compliance
+
+All changes follow the project guidelines:
+- British English spelling (analyse, optimise)
+- Google-style docstrings with type hints
+- No emojis in code (only in user-facing UI)
+- Conventional commit style ready
+- No Claude Code attribution in code
+
+## Conclusion
+
+Both fixes successfully implemented and tested. The application now:
+1. Correctly tracks and displays MCP server usage
+2. Provides professional, user-friendly risk metrics formatting
+3. Maintains backwards compatibility
+4. Follows financial UI best practices

app.py

@@ -119,6 +119,136 @@ async def run_analysis(portfolio_text: str) -> str:
         return f"❌ **Error during analysis**: {str(e)}\n\nPlease check your API keys in .env file and try again."
 
 
+def format_risk_metrics(risk_data: Dict[str, Any], portfolio_value: float) -> str:
+    """Format risk analysis metrics for financial UI display.
+
+    Args:
+        risk_data: Risk analysis results from risk_analyzer_mcp
+        portfolio_value: Total portfolio value for percentage calculations
+
+    Returns:
+        Formatted markdown string with risk metrics
+    """
+    output = []
+
+    # VaR (Value at Risk)
+    if "var" in risk_data:
+        var_data = risk_data["var"]
+        if isinstance(var_data, dict):
+            confidence = var_data.get("confidence_level", 0.95) * 100
+            horizon = var_data.get("time_horizon", 1)
+            var_value = var_data.get("value", 0)
+            var_pct = var_data.get("percentage", 0) * 100
+
+            output.append(f"**Value at Risk (VaR) - {confidence:.0f}% Confidence, {horizon}-Day Horizon**\n")
+            output.append(f"- Maximum Expected Loss: ${abs(var_value):,.2f} ({var_pct:.2f}% of portfolio)\n")
+            output.append(f"- *Interpretation: With {confidence:.0f}% confidence, maximum expected loss over {horizon} day is ${abs(var_value):,.2f}*\n")
+        elif isinstance(var_data, (int, float)):
+            output.append(f"**Value at Risk (VaR)**: ${abs(var_data):,.2f}\n")
+
+    # CVaR (Conditional Value at Risk)
+    if "cvar" in risk_data:
+        cvar_data = risk_data["cvar"]
+        if isinstance(cvar_data, dict):
+            confidence = cvar_data.get("confidence_level", 0.95) * 100
+            cvar_value = cvar_data.get("value", 0)
+            cvar_pct = cvar_data.get("percentage", 0) * 100
+
+            output.append(f"\n**Conditional Value at Risk (CVaR) - {confidence:.0f}% Confidence**\n")
+            output.append(f"- Expected Shortfall: ${abs(cvar_value):,.2f} ({cvar_pct:.2f}% of portfolio)\n")
+            output.append(f"- *Interpretation: If losses exceed VaR threshold, average expected loss is ${abs(cvar_value):,.2f}*\n")
+        elif isinstance(cvar_data, (int, float)):
+            output.append(f"**Conditional Value at Risk (CVaR)**: ${abs(cvar_data):,.2f}\n")
+
+    # Risk-Adjusted Performance Metrics
+    has_performance_metrics = any(k in risk_data for k in ["volatility", "sharpe_ratio", "sortino_ratio", "max_drawdown"])
+    if has_performance_metrics:
+        output.append("\n**Risk-Adjusted Performance**\n")
+
+        # Volatility
+        if "volatility" in risk_data:
+            vol = risk_data["volatility"]
+            if isinstance(vol, dict):
+                annual_vol = vol.get("annual", 0) * 100
+                output.append(f"- Annual Volatility: {annual_vol:.2f}%\n")
+            elif isinstance(vol, (int, float)):
+                output.append(f"- Annual Volatility: {vol * 100:.2f}%\n")
+
+        # Sharpe Ratio
+        if "sharpe_ratio" in risk_data:
+            sharpe = risk_data["sharpe_ratio"]
+            if isinstance(sharpe, (int, float)):
+                stars = get_rating_stars(sharpe, metric_type="sharpe")
+                output.append(f"- Sharpe Ratio: {sharpe:.3f} {stars}\n")
+
+        # Sortino Ratio
+        if "sortino_ratio" in risk_data:
+            sortino = risk_data["sortino_ratio"]
+            if isinstance(sortino, (int, float)):
+                stars = get_rating_stars(sortino, metric_type="sortino")
+                output.append(f"- Sortino Ratio: {sortino:.3f} {stars}\n")
+
+        # Maximum Drawdown
+        if "max_drawdown" in risk_data:
+            mdd = risk_data["max_drawdown"]
+            if isinstance(mdd, (int, float)):
+                output.append(f"- Maximum Drawdown: {mdd * 100:.2f}%\n")
+
+    # Additional risk metrics (if any)
+    other_keys = set(risk_data.keys()) - {"var", "cvar", "volatility", "sharpe_ratio", "sortino_ratio", "max_drawdown"}
+    if other_keys:
+        output.append("\n**Additional Risk Metrics**\n")
+        for key in sorted(other_keys):
+            value = risk_data[key]
+            if isinstance(value, (int, float)):
+                output.append(f"- {key.replace('_', ' ').title()}: {value:.2f}\n")
+            elif isinstance(value, str):
+                output.append(f"- {key.replace('_', ' ').title()}: {value}\n")
+
+    return ''.join(output)
+
+
+def get_rating_stars(value: float, metric_type: str = "sharpe") -> str:
+    """Get star rating for Sharpe or Sortino ratio.
+
+    Args:
+        value: Ratio value
+        metric_type: Type of metric ('sharpe' or 'sortino')
+
+    Returns:
+        Star rating string
+    """
+    if metric_type == "sharpe":
+        # Sharpe ratio thresholds
+        if value >= 3.0:
+            return "⭐⭐⭐⭐⭐"
+        elif value >= 2.0:
+            return "⭐⭐⭐⭐"
+        elif value >= 1.0:
+            return "⭐⭐⭐"
+        elif value >= 0.5:
+            return "⭐⭐"
+        elif value > 0:
+            return "⭐"
+        else:
+            return ""
+    elif metric_type == "sortino":
+        # Sortino ratio thresholds (typically higher than Sharpe)
+        if value >= 3.0:
+            return "⭐⭐⭐⭐⭐"
+        elif value >= 2.0:
+            return "⭐⭐⭐⭐"
+        elif value >= 1.0:
+            return "⭐⭐⭐"
+        elif value >= 0.5:
+            return "⭐⭐"
+        elif value > 0:
+            return "⭐"
+        else:
+            return ""
+    return ""
+
+
 def format_analysis_results(state: AgentState, holdings: List[Dict]) -> str:
     """Format workflow results for Gradio display.
 
@@ -163,11 +293,18 @@ def format_analysis_results(state: AgentState, holdings: List[Dict]) -> str:
         output.append("\n## ⚠️ Risk Metrics\n")
         risk = state['risk_analysis']
         if isinstance(risk, dict):
-            for key, value in risk.items():
-                if isinstance(value, (int, float)):
-                    output.append(f"- **{key}**: {value:.2f}\n")
-                else:
-                    output.append(f"- **{key}**: {value}\n")
+            # Calculate total portfolio value for percentage context
+            portfolio_value = sum(h.get('market_value', 0) for h in holdings)
+            formatted_risk = format_risk_metrics(risk, portfolio_value)
+            if formatted_risk:
+                output.append(formatted_risk)
+            else:
+                # Fallback to generic display if formatting returns nothing
+                for key, value in risk.items():
+                    if isinstance(value, (int, float)):
+                        output.append(f"- **{key}**: {value:.2f}\n")
+                    else:
+                        output.append(f"- **{key}**: {value}\n")
 
     # Optimization Results
     if state.get('optimisation_results'):

backend/agents/workflow.py

@@ -12,7 +12,7 @@ from datetime import datetime, timezone
 from decimal import Decimal
 
 from langgraph.graph import StateGraph, END
-from backend.models.agent_state import AgentState
+from backend.models.agent_state import AgentState, MCPCall
 from backend.agents.portfolio_analyst import PortfolioAnalystAgent
 
 logger = logging.getLogger(__name__)
@@ -201,10 +201,11 @@ class PortfolioAnalysisWorkflow:
 
             # Log MCP calls
             state["mcp_calls"].extend([
-                {"mcp": "yahoo_finance", "tool": "get_quote", "timestamp": datetime.now(timezone.utc).isoformat()},
-                {"mcp": "fmp", "tool": "get_company_profile", "count": len(tickers)},
-                {"mcp": "trading_mcp", "tool": "get_technical_indicators", "count": len(tickers)},
-                {"mcp": "fred", "tool": "get_economic_series", "count": 3},
+                MCPCall.model_validate({"mcp": "yahoo_finance", "tool": "get_quote"}).model_dump(),
+                MCPCall.model_validate({"mcp": "yahoo_finance", "tool": "get_historical_data"}).model_dump(),
+                MCPCall.model_validate({"mcp": "fmp", "tool": "get_company_profile"}).model_dump(),
+                MCPCall.model_validate({"mcp": "trading_mcp", "tool": "get_technical_indicators"}).model_dump(),
+                MCPCall.model_validate({"mcp": "fred", "tool": "get_economic_series"}).model_dump(),
             ])
 
             logger.info(f"PHASE 1 COMPLETE: Fetched data for {len(tickers)} assets")
@@ -302,10 +303,10 @@ class PortfolioAnalysisWorkflow:
 
             # Log MCP calls
             state["mcp_calls"].extend([
-                {"mcp": "portfolio_optimizer", "tool": "optimize_hrp"},
-                {"mcp": "portfolio_optimizer", "tool": "optimize_black_litterman"},
-                {"mcp": "portfolio_optimizer", "tool": "optimize_mean_variance"},
-                {"mcp": "risk_analyzer", "tool": "analyze_risk"},
+                MCPCall.model_validate({"mcp": "portfolio_optimizer_mcp", "tool": "optimize_hrp"}).model_dump(),
+                MCPCall.model_validate({"mcp": "portfolio_optimizer_mcp", "tool": "optimize_black_litterman"}).model_dump(),
+                MCPCall.model_validate({"mcp": "portfolio_optimizer_mcp", "tool": "optimize_mean_variance"}).model_dump(),
+                MCPCall.model_validate({"mcp": "risk_analyzer_mcp", "tool": "analyze_risk"}).model_dump(),
             ])
 
             logger.info("PHASE 2 COMPLETE: Optimizations and risk analysis done")

backend/models/agent_state.py

@@ -63,10 +63,15 @@ class AgentState(TypedDict):
 
 
 class MCPCall(BaseModel):
-    """Record of an MCP tool call."""
+    """Record of an MCP tool call.
 
-    mcp_server: str = Field(..., description="MCP server name")
-    tool_name: str = Field(..., description="Tool called")
+    Accepts both 'mcp_server' and 'mcp' field names for backward compatibility.
+    """
+
+    model_config = {"populate_by_name": True}
+
+    mcp_server: str = Field(..., validation_alias="mcp", description="MCP server name")
+    tool_name: str = Field(..., validation_alias="tool", description="Tool called")
     parameters: Dict[str, Any] = Field(default_factory=dict)
     result: Optional[Dict[str, Any]] = None
     error: Optional[str] = None

test_fixes.py

@@ -0,0 +1,119 @@
+"""Test script for MCP tracking and risk metrics formatting fixes."""
+
+from backend.models.agent_state import MCPCall
+from app import format_risk_metrics, get_rating_stars
+
+
+def test_mcp_call_validation_alias():
+    """Test that MCPCall accepts both 'mcp' and 'mcp_server' field names."""
+    print("Testing MCPCall validation_alias fix...\n")
+
+    # Test 1: Create MCPCall with 'mcp' key (old format)
+    call1 = MCPCall.model_validate({"mcp": "yahoo_finance", "tool": "get_quote"})
+    print(f"✓ Created MCPCall with 'mcp' key: {call1.mcp_server}")
+
+    # Test 2: Create MCPCall with 'mcp_server' key (new format)
+    call2 = MCPCall.model_validate({"mcp_server": "fmp", "tool_name": "get_company_profile"})
+    print(f"✓ Created MCPCall with 'mcp_server' key: {call2.mcp_server}")
+
+    # Test 3: Verify model_dump() uses 'mcp_server' field name
+    dumped = call1.model_dump()
+    assert "mcp_server" in dumped, "model_dump() should contain 'mcp_server' key"
+    assert dumped["mcp_server"] == "yahoo_finance"
+    print(f"✓ model_dump() contains 'mcp_server': {dumped['mcp_server']}")
+
+    # Test 4: Verify tool_name alias works
+    dumped2 = call1.model_dump()
+    assert "tool_name" in dumped2
+    assert dumped2["tool_name"] == "get_quote"
+    print(f"✓ model_dump() contains 'tool_name': {dumped2['tool_name']}")
+
+    print("\n✅ All MCPCall validation tests passed!\n")
+
+
+def test_risk_metrics_formatting():
+    """Test that format_risk_metrics properly formats nested risk data."""
+    print("Testing risk metrics formatting fix...\n")
+
+    # Sample risk data with nested structures
+    risk_data = {
+        "var": {
+            "confidence_level": 0.95,
+            "time_horizon": 1,
+            "value": -1119.58,
+            "percentage": 0.039
+        },
+        "cvar": {
+            "confidence_level": 0.95,
+            "value": -1409.97,
+            "percentage": 0.0491
+        },
+        "volatility": 0.393,
+        "sharpe_ratio": 0.839,
+        "sortino_ratio": 1.256,
+        "max_drawdown": -0.391
+    }
+
+    portfolio_value = 28700.00
+
+    # Format the metrics
+    formatted = format_risk_metrics(risk_data, portfolio_value)
+
+    # Verify key components are present
+    assert "Value at Risk (VaR)" in formatted, "VaR section missing"
+    assert "95% Confidence" in formatted, "Confidence level missing"
+    assert "$1,119.58" in formatted, "VaR value not formatted correctly"
+    assert "3.90%" in formatted, "VaR percentage not formatted correctly"
+
+    assert "Conditional Value at Risk (CVaR)" in formatted, "CVaR section missing"
+    assert "$1,409.97" in formatted, "CVaR value not formatted correctly"
+    assert "4.91%" in formatted, "CVaR percentage not formatted correctly"
+
+    assert "Risk-Adjusted Performance" in formatted, "Performance section missing"
+    assert "Annual Volatility: 39.30%" in formatted, "Volatility not formatted correctly"
+    assert "Sharpe Ratio: 0.839" in formatted, "Sharpe ratio missing"
+    assert "Sortino Ratio: 1.256" in formatted, "Sortino ratio missing"
+    assert "Maximum Drawdown: -39.10%" in formatted, "Max drawdown not formatted correctly"
+
+    # Verify star ratings
+    assert "⭐⭐⭐" in formatted, "Star ratings missing"
+
+    print("Formatted output:\n")
+    print(formatted)
+    print("\n✅ All risk metrics formatting tests passed!\n")
+
+
+def test_star_ratings():
+    """Test star rating function."""
+    print("Testing star rating system...\n")
+
+    # Sharpe ratio ratings
+    assert get_rating_stars(3.5, "sharpe") == "⭐⭐⭐⭐⭐"
+    assert get_rating_stars(2.5, "sharpe") == "⭐⭐⭐⭐"
+    assert get_rating_stars(1.5, "sharpe") == "⭐⭐⭐"
+    assert get_rating_stars(0.839, "sharpe") == "⭐⭐"
+    assert get_rating_stars(0.3, "sharpe") == "⭐"
+    print("✓ Sharpe ratio ratings work correctly")
+
+    # Sortino ratio ratings
+    assert get_rating_stars(3.5, "sortino") == "⭐⭐⭐⭐⭐"
+    assert get_rating_stars(2.5, "sortino") == "⭐⭐⭐⭐"
+    assert get_rating_stars(1.256, "sortino") == "⭐⭐⭐"
+    print("✓ Sortino ratio ratings work correctly")
+
+    print("\n✅ All star rating tests passed!\n")
+
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("Running Fix Verification Tests")
+    print("=" * 60)
+    print()
+
+    test_mcp_call_validation_alias()
+    test_risk_metrics_formatting()
+    test_star_ratings()
+
+    print("=" * 60)
+    print("All Tests Passed! ✅")
+    print("=" * 60)