feat: complete MVP integration with Gradio UI, database schema, and tests

- Integrate Gradio UI with 3-phase workflow pipeline
- Implement portfolio input parser supporting multiple formats
- Add comprehensive results formatter with markdown output
- Create Supabase PostgreSQL schema with RLS policies
- Implement database persistence (save_analysis, get_analysis_history)
- Build integration test suite for MCP pipeline
- Fix Pydantic AI agent initialization (output_type parameter)
- Add missing config fields (anthropic_model, alpaca keys)
- Update README with setup instructions and architecture docs

Status: MVP ~90% complete, ready for deployment

README.md

@@ -1,14 +1,279 @@
 ---
 title: Portfolio Intelligence Platform
-emoji: 🏢
-colorFrom: yellow
-colorTo: indigo
+emoji: 📊
+colorFrom: blue
+colorTo: purple
 sdk: gradio
 sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 license: mit
-short_description: An agentic platform that judges your portfolio
+short_description: AI portfolio analysis with multi-agent MCP
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 📊 Portfolio Intelligence Platform
+
+AI-powered portfolio analysis using **multi-agent MCP orchestration** with quantitative models and LLM synthesis.
+
+## 🎯 What It Does
+
+The Portfolio Intelligence Platform analyses your investment portfolio using:
+- **6 MCP Servers**: Yahoo Finance, Financial Modeling Prep, Trading-MCP, FRED, Portfolio Optimizer, Risk Analyzer
+- **3-Phase Architecture**: Data Collection → Computation → AI Synthesis
+- **Quantitative Models**: HRP, Black-Litterman, Mean-Variance optimisation
+- **Risk Analysis**: VaR, CVaR, Monte Carlo simulation, Sharpe ratio
+- **AI Insights**: Claude Sonnet 4.5 with Pydantic AI for structured analysis
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.12+
+- uv package manager (install with `pip install uv`)
+- Anthropic API key (for Claude)
+- Optional: Supabase account for persistence
+- Optional: FMP and FRED API keys for enhanced data
+
+### Installation
+
+1. **Clone the repository**:
+```bash
+git clone <your-repo-url>
+cd Portfolio-Intelligence-Platform
+```
+
+2. **Install dependencies using uv**:
+```bash
+uv sync
+```
+
+3. **Set up environment variables**:
+Copy `.env` file and fill in your API keys:
+```bash
+# Required
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional (for enhanced features)
+SUPABASE_URL=your_supabase_url_here
+SUPABASE_KEY=your_supabase_anon_key_here
+FMP_API_KEY=your_financial_modeling_prep_key_here
+FRED_API_KEY=your_fred_api_key_here
+```
+
+4. **Set up database (optional)**:
+If using Supabase for persistence:
+```bash
+uv run python database/setup_database.py
+```
+This will output SQL that you need to run in your Supabase SQL Editor.
+
+5. **Run the application**:
+```bash
+uv run python app.py
+```
+
+Visit http://localhost:7860 to use the application.
+
+## 📖 Usage
+
+### Basic Portfolio Analysis
+
+1. Enter your portfolio holdings in the format:
+```
+AAPL 50
+TSLA 25 shares
+NVDA $5000
+BTC 0.5
+```
+
+2. Click "Analyse Portfolio"
+
+3. Get comprehensive analysis including:
+   - Portfolio health score
+   - Risk metrics (VaR, CVaR, Sharpe ratio)
+   - Optimised allocations (HRP, Black-Litterman, Mean-Variance)
+   - AI-generated insights and recommendations
+   - MCP server transparency
+
+### Example Portfolios
+
+Try these pre-loaded examples:
+- **Tech Growth**: `AAPL 50\nTSLA 25 shares\nNVDA $5000`
+- **Conservative**: `VOO 100 shares\nVTI 75 shares\nSCHD 50 shares`
+- **Balanced**: `VTI $25000\nVXUS $15000\nBND $15000\nGLD $5000`
+
+## 🏗️ Architecture
+
+### Three-Phase Workflow
+
+```
+Phase 1: Data Layer (4 MCPs)
+├─ Yahoo Finance: Real-time quotes, historical prices
+├─ FMP: Company fundamentals, financial statements
+├─ Trading-MCP: Technical indicators (RSI, MACD)
+└─ FRED: Macroeconomic data
+
+Phase 2: Computation Layer (2 MCPs)
+├─ Portfolio Optimizer: HRP, Black-Litterman, Mean-Variance
+└─ Risk Analyzer: VaR, CVaR, Monte Carlo, risk metrics
+
+Phase 3: LLM Synthesis
+└─ Claude Sonnet 4.5: AI insights and recommendations
+```
+
+### Technology Stack
+
+- **Frontend**: Gradio 5.49.1
+- **AI Framework**: Pydantic AI 1.18.0 (with native prompt caching)
+- **Orchestration**: LangGraph
+- **MCP Protocol**: FastMCP 2.13.0
+- **Quantitative Finance**: PyPortfolioOpt, riskfolio-lib, arch
+- **Database**: Supabase PostgreSQL (optional)
+
+## 🔧 Development
+
+### Project Structure
+
+```
+Portfolio-Intelligence-Platform/
+├── app.py                      # Gradio interface
+├── backend/
+│   ├── config.py               # Configuration management
+│   ├── database.py             # Supabase client
+│   ├── mcp_router.py           # MCP orchestration router
+│   ├── agents/
+│   │   ├── base_agent.py       # Pydantic AI base agent
+│   │   ├── portfolio_analyst.py # Portfolio analysis agent
+│   │   └── workflow.py         # LangGraph 3-phase workflow
+│   ├── models/
+│   │   ├── portfolio.py        # Portfolio data models
+│   │   └── agent_state.py      # LangGraph state models
+│   └── mcp_servers/
+│       ├── yahoo_finance_mcp.py
+│       ├── fmp_mcp.py
+│       ├── trading_mcp.py
+│       ├── fred_mcp.py
+│       ├── portfolio_optimizer_mcp.py
+│       └── risk_analyzer_mcp.py
+├── database/
+│   ├── schema.sql              # Database schema
+│   └── setup_database.py       # Setup script
+└── pyproject.toml              # uv dependencies
+```
+
+### Running Tests
+
+```bash
+uv run pytest tests/
+```
+
+### Code Quality
+
+```bash
+# Format code
+uv run black backend/ app.py
+
+# Type checking
+uv run mypy backend/ app.py
+
+# Linting
+uv run ruff backend/ app.py
+```
+
+## 🔑 API Keys
+
+### Required
+- **Anthropic API**: Get from https://console.anthropic.com/
+
+### Optional (for enhanced features)
+- **Supabase**: Get from https://supabase.com/ (free tier available)
+- **Financial Modeling Prep**: Get from https://financialmodelingprep.com/ (250 requests/day free)
+- **FRED**: Get from https://fred.stlouisfed.org/docs/api/api_key.html (free)
+
+### Cost Estimates
+
+With native prompt caching:
+- ~£0.01-0.02 per portfolio analysis
+- ~£1-2/month for 100 analyses
+- Infrastructure: £0/month (using free tiers)
+
+## 📊 Features
+
+### Portfolio Optimization
+
+- **Hierarchical Risk Parity (HRP)**: Diversification-focused allocation
+- **Black-Litterman**: Bayesian approach with market equilibrium
+- **Mean-Variance**: Classic Markowitz efficient frontier
+
+### Risk Analysis
+
+- **VaR/CVaR**: Value at Risk and Conditional VaR (95%, 99% confidence)
+- **Monte Carlo Simulation**: 10,000 simulations for tail risk
+- **Sharpe/Sortino Ratios**: Risk-adjusted return metrics
+- **Maximum Drawdown**: Historical worst-case scenarios
+
+### AI Insights
+
+- Portfolio health scoring (0-10)
+- Personalized recommendations
+- Risk tolerance assessment
+- Transparent reasoning with MCP server traceability
+
+## 🚢 Deployment
+
+### HuggingFace Spaces (Recommended)
+
+This application is designed for one-click deployment to HuggingFace Spaces:
+
+1. Push to your HuggingFace Space repository
+2. Add secrets in Space settings (ANTHROPIC_API_KEY, etc.)
+3. Application auto-deploys
+
+### Local Production
+
+```bash
+# Using uv
+uv run python app.py
+
+# Or with Gunicorn (for production)
+uv run gunicorn app:app --workers 4 --bind 0.0.0.0:7860
+```
+
+## 📝 License
+
+MIT License - see LICENSE file for details.
+
+## 🙏 Acknowledgements
+
+- Built for MCP 1st Birthday Hackathon
+- Uses Anthropic's Claude Sonnet 4.5
+- Quantitative models from PyPortfolioOpt and riskfolio-lib
+- MCP protocol by Anthropic
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**"Analysis failed" error**:
+- Check that ANTHROPIC_API_KEY is set correctly in .env
+- Verify API key has sufficient credits
+
+**No market data returned**:
+- Yahoo Finance may be rate-limited (yfinance is free but unofficial)
+- Consider getting FMP API key for more reliable data
+
+**Database errors**:
+- Verify SUPABASE_URL and SUPABASE_KEY are correct
+- Run database/setup_database.py to create tables
+- Application works without database (analysis won't be saved)
+
+## 📧 Support
+
+For issues or questions:
+1. Check the documentation in `finance-agentic-ai/` directory
+2. Review existing GitHub issues
+3. Create a new issue with detailed description
+
+---
+
+Built with ❤️ using Pydantic AI, LangGraph, and FastMCP

app.py

@@ -4,24 +4,229 @@ Main application file for the hackathon demo.
 """
 
 import gradio as gr
-from typing import List, Tuple
-import os
+import asyncio
+import re
+import logging
+from typing import List, Dict, Any
+from datetime import datetime
 from dotenv import load_dotenv
 
+from backend.mcp_router import mcp_router
+from backend.agents.workflow import PortfolioAnalysisWorkflow
+from backend.models.agent_state import AgentState
+
+# Load environment variables
 load_dotenv()
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize workflow
+workflow = PortfolioAnalysisWorkflow(mcp_router)
+
+
+def parse_portfolio_input(portfolio_text: str) -> List[Dict[str, Any]]:
+    """Parse portfolio input text into structured holdings.
+
+    Supports formats:
+    - AAPL 50 (50 shares)
+    - TSLA 25 shares
+    - NVDA $5000 (dollar amount)
+    - BTC 0.5 (fractional shares/crypto)
+
+    Args:
+        portfolio_text: Raw text input from user
+
+    Returns:
+        List of holding dictionaries
+    """
+    holdings = []
+    lines = portfolio_text.strip().split('\n')
+
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+
+        # Match patterns: TICKER QUANTITY [shares] or TICKER $AMOUNT
+        match = re.match(r'([A-Za-z]+)\s+(\$)?([0-9.]+)\s*(shares)?', line, re.IGNORECASE)
+        if match:
+            ticker = match.group(1).upper()
+            is_dollar = match.group(2) == '$'
+            amount = float(match.group(3))
+
+            holdings.append({
+                'ticker': ticker,
+                'quantity': amount if not is_dollar else 0,
+                'dollar_amount': amount if is_dollar else 0,
+                'cost_basis': 0  # Will be calculated from current price
+            })
+        else:
+            logger.warning(f"Could not parse line: {line}")
+
+    return holdings
+
+
+async def run_analysis(portfolio_text: str) -> str:
+    """Run portfolio analysis workflow.
+
+    Args:
+        portfolio_text: Raw portfolio input
+
+    Returns:
+        Formatted analysis results
+    """
+    try:
+        # Parse input
+        holdings = parse_portfolio_input(portfolio_text)
+
+        if not holdings:
+            return "❌ **Error**: Could not parse any holdings. Please use format like:\n```\nAAPL 50\nTSLA 25 shares\nNVDA $5000\n```"
+
+        logger.info(f"Parsed {len(holdings)} holdings")
+
+        # Create initial state
+        initial_state: AgentState = {
+            'portfolio_id': f"demo_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            'user_query': 'Analyse my portfolio',
+            'risk_tolerance': 'moderate',
+            'holdings': holdings,
+            'historical_prices': {},
+            'fundamentals': {},
+            'economic_data': {},
+            'realtime_data': {},
+            'technical_indicators': {},
+            'optimisation_results': {},
+            'risk_analysis': {},
+            'ai_synthesis': '',
+            'recommendations': [],
+            'reasoning_steps': [],
+            'current_step': 'starting',
+            'errors': [],
+            'mcp_calls': []
+        }
+
+        # Run workflow
+        logger.info("Starting workflow execution...")
+        final_state = await workflow.run(initial_state)
 
-def analyse_portfolio(portfolio_input: str) -> str:
-    """Analyse portfolio and return AI insights.
+        # Format results
+        return format_analysis_results(final_state, holdings)
+
+    except Exception as e:
+        logger.error(f"Analysis error: {e}", exc_info=True)
+        return f"❌ **Error during analysis**: {str(e)}\n\nPlease check your API keys in .env file and try again."
+
+
+def format_analysis_results(state: AgentState, holdings: List[Dict]) -> str:
+    """Format workflow results for Gradio display.
 
     Args:
-        portfolio_input: Portfolio holdings as text (e.g., "AAPL 50\nTSLA 25 shares")
+        state: Final workflow state
+        holdings: Original holdings list
 
     Returns:
-        Analysis results with insights and recommendations
+        Formatted markdown string
     """
-    # TODO: Integrate with MCP router and agents
-    return f"Analysis placeholder for:\n{portfolio_input}"
+    output = []
+
+    # Header
+    output.append("# 📊 Portfolio Analysis Results\n")
+
+    # Portfolio Summary
+    output.append("## 📈 Portfolio Summary\n")
+    tickers = [h['ticker'] for h in holdings]
+    output.append(f"**Holdings**: {', '.join(tickers)}\n")
+    output.append(f"**Number of positions**: {len(holdings)}\n")
+
+    # Check for errors
+    if state.get('errors'):
+        output.append("\n## ⚠️ Warnings\n")
+        for error in state['errors']:
+            output.append(f"- {error}\n")
+
+    # AI Synthesis
+    if state.get('ai_synthesis'):
+        output.append("\n## 🤖 AI Analysis\n")
+        output.append(state['ai_synthesis'])
+        output.append("\n")
+
+    # Recommendations
+    if state.get('recommendations'):
+        output.append("\n## 💡 Recommendations\n")
+        for i, rec in enumerate(state['recommendations'], 1):
+            output.append(f"{i}. {rec}\n")
+
+    # Risk Analysis
+    if state.get('risk_analysis'):
+        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")
+
+    # Optimization Results
+    if state.get('optimisation_results'):
+        output.append("\n## 🎯 Portfolio Optimisation\n")
+        opt = state['optimisation_results']
+        if isinstance(opt, dict):
+            for method, result in opt.items():
+                output.append(f"\n### {method}\n")
+                if isinstance(result, dict) and 'weights' in result:
+                    output.append("**Suggested Allocation**:\n")
+                    for ticker, weight in result['weights'].items():
+                        output.append(f"- {ticker}: {weight*100:.1f}%\n")
+
+    # MCP Calls (for transparency)
+    if state.get('mcp_calls'):
+        output.append(f"\n## 🔧 MCP Servers Called\n")
+        mcp_servers = set()
+        for call in state['mcp_calls']:
+            if isinstance(call, dict) and 'mcp_server' in call:
+                mcp_servers.add(call['mcp_server'])
+        output.append(f"Used {len(mcp_servers)} MCP servers: {', '.join(sorted(mcp_servers))}\n")
+
+    # Execution time
+    output.append(f"\n---\n*Analysis completed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*")
+
+    return '\n'.join(output)
+
+
+def analyse_portfolio_sync(portfolio_input: str, progress=gr.Progress()) -> str:
+    """Synchronous wrapper for async analysis (required by Gradio).
+
+    Args:
+        portfolio_input: Portfolio holdings as text
+        progress: Gradio progress tracker
+
+    Returns:
+        Analysis results
+    """
+    if not portfolio_input.strip():
+        return "Please enter your portfolio holdings to get started."
+
+    # Show progress
+    progress(0.1, desc="Parsing portfolio...")
+
+    # Run async function in event loop
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+        progress(0.2, desc="Starting analysis workflow...")
+        result = loop.run_until_complete(run_analysis(portfolio_input))
+
+        progress(1.0, desc="Complete!")
+        loop.close()
+
+        return result
+    except Exception as e:
+        logger.error(f"Error in sync wrapper: {e}", exc_info=True)
+        return f"❌ **Error**: {str(e)}"
 
 
 def create_interface() -> gr.Blocks:
@@ -36,7 +241,7 @@ def create_interface() -> gr.Blocks:
         fill_height=True
     ) as demo:
         gr.Markdown("# 📊 Portfolio Intelligence Platform")
-        gr.Markdown("AI-powered portfolio analysis using MCP orchestration")
+        gr.Markdown("AI-powered portfolio analysis using multi-agent MCP orchestration")
 
         with gr.Row():
             with gr.Column(scale=1):
@@ -46,15 +251,15 @@ def create_interface() -> gr.Blocks:
                     label="Portfolio Holdings",
                     placeholder="AAPL 50\nTSLA 25 shares\nNVDA $5000\nBTC 0.5",
                     lines=10,
-                    info="Enter one holding per line"
+                    info="Enter one holding per line (TICKER QUANTITY or TICKER $AMOUNT)"
                 )
 
-                analyse_btn = gr.Button("Analyse Portfolio", variant="primary")
+                analyse_btn = gr.Button("🚀 Analyse Portfolio", variant="primary", size="lg")
 
                 # Example portfolios
                 gr.Examples(
                     examples=[
-                        ["AAPL 50\nTSLA 25 shares\nNVDA $5000\nBTC 0.5"],
+                        ["AAPL 50\nTSLA 25 shares\nNVDA $5000"],
                         ["VOO 100 shares\nVTI 75 shares\nSCHD 50 shares"],
                         ["VTI $25000\nVXUS $15000\nBND $15000\nGLD $5000"],
                     ],
@@ -66,15 +271,21 @@ def create_interface() -> gr.Blocks:
                 gr.Markdown("## Analysis Results")
 
                 output = gr.Markdown(
-                    value="Enter your portfolio and click 'Analyse Portfolio' to get started.",
+                    value="👈 Enter your portfolio and click **Analyse Portfolio** to get started.\n\n"
+                          "The system will:\n"
+                          "1. **Fetch market data** (prices, fundamentals, economic indicators)\n"
+                          "2. **Run optimisations** (HRP, Black-Litterman, Mean-Variance)\n"
+                          "3. **Analyse risk** (VaR, CVaR, Sharpe ratio)\n"
+                          "4. **Generate AI insights** with actionable recommendations",
                     label="AI Insights"
                 )
 
         # Event handlers
         analyse_btn.click(
-            fn=analyse_portfolio,
+            fn=analyse_portfolio_sync,
             inputs=portfolio_input,
-            outputs=output
+            outputs=output,
+            show_progress=True
         )
 
     return demo

backend/agents/base_agent.py

@@ -21,7 +21,7 @@ class BasePortfolioAgent(Generic[T]):
 
     def __init__(
         self,
-        result_type: type[T],
+        output_type: type[T],
         system_prompt: str,
         agent_name: str,
         model: str | None = None,
@@ -29,20 +29,20 @@ class BasePortfolioAgent(Generic[T]):
         """Initialize the base agent.
 
         Args:
-            result_type: Pydantic model class for structured output
+            output_type: Pydantic model class for structured output
             system_prompt: System prompt for the agent
             agent_name: Name of the agent for logging
-            model: LLM model to use (defaults to settings.ANTHROPIC_MODEL)
+            model: LLM model to use (defaults to settings.anthropic_model)
         """
         self.agent_name = agent_name
-        self.model = model or settings.ANTHROPIC_MODEL
-        self.result_type = result_type
+        self.model = f"anthropic:{model or settings.anthropic_model}"
+        self.output_type = output_type
         self.system_prompt = system_prompt
 
         # Initialize Pydantic AI agent with native prompt caching
         self.agent = Agent(
             self.model,
-            result_type=result_type,
+            output_type=output_type,
             system_prompt=system_prompt,
         )
 

backend/agents/portfolio_analyst.py

@@ -59,7 +59,7 @@ class PortfolioAnalystAgent(BasePortfolioAgent[PortfolioAnalysisOutput]):
 
     def __init__(self):
         super().__init__(
-            result_type=PortfolioAnalysisOutput,
+            output_type=PortfolioAnalysisOutput,
             system_prompt=SYSTEM_PROMPT,
             agent_name="PortfolioAnalyst",
         )
@@ -133,7 +133,7 @@ class QuickInsightAgent(BasePortfolioAgent[BaseModel]):
             confidence: float = Field(..., ge=0.0, le=1.0)
 
         super().__init__(
-            result_type=QuickInsight,
+            output_type=QuickInsight,
             system_prompt="You are a helpful financial assistant. Provide concise, accurate answers to investment questions.",
             agent_name="QuickInsight",
         )

backend/config.py

@@ -14,6 +14,7 @@ class Settings(BaseSettings):
 
     Attributes:
         anthropic_api_key: Anthropic API key for Claude
+        anthropic_model: Anthropic model ID (default: claude-sonnet-4-5-20250929)
         supabase_url: Supabase project URL
         supabase_key: Supabase anon key
         fmp_api_key: Financial Modeling Prep API key
@@ -27,6 +28,10 @@ class Settings(BaseSettings):
         default="",
         validation_alias="ANTHROPIC_API_KEY"
     )
+    anthropic_model: str = Field(
+        default="claude-sonnet-4-5-20250929",
+        validation_alias="ANTHROPIC_MODEL"
+    )
 
     # Database Configuration
     supabase_url: Optional[str] = Field(
@@ -47,6 +52,14 @@ class Settings(BaseSettings):
         default=None,
         validation_alias="FRED_API_KEY"
     )
+    alpaca_api_key: Optional[str] = Field(
+        default=None,
+        validation_alias="ALPACA_API_KEY"
+    )
+    alpaca_secret_key: Optional[str] = Field(
+        default=None,
+        validation_alias="ALPACA_SECRET_KEY"
+    )
 
     # Application Settings
     environment: str = Field(

backend/database.py

@@ -3,7 +3,7 @@
 Handles Supabase PostgreSQL connections and operations.
 """
 
-from typing import Optional
+from typing import Optional, Dict, Any, List
 from supabase import create_client, Client
 from backend.config import settings
 import logging
@@ -43,29 +43,81 @@ class Database:
         """
         return self.client is not None
 
-    async def save_analysis(self, user_id: str, portfolio_data: dict, analysis_result: dict) -> bool:
-        """Save portfolio analysis to database.
+    async def save_analysis(
+        self,
+        portfolio_id: str,
+        analysis_results: Dict[str, Any]
+    ) -> bool:
+        """Save portfolio analysis results to database.
 
         Args:
-            user_id: User identifier
-            portfolio_data: Portfolio holdings data
-            analysis_result: Analysis results from AI agents
+            portfolio_id: Portfolio ID
+            analysis_results: Complete analysis results from workflow
 
         Returns:
             True if saved successfully, False otherwise
         """
         if not self.is_connected():
-            logger.warning("Database not connected - skipping save")
+            logger.warning("Database not connected, skipping save")
             return False
 
         try:
-            # TODO: Implement actual database schema and insert logic
-            logger.info(f"Saving analysis for user {user_id}")
+            # Extract data from analysis results
+            data = {
+                'portfolio_id': portfolio_id,
+                'holdings_snapshot': analysis_results.get('holdings', []),
+                'market_data': analysis_results.get('market_data', {}),
+                'risk_metrics': analysis_results.get('risk_analysis', {}),
+                'optimisation_results': analysis_results.get('optimisation_results', {}),
+                'ai_synthesis': analysis_results.get('ai_synthesis', ''),
+                'recommendations': analysis_results.get('recommendations', []),
+                'reasoning_steps': analysis_results.get('reasoning_steps', []),
+                'mcp_calls': analysis_results.get('mcp_calls', []),
+                'execution_time_ms': analysis_results.get('execution_time_ms'),
+                'model_version': analysis_results.get('model_version', 'claude-sonnet-4-5'),
+            }
+
+            # Insert into portfolio_analyses table
+            result = self.client.table('portfolio_analyses').insert(data).execute()
+
+            logger.info(f"Saved analysis for portfolio {portfolio_id}")
             return True
+
         except Exception as e:
             logger.error(f"Failed to save analysis: {e}")
             return False
 
+    async def get_analysis_history(
+        self,
+        portfolio_id: str,
+        limit: int = 10
+    ) -> List[Dict[str, Any]]:
+        """Get analysis history for a portfolio.
+
+        Args:
+            portfolio_id: Portfolio ID
+            limit: Maximum number of analyses to return
+
+        Returns:
+            List of analysis results
+        """
+        if not self.is_connected():
+            return []
+
+        try:
+            result = self.client.table('portfolio_analyses') \
+                .select('*') \
+                .eq('portfolio_id', portfolio_id) \
+                .order('analysis_date', desc=True) \
+                .limit(limit) \
+                .execute()
+
+            return result.data if result.data else []
+
+        except Exception as e:
+            logger.error(f"Failed to get analysis history: {e}")
+            return []
+
 
 # Global database instance
 db = Database()

backend/mcp_servers/fmp_mcp.py

@@ -24,7 +24,7 @@ mcp = FastMCP("financial-modeling-prep")
 
 # API Configuration
 BASE_URL = "https://financialmodelingprep.com/api/v3"
-API_KEY = settings.FMP_API_KEY
+API_KEY = settings.fmp_api_key
 
 
 class CompanyProfileRequest(BaseModel):

backend/mcp_servers/fred_mcp.py

@@ -22,7 +22,7 @@ mcp = FastMCP("fred")
 
 # API Configuration
 BASE_URL = "https://api.stlouisfed.org/fred"
-API_KEY = settings.FRED_API_KEY
+API_KEY = settings.fred_api_key
 
 
 class SeriesRequest(BaseModel):

database/schema.sql

@@ -0,0 +1,152 @@
+-- Portfolio Intelligence Platform Database Schema
+-- For Supabase PostgreSQL
+
+-- Enable UUID extension
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+
+-- Users table
+CREATE TABLE IF NOT EXISTS users (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    email VARCHAR(255) UNIQUE NOT NULL,
+    username VARCHAR(100) UNIQUE NOT NULL,
+    is_active BOOLEAN DEFAULT true,
+    is_demo BOOLEAN DEFAULT false,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_users_username ON users(username);
+
+-- Portfolios table
+CREATE TABLE IF NOT EXISTS portfolios (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    name VARCHAR(200) NOT NULL,
+    description TEXT,
+    risk_tolerance VARCHAR(20) DEFAULT 'moderate',
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE INDEX idx_portfolios_user_id ON portfolios(user_id);
+CREATE INDEX idx_portfolios_created_at ON portfolios(created_at DESC);
+
+-- Portfolio holdings table
+CREATE TABLE IF NOT EXISTS portfolio_holdings (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    portfolio_id UUID NOT NULL REFERENCES portfolios(id) ON DELETE CASCADE,
+    ticker VARCHAR(20) NOT NULL,
+    quantity NUMERIC(20, 8) NOT NULL,
+    cost_basis NUMERIC(20, 2),
+    asset_type VARCHAR(20) DEFAULT 'stock',
+    added_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE INDEX idx_holdings_portfolio_id ON portfolio_holdings(portfolio_id);
+CREATE INDEX idx_holdings_ticker ON portfolio_holdings(ticker);
+
+-- Portfolio analyses table
+CREATE TABLE IF NOT EXISTS portfolio_analyses (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    portfolio_id UUID NOT NULL REFERENCES portfolios(id) ON DELETE CASCADE,
+    analysis_date TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+
+    -- Analysis results (JSONB for flexibility)
+    holdings_snapshot JSONB NOT NULL,
+    market_data JSONB,
+    risk_metrics JSONB,
+    optimisation_results JSONB,
+    ai_synthesis TEXT,
+    recommendations JSONB,
+
+    -- Metadata
+    reasoning_steps JSONB,
+    mcp_calls JSONB,
+    execution_time_ms INTEGER,
+    model_version VARCHAR(50),
+
+    -- Computed fields
+    total_value NUMERIC(20, 2),
+    health_score INTEGER CHECK (health_score >= 0 AND health_score <= 10),
+    risk_level VARCHAR(20),
+
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE INDEX idx_analyses_portfolio_id ON portfolio_analyses(portfolio_id);
+CREATE INDEX idx_analyses_date ON portfolio_analyses(analysis_date DESC);
+CREATE INDEX idx_analyses_health_score ON portfolio_analyses(health_score);
+
+-- Create demo user for testing
+INSERT INTO users (id, email, username, is_demo)
+VALUES (
+    '00000000-0000-0000-0000-000000000001'::UUID,
+    '[email protected]',
+    'demo-user',
+    true
+) ON CONFLICT (email) DO NOTHING;
+
+-- Function to update updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = NOW();
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Triggers for updated_at
+CREATE TRIGGER update_users_updated_at BEFORE UPDATE ON users
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+CREATE TRIGGER update_portfolios_updated_at BEFORE UPDATE ON portfolios
+    FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+-- Grant permissions (Supabase uses RLS - Row Level Security)
+-- These are basic permissions; adjust based on your auth setup
+ALTER TABLE users ENABLE ROW LEVEL SECURITY;
+ALTER TABLE portfolios ENABLE ROW LEVEL SECURITY;
+ALTER TABLE portfolio_holdings ENABLE ROW LEVEL SECURITY;
+ALTER TABLE portfolio_analyses ENABLE ROW LEVEL SECURITY;
+
+-- Basic RLS policies (adjust for production)
+-- Allow users to read their own data
+CREATE POLICY users_read_own ON users
+    FOR SELECT
+    USING (auth.uid()::UUID = id OR is_demo = true);
+
+CREATE POLICY portfolios_read_own ON portfolios
+    FOR SELECT
+    USING (auth.uid()::UUID = user_id OR user_id = '00000000-0000-0000-0000-000000000001'::UUID);
+
+CREATE POLICY portfolios_insert_own ON portfolios
+    FOR INSERT
+    WITH CHECK (auth.uid()::UUID = user_id OR user_id = '00000000-0000-0000-0000-000000000001'::UUID);
+
+CREATE POLICY portfolios_update_own ON portfolios
+    FOR UPDATE
+    USING (auth.uid()::UUID = user_id OR user_id = '00000000-0000-0000-0000-000000000001'::UUID);
+
+CREATE POLICY portfolios_delete_own ON portfolios
+    FOR DELETE
+    USING (auth.uid()::UUID = user_id OR user_id = '00000000-0000-0000-0000-000000000001'::UUID);
+
+-- Similar policies for holdings and analyses
+CREATE POLICY holdings_access_own ON portfolio_holdings
+    FOR ALL
+    USING (
+        portfolio_id IN (
+            SELECT id FROM portfolios
+            WHERE user_id = auth.uid()::UUID OR user_id = '00000000-0000-0000-0000-000000000001'::UUID
+        )
+    );
+
+CREATE POLICY analyses_access_own ON portfolio_analyses
+    FOR ALL
+    USING (
+        portfolio_id IN (
+            SELECT id FROM portfolios
+            WHERE user_id = auth.uid()::UUID OR user_id = '00000000-0000-0000-0000-000000000001'::UUID
+        )
+    );

database/setup_database.py

@@ -0,0 +1,65 @@
+"""Database setup script for Supabase.
+
+Run this script to set up the database schema in your Supabase instance.
+"""
+
+import os
+import sys
+from pathlib import Path
+from supabase import create_client
+from dotenv import load_dotenv
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+load_dotenv()
+
+
+def setup_database():
+    """Set up database schema in Supabase."""
+    supabase_url = os.getenv("SUPABASE_URL")
+    supabase_key = os.getenv("SUPABASE_KEY")
+
+    if not supabase_url or not supabase_key:
+        print("❌ Error: SUPABASE_URL and SUPABASE_KEY must be set in .env file")
+        return False
+
+    try:
+        print("📊 Connecting to Supabase...")
+        client = create_client(supabase_url, supabase_key)
+
+        # Read schema file
+        schema_path = Path(__file__).parent / "schema.sql"
+        with open(schema_path, 'r') as f:
+            schema_sql = f.read()
+
+        print("🔧 Executing schema SQL...")
+        # Note: Supabase Python client doesn't support raw SQL execution
+        # You need to execute this in the Supabase SQL Editor instead
+        print("\n" + "="*80)
+        print("⚠️  IMPORTANT: Copy the SQL below and execute it in your Supabase SQL Editor")
+        print("="*80 + "\n")
+        print(schema_sql)
+        print("\n" + "="*80)
+        print("📝 Instructions:")
+        print("1. Go to your Supabase dashboard")
+        print("2. Navigate to SQL Editor")
+        print("3. Create a new query")
+        print("4. Copy and paste the SQL above")
+        print("5. Click 'Run' to execute")
+        print("="*80 + "\n")
+
+        # Verify connection
+        result = client.table('users').select("count", count='exact').execute()
+        print(f"✅ Database connection verified!")
+
+        return True
+
+    except Exception as e:
+        print(f"❌ Error setting up database: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    success = setup_database()
+    sys.exit(0 if success else 1)

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests package for Portfolio Intelligence Platform."""

tests/conftest.py

@@ -0,0 +1,33 @@
+"""Pytest configuration and fixtures."""
+
+import pytest
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+@pytest.fixture(scope="session")
+def event_loop():
+    """Create an instance of the default event loop for the test session."""
+    import asyncio
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    yield loop
+    loop.close()
+
+
+@pytest.fixture
+def sample_portfolio_holdings():
+    """Sample portfolio holdings for testing."""
+    return [
+        {'ticker': 'AAPL', 'quantity': 50, 'dollar_amount': 0, 'cost_basis': 150.0},
+        {'ticker': 'GOOGL', 'quantity': 30, 'dollar_amount': 0, 'cost_basis': 2800.0},
+        {'ticker': 'MSFT', 'quantity': 40, 'dollar_amount': 0, 'cost_basis': 350.0}
+    ]
+
+
+@pytest.fixture
+def sample_portfolio_text():
+    """Sample portfolio input text for testing."""
+    return "AAPL 50\nGOOGL 30 shares\nMSFT 40"

tests/test_integration.py

@@ -0,0 +1,289 @@
+"""Integration tests for Portfolio Intelligence Platform.
+
+Tests the complete MCP pipeline from input to output.
+"""
+
+import pytest
+import asyncio
+from decimal import Decimal
+from typing import Dict, Any
+
+from backend.mcp_router import router as mcp_router
+from backend.agents.workflow import PortfolioAnalysisWorkflow
+from backend.models.agent_state import AgentState
+from app import parse_portfolio_input
+
+
+class TestPortfolioInputParser:
+    """Test portfolio input parsing."""
+
+    def test_parse_basic_shares(self):
+        """Test parsing basic share format."""
+        input_text = "AAPL 50"
+        holdings = parse_portfolio_input(input_text)
+
+        assert len(holdings) == 1
+        assert holdings[0]['ticker'] == 'AAPL'
+        assert holdings[0]['quantity'] == 50.0
+        assert holdings[0]['dollar_amount'] == 0
+
+    def test_parse_with_shares_keyword(self):
+        """Test parsing with 'shares' keyword."""
+        input_text = "TSLA 25 shares"
+        holdings = parse_portfolio_input(input_text)
+
+        assert len(holdings) == 1
+        assert holdings[0]['ticker'] == 'TSLA'
+        assert holdings[0]['quantity'] == 25.0
+
+    def test_parse_dollar_amount(self):
+        """Test parsing dollar amount format."""
+        input_text = "NVDA $5000"
+        holdings = parse_portfolio_input(input_text)
+
+        assert len(holdings) == 1
+        assert holdings[0]['ticker'] == 'NVDA'
+        assert holdings[0]['dollar_amount'] == 5000.0
+        assert holdings[0]['quantity'] == 0
+
+    def test_parse_multiple_holdings(self):
+        """Test parsing multiple holdings."""
+        input_text = "AAPL 50\nTSLA 25 shares\nNVDA $5000"
+        holdings = parse_portfolio_input(input_text)
+
+        assert len(holdings) == 3
+        assert holdings[0]['ticker'] == 'AAPL'
+        assert holdings[1]['ticker'] == 'TSLA'
+        assert holdings[2]['ticker'] == 'NVDA'
+
+    def test_parse_fractional_shares(self):
+        """Test parsing fractional shares."""
+        input_text = "BTC 0.5"
+        holdings = parse_portfolio_input(input_text)
+
+        assert len(holdings) == 1
+        assert holdings[0]['ticker'] == 'BTC'
+        assert holdings[0]['quantity'] == 0.5
+
+    def test_parse_empty_lines(self):
+        """Test parsing with empty lines."""
+        input_text = "AAPL 50\n\nTSLA 25\n\n"
+        holdings = parse_portfolio_input(input_text)
+
+        assert len(holdings) == 2
+
+    def test_parse_lowercase_tickers(self):
+        """Test that tickers are converted to uppercase."""
+        input_text = "aapl 50"
+        holdings = parse_portfolio_input(input_text)
+
+        assert holdings[0]['ticker'] == 'AAPL'
+
+
+class TestMCPServers:
+    """Test individual MCP servers."""
+
+    @pytest.mark.asyncio
+    async def test_yahoo_finance_quote(self):
+        """Test Yahoo Finance quote retrieval."""
+        result = await mcp_router.call_yahoo_finance_mcp(
+            action='get_quote',
+            params={'tickers': ['AAPL']}
+        )
+
+        assert 'result' in result
+        assert len(result['result']) > 0
+        assert result['result'][0]['ticker'] == 'AAPL'
+
+    @pytest.mark.asyncio
+    async def test_yahoo_finance_historical(self):
+        """Test Yahoo Finance historical data."""
+        result = await mcp_router.call_yahoo_finance_mcp(
+            action='get_historical_data',
+            params={
+                'ticker': 'AAPL',
+                'period': '1mo',
+                'interval': '1d'
+            }
+        )
+
+        assert 'result' in result
+        assert 'dates' in result['result']
+        assert 'close_prices' in result['result']
+        assert len(result['result']['dates']) > 0
+
+    @pytest.mark.asyncio
+    async def test_portfolio_optimizer_hrp(self):
+        """Test HRP portfolio optimization."""
+        # First get historical data
+        historical_result = await mcp_router.call_yahoo_finance_mcp(
+            action='get_historical_data',
+            params={
+                'ticker': 'AAPL',
+                'period': '1y',
+                'interval': '1d'
+            }
+        )
+
+        market_data = [
+            {
+                'ticker': 'AAPL',
+                'dates': historical_result['result']['dates'],
+                'close_prices': historical_result['result']['close_prices']
+            }
+        ]
+
+        result = await mcp_router.call_portfolio_optimizer_mcp(
+            action='optimize_hrp',
+            params={
+                'market_data': market_data,
+                'symbols': ['AAPL']
+            }
+        )
+
+        assert 'result' in result
+        assert 'weights' in result['result']
+        assert 'AAPL' in result['result']['weights']
+
+    @pytest.mark.asyncio
+    async def test_risk_analyzer(self):
+        """Test risk analysis."""
+        # Get historical data first
+        historical_result = await mcp_router.call_yahoo_finance_mcp(
+            action='get_historical_data',
+            params={
+                'ticker': 'AAPL',
+                'period': '1y',
+                'interval': '1d'
+            }
+        )
+
+        market_data = [
+            {
+                'ticker': 'AAPL',
+                'dates': historical_result['result']['dates'],
+                'close_prices': historical_result['result']['close_prices']
+            }
+        ]
+
+        result = await mcp_router.call_risk_analyzer_mcp(
+            action='analyze_risk',
+            params={
+                'market_data': market_data,
+                'weights': {'AAPL': 1.0},
+                'portfolio_value': 10000,
+                'confidence_level': 0.95,
+                'method': 'historical'
+            }
+        )
+
+        assert 'result' in result
+        assert 'var_95' in result['result']
+        assert 'cvar_95' in result['result']
+
+
+class TestWorkflow:
+    """Test the complete workflow."""
+
+    @pytest.mark.asyncio
+    async def test_workflow_execution(self):
+        """Test complete workflow execution."""
+        # Create initial state
+        initial_state: AgentState = {
+            'portfolio_id': 'test_portfolio_001',
+            'user_query': 'Analyse my portfolio',
+            'risk_tolerance': 'moderate',
+            'holdings': [
+                {'ticker': 'AAPL', 'quantity': 50, 'dollar_amount': 0, 'cost_basis': 0}
+            ],
+            'historical_prices': {},
+            'fundamentals': {},
+            'economic_data': {},
+            'realtime_data': {},
+            'technical_indicators': {},
+            'optimisation_results': {},
+            'risk_analysis': {},
+            'ai_synthesis': '',
+            'recommendations': [],
+            'reasoning_steps': [],
+            'current_step': 'starting',
+            'errors': [],
+            'mcp_calls': []
+        }
+
+        # Initialize workflow
+        workflow = PortfolioAnalysisWorkflow(mcp_router)
+
+        # Run workflow
+        final_state = await workflow.run(initial_state)
+
+        # Verify results
+        assert final_state['current_step'] == 'complete'
+        assert len(final_state['mcp_calls']) > 0
+        assert final_state['ai_synthesis'] != ''
+        assert len(final_state['recommendations']) > 0
+
+    @pytest.mark.asyncio
+    async def test_workflow_with_multiple_holdings(self):
+        """Test workflow with multiple holdings."""
+        initial_state: AgentState = {
+            'portfolio_id': 'test_portfolio_002',
+            'user_query': 'Analyse my diversified portfolio',
+            'risk_tolerance': 'moderate',
+            'holdings': [
+                {'ticker': 'AAPL', 'quantity': 50, 'dollar_amount': 0, 'cost_basis': 0},
+                {'ticker': 'GOOGL', 'quantity': 30, 'dollar_amount': 0, 'cost_basis': 0},
+                {'ticker': 'MSFT', 'quantity': 40, 'dollar_amount': 0, 'cost_basis': 0}
+            ],
+            'historical_prices': {},
+            'fundamentals': {},
+            'economic_data': {},
+            'realtime_data': {},
+            'technical_indicators': {},
+            'optimisation_results': {},
+            'risk_analysis': {},
+            'ai_synthesis': '',
+            'recommendations': [],
+            'reasoning_steps': [],
+            'current_step': 'starting',
+            'errors': [],
+            'mcp_calls': []
+        }
+
+        workflow = PortfolioAnalysisWorkflow(mcp_router)
+        final_state = await workflow.run(initial_state)
+
+        # Verify all phases completed
+        assert 'historical_prices' in final_state
+        assert 'optimisation_results' in final_state
+        assert 'risk_analysis' in final_state
+        assert final_state['ai_synthesis'] != ''
+
+
+@pytest.mark.skip(reason="Requires valid API keys")
+class TestWithRealAPIs:
+    """Tests that require real API keys."""
+
+    @pytest.mark.asyncio
+    async def test_fmp_company_profile(self):
+        """Test FMP company profile retrieval."""
+        result = await mcp_router.call_fmp_mcp(
+            action='get_company_profile',
+            params={'ticker': 'AAPL'}
+        )
+
+        assert 'result' in result
+
+    @pytest.mark.asyncio
+    async def test_fred_economic_data(self):
+        """Test FRED economic data retrieval."""
+        result = await mcp_router.call_fred_mcp(
+            action='get_economic_series',
+            params={'series_id': 'GDP'}
+        )
+
+        assert 'result' in result
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "-s"])