Upload 18 files

.env

@@ -0,0 +1,2 @@
+SWARMS_API_KEY=sk-f763a9c6f898aa3ec74bf49047736a0201c293eefc36d5a04be8af647b93b711
+FRED_API_KEY=d421178827e3d9c621210bc6f0303439

.gitignore

@@ -0,0 +1 @@
+__pycache__/

app/api/dependencies.py

@@ -0,0 +1,17 @@
+from fastapi import HTTPException, Depends
+from app.services.data_fetcher import PortfolioDataFetcher, EconomicDataFetcher
+from app.services.portfolio_analyzer import PortfolioAnalyzer
+from app.services.backtester import AdvancedBacktester
+from app.core.exceptions import PortfolioException
+
+def get_data_fetcher() -> PortfolioDataFetcher:
+    return PortfolioDataFetcher()
+
+def get_economic_fetcher() -> EconomicDataFetcher:
+    return EconomicDataFetcher()
+
+def get_portfolio_analyzer() -> PortfolioAnalyzer:
+    return PortfolioAnalyzer()
+
+def get_backtester() -> AdvancedBacktester:
+    return AdvancedBacktester()

app/api/routes.py

@@ -0,0 +1,161 @@
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Dict, List, Any
+from app.services.data_fetcher import PortfolioDataFetcher, EconomicDataFetcher
+from app.services.portfolio_analyzer import PortfolioAnalyzer
+from app.services.backtester import AdvancedBacktester
+from app.services.swarm_service import create_portfolio_swarm
+from app.models.response import (
+    EconomicDataResponse, 
+    MarketIndicesResponse, 
+    StockDataResponse,
+    PortfolioAnalysisResponse,
+    BacktestResponse,
+    SwarmAnalysisResponse
+)
+from app.models.portfolio import Portfolio, BacktestRequest, ClientProfile
+from app.api.dependencies import (
+    get_data_fetcher, 
+    get_economic_fetcher, 
+    get_portfolio_analyzer, 
+    get_backtester
+)
+from app.core.exceptions import PortfolioException
+
+router = APIRouter()
+
+@router.get("/economic-data", response_model=EconomicDataResponse)
+async def get_economic_data(fetcher: EconomicDataFetcher = Depends(get_economic_fetcher)):
+    """Get current economic indicators"""
+    try:
+        rbi_repo_rate = fetcher.get_rbi_repo_rate()
+        indian_inflation_rate = fetcher.get_indian_inflation_rate()
+        real_interest_rate = rbi_repo_rate - indian_inflation_rate
+        
+        return EconomicDataResponse(
+            rbi_repo_rate=rbi_repo_rate,
+            indian_inflation_rate=indian_inflation_rate,
+            real_interest_rate=real_interest_rate
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/market-indices", response_model=MarketIndicesResponse)
+async def get_market_indices(fetcher: PortfolioDataFetcher = Depends(get_data_fetcher)):
+    """Get live market indices data"""
+    try:
+        indices_data = fetcher.get_market_indices()
+        return MarketIndicesResponse(indices=indices_data)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/stock-data/{symbol}", response_model=StockDataResponse)
+async def get_stock_data(symbol: str, fetcher: PortfolioDataFetcher = Depends(get_data_fetcher)):
+    """Get stock data for a specific symbol"""
+    try:
+        stock_data = fetcher.get_stock_data([symbol])
+        if symbol not in stock_data:
+            raise HTTPException(status_code=404, detail=f"Stock data not found for {symbol}")
+        
+        data = stock_data[symbol]
+        return StockDataResponse(
+            symbol=symbol,
+            current_price=data['current_price'],
+            volume=data['volume'],
+            returns_1y=data['returns_1y'],
+            volatility=data['volatility'],
+            market_cap=data['market_cap'],
+            pe_ratio=data['pe_ratio'],
+            dividend_yield=data['dividend_yield']
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/portfolio-analysis", response_model=PortfolioAnalysisResponse)
+async def analyze_portfolio(
+    portfolio: Portfolio,
+    analyzer: PortfolioAnalyzer = Depends(get_portfolio_analyzer),
+    fetcher: PortfolioDataFetcher = Depends(get_data_fetcher)
+):
+    """Analyze portfolio performance and allocation"""
+    try:
+        # Convert portfolio to holdings dict
+        holdings = {}
+        for holding in portfolio.holdings:
+            holdings[holding.symbol] = {
+                'quantity': holding.quantity,
+                'current_price': holding.current_price,
+                'name': holding.name
+            }
+        
+        # Analyze portfolio
+        analysis = analyzer.analyze_portfolio(holdings, portfolio.current_portfolio_value)
+        
+        return PortfolioAnalysisResponse(
+            portfolio_value=analysis['portfolio_value'],
+            number_of_holdings=analysis['number_of_holdings'],
+            sector_allocation=analysis['sector_allocation'],
+            holdings=analysis['holdings']
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/backtest", response_model=BacktestResponse)
+async def backtest_portfolio(
+    request: BacktestRequest,
+    backtester: AdvancedBacktester = Depends(get_backtester)
+):
+    """Run backtesting on a portfolio"""
+    try:
+        results, error = backtester.backtest_portfolio(
+            request.holdings,
+            request.start_date.strftime("%Y-%m-%d"),
+            request.end_date.strftime("%Y-%m-%d"),
+            request.benchmark
+        )
+        
+        if error:
+            raise HTTPException(status_code=400, detail=error)
+        
+        return BacktestResponse(**results)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/ai-analysis", response_model=SwarmAnalysisResponse)
+async def run_ai_analysis(
+    portfolio: Portfolio,
+    client_profile: ClientProfile
+):
+    """Run AI analysis using the swarm"""
+    try:
+        # Prepare portfolio data for analysis
+        portfolio_summary = f"""
+        Portfolio Value: ₹{portfolio.current_portfolio_value:,.0f}
+        Number of Holdings: {len(portfolio.holdings)}
+        Holdings: {portfolio.holdings}
+        """
+        
+        client_profile_str = f"""
+        Age: {client_profile.age}
+        Investment Horizon: {client_profile.investment_horizon}
+        Risk Tolerance: {client_profile.risk_tolerance}
+        Investment Objective: {client_profile.investment_objective}
+        Annual Income: ₹{client_profile.annual_income:,.0f}
+        """
+        
+        # Get economic data
+        economic_fetcher = EconomicDataFetcher()
+        rbi_repo_rate = economic_fetcher.get_rbi_repo_rate()
+        indian_inflation_rate = economic_fetcher.get_indian_inflation_rate()
+        
+        economic_context = f"""
+        Current RBI Repo Rate: {rbi_repo_rate:.2f}%
+        Current Indian Inflation Rate: {indian_inflation_rate:.2f}%
+        Real Interest Rate: {rbi_repo_rate - indian_inflation_rate:.2f}%
+        """
+        
+        # Run swarm analysis
+        swarm_result = create_portfolio_swarm(portfolio_summary, client_profile_str, economic_context)
+        
+        return SwarmAnalysisResponse(**swarm_result)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

app/core/config.py

@@ -0,0 +1,169 @@
+import os
+from dotenv import load_dotenv
+from pydantic_settings import BaseSettings
+
+load_dotenv()
+
+class Settings(BaseSettings):
+    SWARMS_API_KEY: str = os.getenv("SWARMS_API_KEY", "")
+    FRED_API_KEY: str = os.getenv("FRED_API_KEY", "")
+    BASE_URL: str = "https://api.swarms.world"
+    
+    # Nifty 50 symbols and names
+    NIFTY50_SYMBOLS: list = [
+        'ADANIENT.NS', 'ADANIPORTS.NS', 'APOLLOHOSP.NS', 'ASIANPAINT.NS',
+        'AXISBANK.NS', 'BAJAJ-AUTO.NS', 'BAJFINANCE.NS', 'BAJAJFINSV.NS', 
+        'BEL.NS', 'BHARTIARTL.NS', 'CIPLA.NS', 'COALINDIA.NS', 'DRREDDY.NS', 
+        'EICHERMOT.NS', 'GRASIM.NS', 'HCLTECH.NS', 'HDFCBANK.NS', 'HDFCLIFE.NS', 
+        'HEROMOTOCO.NS', 'HINDALCO.NS', 'HINDUNILVR.NS', 'ICICIBANK.NS', 
+        'INDUSINDBK.NS', 'INFY.NS', 'ITC.NS', 'JIOFIN.NS', 'JSWSTEEL.NS', 
+        'KOTAKBANK.NS', 'LT.NS', 'M&M.NS', 'MARUTI.NS', 'NESTLEIND.NS', 
+        'NTPC.NS', 'ONGC.NS', 'POWERGRID.NS', 'RELIANCE.NS', 'SBILIFE.NS', 
+        'SHRIRAMFIN.NS', 'SBIN.NS', 'SUNPHARMA.NS', 'TATACONSUM.NS', 'TCS.NS',
+        'TATAMOTORS.NS', 'TATASTEEL.NS', 'TECHM.NS', 'TITAN.NS', 'TRENT.NS', 
+        'ULTRACEMCO.NS', 'WIPRO.NS'
+    ]
+    
+    STOCK_NAMES: dict = {
+        'ADANIENT.NS': 'Adani Enterprises', 'ADANIPORTS.NS': 'Adani Ports', 
+        'APOLLOHOSP.NS': 'Apollo Hospitals', 'ASIANPAINT.NS': 'Asian Paints',
+        'AXISBANK.NS': 'Axis Bank', 'BAJAJ-AUTO.NS': 'Bajaj Auto', 
+        'BAJFINANCE.NS': 'Bajaj Finance', 'BAJAJFINSV.NS': 'Bajaj Finserv', 
+        'BEL.NS': 'Bharat Electronics', 'BHARTIARTL.NS': 'Bharti Airtel', 
+        'CIPLA.NS': 'Cipla', 'COALINDIA.NS': 'Coal India', 'DRREDDY.NS': 'Dr Reddy Labs',
+        'EICHERMOT.NS': 'Eicher Motors', 'GRASIM.NS': 'Grasim Industries', 
+        'HCLTECH.NS': 'HCL Technologies', 'HDFCBANK.NS': 'HDFC Bank', 
+        'HDFCLIFE.NS': 'HDFC Life', 'HEROMOTOCO.NS': 'Hero MotoCorp', 
+        'HINDALCO.NS': 'Hindalco', 'HINDUNILVR.NS': 'Hindustan Unilever', 
+        'ICICIBANK.NS': 'ICICI Bank', 'INDUSINDBK.NS': 'IndusInd Bank', 
+        'INFY.NS': 'Infosys', 'ITC.NS': 'ITC', 'JIOFIN.NS': 'Jio Financial',
+        'JSWSTEEL.NS': 'JSW Steel', 'KOTAKBANK.NS': 'Kotak Mahindra Bank', 
+        'LT.NS': 'Larsen & Toubro', 'M&M.NS': 'Mahindra & Mahindra', 
+        'MARUTI.NS': 'Maruti Suzuki', 'NESTLEIND.NS': 'Nestle India', 
+        'NTPC.NS': 'NTPC', 'ONGC.NS': 'ONGC', 'POWERGRID.NS': 'Power Grid Corp',
+        'RELIANCE.NS': 'Reliance Industries', 'SBILIFE.NS': 'SBI Life', 
+        'SHRIRAMFIN.NS': 'Shriram Finance', 'SBIN.NS': 'State Bank of India', 
+        'SUNPHARMA.NS': 'Sun Pharma', 'TATACONSUM.NS': 'Tata Consumer', 
+        'TCS.NS': 'Tata Consultancy Services', 'TATAMOTORS.NS': 'Tata Motors',
+        'TATASTEEL.NS': 'Tata Steel', 'TECHM.NS': 'Tech Mahindra', 
+        'TITAN.NS': 'Titan Company', 'TRENT.NS': 'Trent', 
+        'ULTRACEMCO.NS': 'UltraTech Cement', 'WIPRO.NS': 'Wipro'
+    }
+    
+    # Agent prompts
+    INVESTMENT_MANAGER_PROMPT: str = """
+    You are an experienced Indian Investment Portfolio Manager, responsible for coordinating a team of specialized financial AI agents to provide comprehensive investment recommendations for Indian equity markets.
+    Your responsibilities include:
+    1. Analyzing Indian portfolios and investment objectives in the context of NSE/BSE markets
+    2. Routing specific questions to appropriate specialist agents
+    3. Synthesizing inputs from various specialists into coherent recommendations
+    4. Ensuring recommendations follow sound investment principles for Indian markets
+    5. Considering Indian market factors: RBI policy, monsoons, FII/DII flows, government policies
+    6. Prioritizing recommendations based on client objectives and Indian market conditions
+    Always consider Indian market context:
+    - RBI repo rate, inflation, and monetary policy
+    - Sectoral performance and rotation in Indian markets
+    - Tax implications (LTCG/STCG, dividend tax)
+    - Currency (INR) considerations
+    - Government policy impacts and budget announcements
+    Your final recommendations should include:
+    - Clear assessment of current portfolio in Indian market context
+    - Prioritized investment recommendations with rationale
+    - Asset allocation adjustments with specific percentages
+    - Risk management considerations for Indian market volatility
+    - Implementation timeline suitable for Indian markets
+    """
+    
+    ASSET_ALLOCATION_PROMPT: str = """
+    You are an experienced Indian asset allocation specialist with deep knowledge of Indian equity markets, portfolio construction for NSE/BSE stocks, and Modern Portfolio Theory adapted for Indian markets.
+    Your responsibilities include:
+    1. Analyzing current portfolio allocations across Indian sectors and market caps
+    2. Assessing portfolio efficiency and diversification within Indian markets
+    3. Recommending optimal asset allocation for Indian equity portfolios
+    4. Balancing risk and return expectations in Indian market context
+    5. Considering sector rotation opportunities in Indian markets
+    When analyzing Indian portfolios:
+    - Evaluate allocation across sectors (IT, Banking, Pharma, Auto, etc.)
+    - Assess market cap distribution (Large, Mid, Small cap)
+    - Consider geographical exposure (domestic vs export-oriented companies)
+    - Analyze correlation with Indian market indices (Nifty, Sensex)
+    - Recommend specific allocation changes with percentage targets
+    - Consider Indian market liquidity and trading volumes
+    Base recommendations on Indian market characteristics and regulatory environment.
+    """
+    
+    MARKET_ANALYST_PROMPT: str = """
+    You are an experienced Indian market analyst with expertise in Indian economic cycles, government policies, and NSE/BSE market trends.
+    Your responsibilities include:
+    1. Analyzing Indian economic indicators and their market impact
+    2. Identifying current Indian market trends and sector rotation opportunities
+    3. Assessing valuation levels across Indian sectors and stocks
+    4. Recognizing potential risks and catalysts in Indian markets
+    5. Providing outlook for different Indian sectors and market segments
+    Focus on Indian market specific factors:
+    - RBI monetary policy and interest rate cycle
+    - Government policies, budget announcements, and reforms
+    - Monsoon predictions and agricultural sector impact
+    - FII/DII investment flows and market sentiment
+    - Corporate earnings growth and sector performance
+    - Currency (INR) movements and their sector impact
+    Provide actionable insights for Indian equity investors.
+    """
+    
+    RISK_ANALYST_PROMPT: str = """
+    You are an expert in Indian market risk analysis with extensive knowledge of Indian equity market risks, volatility patterns, and risk management strategies.
+    Your responsibilities include:
+    1. Identifying and quantifying risks specific to Indian equity portfolios
+    2. Analyzing portfolio vulnerability to Indian market scenarios
+    3. Recommending risk mitigation strategies for Indian market conditions
+    4. Assessing concentration risks in Indian portfolios
+    5. Evaluating currency and regulatory risks
+    Focus on Indian market risks:
+    - High volatility and market sentiment swings
+    - Sector concentration and diversification needs
+    - Regulatory risks from SEBI, RBI, and government policy changes
+    - Liquidity risks in mid and small-cap stocks
+    - Currency (INR) volatility impact on different sectors
+    - Political and policy uncertainty effects
+    Recommend practical risk management approaches suitable for Indian market conditions.
+    """
+    
+    FIXED_INCOME_PROMPT: str = """
+    You are an Indian fixed income specialist with expertise in Indian government bonds, corporate bonds, and fixed income strategies suitable for Indian investors.
+    Your responsibilities include:
+    1. Analyzing fixed income opportunities in Indian markets
+    2. Assessing interest rate risks in context of RBI policy
+    3. Evaluating credit risks in Indian corporate bonds
+    4. Recommending fixed income allocation for Indian portfolios
+    5. Identifying opportunities in Indian government securities, corporate bonds, and debt mutual funds
+    Consider Indian fixed income landscape:
+    - RBI monetary policy and repo rate changes
+    - Government borrowing programs and bond issuances
+    - Corporate credit quality and rating changes
+    - Tax implications of different fixed income instruments
+    - Inflation expectations and real returns
+    Provide recommendations suitable for Indian regulatory and tax environment.
+    """
+    
+    EQUITY_PROMPT: str = """
+    You are an Indian equity market specialist with deep expertise in NSE/BSE stocks, sector analysis, and Indian equity strategies.
+    Your responsibilities include:
+    1. Analyzing Indian equity positioning and sector allocation
+    2. Evaluating opportunities across market caps and sectors
+    3. Identifying Indian equity market opportunities and risks
+    4. Recommending equity strategies aligned with Indian market cycles
+    5. Assessing valuation levels of Indian stocks and sectors
+    Focus on Indian equity characteristics:
+    - Sector rotation patterns in Indian markets
+    - Market cap preferences (Large/Mid/Small cap dynamics)
+    - Export vs domestic-oriented company performance
+    - Seasonal patterns and festival season effects
+    - Corporate governance and quality factors
+    - Dividend yields and growth characteristics
+    Base recommendations on Indian market cycles, sectoral trends, and corporate fundamentals.
+    """
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

app/core/exceptions.py

@@ -0,0 +1,21 @@
+from fastapi import HTTPException
+
+class PortfolioException(HTTPException):
+    def __init__(self, status_code: int, detail: str):
+        super().__init__(status_code=status_code, detail=detail)
+
+class DataFetchException(PortfolioException):
+    def __init__(self, detail: str):
+        super().__init__(status_code=500, detail=f"Data fetch error: {detail}")
+
+class AnalysisException(PortfolioException):
+    def __init__(self, detail: str):
+        super().__init__(status_code=500, detail=f"Analysis error: {detail}")
+
+class BacktestException(PortfolioException):
+    def __init__(self, detail: str):
+        super().__init__(status_code=500, detail=f"Backtest error: {detail}")
+
+class SwarmException(PortfolioException):
+    def __init__(self, detail: str):
+        super().__init__(status_code=500, detail=f"Swarm analysis error: {detail}")

app/models/portfolio.py

@@ -0,0 +1,32 @@
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+class StockHolding(BaseModel):
+    symbol: str
+    name: str
+    quantity: int
+    current_price: float
+
+class Portfolio(BaseModel):
+    holdings: List[StockHolding]
+    current_portfolio_value: float
+    annual_income: float
+    age: int
+    investment_horizon: str
+    risk_tolerance: str
+    investment_objective: str
+
+class BacktestRequest(BaseModel):
+    holdings: Dict[str, int]  # symbol: quantity
+    start_date: datetime
+    end_date: datetime
+    benchmark: str = "^NSEI"
+
+class ClientProfile(BaseModel):
+    age: int
+    investment_horizon: str
+    risk_tolerance: str
+    investment_objective: str
+    annual_income: float
+    current_portfolio_value: float

app/models/response.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+class EconomicDataResponse(BaseModel):
+    rbi_repo_rate: float
+    indian_inflation_rate: float
+    real_interest_rate: float
+
+class MarketIndicesResponse(BaseModel):
+    indices: Dict[str, Dict[str, float]]
+
+class StockDataResponse(BaseModel):
+    symbol: str
+    current_price: float
+    volume: float
+    returns_1y: float
+    volatility: float
+    market_cap: float
+    pe_ratio: float
+    dividend_yield: float
+
+class PortfolioAnalysisResponse(BaseModel):
+    portfolio_value: float
+    number_of_holdings: int
+    sector_allocation: Dict[str, float]
+    holdings: List[Dict[str, Any]]
+
+class BacktestResponse(BaseModel):
+    total_return: float
+    annual_return: float
+    max_drawdown: float
+    annual_volatility: float
+    sharpe_ratio: float
+    sortino_ratio: float
+    beta: float
+    alpha: float
+    information_ratio: float
+    portfolio_cumulative: List[Dict[str, Any]]
+    benchmark_cumulative: List[Dict[str, Any]]
+    drawdown: List[Dict[str, Any]]
+
+class SwarmAnalysisResponse(BaseModel):
+    status: str
+    output: List[Dict[str, Any]]
+    error: Optional[str] = None

app/services/backtester.py

@@ -0,0 +1,109 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from typing import Dict, Tuple, Any
+from datetime import datetime
+from app.core.exceptions import BacktestException
+
+class AdvancedBacktester:
+    """Advanced portfolio backtesting"""
+    
+    def backtest_portfolio(self, holdings: Dict[str, int], start_date: str, end_date: str, benchmark: str = '^NSEI') -> Tuple[Dict[str, Any], str]:
+        """Backtest portfolio performance"""
+        symbols = list(holdings.keys())
+        
+        try:
+            # Fetch data for all symbols + benchmark
+            all_symbols = symbols + [benchmark]
+            data_dict = {}
+            
+            for symbol in all_symbols:
+                ticker = yf.Ticker(symbol)
+                hist = ticker.history(start=start_date, end=end_date)
+                if not hist.empty:
+                    data_dict[symbol] = hist['Close']
+            
+            if not data_dict:
+                return None, "No data available for backtesting period"
+            
+            # Convert to DataFrame
+            data = pd.DataFrame(data_dict)
+            data = data.dropna()
+            
+            if data.empty:
+                return None, "No overlapping data available"
+            
+            # Calculate portfolio weights based on initial investment
+            initial_prices = data.iloc[0][symbols]
+            total_investment = sum(holdings[symbol] * initial_prices[symbol] for symbol in symbols)
+            weights = {symbol: (holdings[symbol] * initial_prices[symbol]) / total_investment for symbol in symbols}
+            
+            # Portfolio returns
+            returns = data.pct_change().dropna()
+            portfolio_returns = pd.Series(0, index=returns.index)
+            
+            for symbol in symbols:
+                if symbol in returns.columns:
+                    portfolio_returns += returns[symbol] * weights[symbol]
+            
+            # Benchmark returns
+            benchmark_returns = returns[benchmark] if benchmark in returns.columns else pd.Series(0, index=returns.index)
+            
+            # Calculate cumulative returns
+            portfolio_cumulative = (1 + portfolio_returns).cumprod()
+            benchmark_cumulative = (1 + benchmark_returns).cumprod()
+            
+            # Calculate advanced metrics
+            annual_return = portfolio_returns.mean() * 252
+            annual_volatility = portfolio_returns.std() * np.sqrt(252)
+            sharpe_ratio = (annual_return - 0.05) / annual_volatility if annual_volatility > 0 else 0
+            
+            # Maximum drawdown
+            running_max = portfolio_cumulative.expanding().max()
+            drawdown = (portfolio_cumulative - running_max) / running_max
+            max_drawdown = drawdown.min()
+            
+            # Beta calculation
+            covariance = np.cov(portfolio_returns.dropna(), benchmark_returns.dropna())[0][1]
+            benchmark_variance = np.var(benchmark_returns.dropna())
+            beta = covariance / benchmark_variance if benchmark_variance > 0 else 0
+            
+            # Alpha calculation
+            benchmark_annual_return = benchmark_returns.mean() * 252
+            alpha = annual_return - (0.05 + beta * (benchmark_annual_return - 0.05))
+            
+            # Information ratio
+            active_returns = portfolio_returns - benchmark_returns
+            tracking_error = active_returns.std() * np.sqrt(252)
+            information_ratio = (annual_return - benchmark_annual_return) / tracking_error if tracking_error > 0 else 0
+            
+            # Sortino ratio
+            downside_returns = portfolio_returns[portfolio_returns < 0]
+            downside_deviation = downside_returns.std() * np.sqrt(252) if len(downside_returns) > 0 else annual_volatility
+            sortino_ratio = (annual_return - 0.05) / downside_deviation if downside_deviation > 0 else 0
+            
+            # Convert cumulative returns and drawdown to list of dicts for JSON serialization
+            portfolio_cumulative_list = [{'date': str(date), 'value': value} for date, value in portfolio_cumulative.items()]
+            benchmark_cumulative_list = [{'date': str(date), 'value': value} for date, value in benchmark_cumulative.items()]
+            drawdown_list = [{'date': str(date), 'value': value * 100} for date, value in drawdown.items()]
+            
+            results = {
+                'portfolio_cumulative': portfolio_cumulative_list,
+                'benchmark_cumulative': benchmark_cumulative_list,
+                'drawdown': drawdown_list,
+                'annual_return': annual_return * 100,
+                'annual_volatility': annual_volatility * 100,
+                'sharpe_ratio': sharpe_ratio,
+                'sortino_ratio': sortino_ratio,
+                'max_drawdown': max_drawdown * 100,
+                'beta': beta,
+                'alpha': alpha * 100,
+                'information_ratio': information_ratio,
+                'total_return': (portfolio_cumulative.iloc[-1] - 1) * 100,
+                'benchmark_return': (benchmark_cumulative.iloc[-1] - 1) * 100
+            }
+            
+            return results, None
+        
+        except Exception as e:
+            return None, str(e)

app/services/data_fetcher.py

@@ -0,0 +1,125 @@
+import requests
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Optional
+from app.core.config import settings
+from app.core.exceptions import DataFetchException
+
+class EconomicDataFetcher:
+    """Fetch economic data from FRED API"""
+    
+    def __init__(self):
+        self.fred_api_key = settings.FRED_API_KEY
+        self.base_url = "https://api.stlouisfed.org/fred/series/observations"
+        
+    def get_rbi_repo_rate(self) -> float:
+        """Fetch RBI repo rate from FRED"""
+        try:
+            params = {
+                'series_id': 'INTDSRINM193N',  # India Interest Rate
+                'api_key': self.fred_api_key,
+                'file_type': 'json',
+                'sort_order': 'desc',
+                'limit': 1
+            }
+            
+            response = requests.get(self.base_url, params=params)
+            data = response.json()
+            
+            if 'observations' in data and len(data['observations']) > 0:
+                return float(data['observations'][0]['value'])
+            else:
+                return 6.5  # Default fallback value
+        except Exception as e:
+            raise DataFetchException(f"Could not fetch repo rate from FRED: {str(e)}")
+    
+    def get_indian_inflation_rate(self) -> float:
+        """Fetch Indian inflation rate from FRED"""
+        try:
+            params = {
+                'series_id': 'FPCPITOTLZGIND',
+                'api_key': self.fred_api_key,
+                'file_type': 'json',
+                'sort_order': 'desc',
+                'limit': 1
+            }
+            
+            response = requests.get(self.base_url, params=params)
+            data = response.json()
+            
+            if 'observations' in data and len(data['observations']) > 0:
+                return float(data['observations'][0]['value'])
+            else:
+                return 5.7  # Default fallback value
+        except Exception as e:
+            raise DataFetchException(f"Could not fetch inflation rate from FRED: {str(e)}")
+
+class PortfolioDataFetcher:
+    """Fetch real-time portfolio and market data"""
+    
+    def __init__(self):
+        self.economic_fetcher = EconomicDataFetcher()
+        self.rbi_repo_rate = self.economic_fetcher.get_rbi_repo_rate()
+        self.indian_inflation_rate = self.economic_fetcher.get_indian_inflation_rate()
+        
+    def get_stock_data(self, symbols: List[str], period: str = "1y") -> Dict[str, Dict]:
+        """Fetch stock data for analysis"""
+        stock_data = {}
+        for symbol in symbols:
+            try:
+                ticker = yf.Ticker(symbol)
+                hist = ticker.history(period=period)
+                info = ticker.info
+                
+                if not hist.empty:
+                    # Calculate additional metrics
+                    returns_1y = ((hist['Close'].iloc[-1] - hist['Close'].iloc[0]) / hist['Close'].iloc[0]) * 100 if len(hist) > 252 else 0
+                    volatility = hist['Close'].pct_change().std() * np.sqrt(252) * 100
+                    
+                    stock_data[symbol] = {
+                        'history': hist,
+                        'info': info,
+                        'current_price': hist['Close'].iloc[-1],
+                        'volume': hist['Volume'].iloc[-1],
+                        'returns_1y': returns_1y,
+                        'volatility': volatility,
+                        'market_cap': info.get('marketCap', 0),
+                        'pe_ratio': info.get('forwardPE', info.get('trailingPE', 'N/A')),
+                        'dividend_yield': info.get('dividendYield', 0) * 100 if info.get('dividendYield') else 0
+                    }
+            except Exception as e:
+                raise DataFetchException(f"Error fetching {symbol}: {str(e)}")
+        return stock_data
+    
+    def get_market_indices(self) -> Dict[str, Dict]:
+        """Fetch Indian market indices data"""
+        indices = {
+            '^NSEI': 'Nifty 50',
+            '^BSESN': 'BSE Sensex',
+            '^NSEBANK': 'Nifty Bank',
+            '^CNXIT': 'Nifty IT',
+        }
+        
+        indices_data = {}
+        for symbol, name in indices.items():
+            try:
+                ticker = yf.Ticker(symbol)
+                hist = ticker.history(period="5d")
+                
+                if not hist.empty:
+                    current_price = hist['Close'].iloc[-1]
+                    previous_close = hist['Close'].iloc[-2] if len(hist) > 1 else current_price
+                    change = current_price - previous_close
+                    change_pct = (change / previous_close) * 100
+                    
+                    indices_data[name] = {
+                        'current_price': current_price,
+                        'change': change,
+                        'change_pct': change_pct,
+                        'volume': hist['Volume'].iloc[-1] if 'Volume' in hist else 0
+                    }
+            except Exception as e:
+                raise DataFetchException(f"Could not fetch data for {name}: {str(e)}")
+                
+        return indices_data

app/services/portfolio_analyzer.py

@@ -0,0 +1,91 @@
+import pandas as pd
+import numpy as np
+from typing import Dict, List
+from app.services.data_fetcher import EconomicDataFetcher
+from app.core.exceptions import AnalysisException
+
+class PortfolioAnalyzer:
+    """Analyze portfolio performance and risk"""
+    
+    def __init__(self):
+        self.economic_fetcher = EconomicDataFetcher()
+        self.risk_free_rate = self.economic_fetcher.get_rbi_repo_rate()
+    
+    def calculate_portfolio_metrics(self, weights, returns_df):
+        """Calculate portfolio metrics"""
+        portfolio_returns = (returns_df * weights).sum(axis=1)
+        expected_return = portfolio_returns.mean() * 252
+        volatility = portfolio_returns.std() * np.sqrt(252)
+        sharpe_ratio = (expected_return - self.risk_free_rate) / volatility if volatility > 0 else 0
+        
+        return {
+            'expected_return': expected_return,
+            'volatility': volatility,
+            'sharpe_ratio': sharpe_ratio,
+            'cumulative_return': (1 + portfolio_returns).prod() - 1
+        }
+    
+    def calculate_portfolio_value(self, holdings: Dict[str, Dict]) -> float:
+        """Calculate total portfolio value"""
+        total_value = 0
+        for symbol, data in holdings.items():
+            total_value += data['quantity'] * data['current_price']
+        return total_value
+    
+    def get_sector_allocation(self, holdings: Dict[str, Dict]) -> Dict[str, float]:
+        """Get sector allocation (simplified)"""
+        # In a real implementation, you would map stocks to sectors
+        sectors = {
+            'IT': ['TCS.NS', 'INFY.NS', 'HCLTECH.NS', 'TECHM.NS'],
+            'Banking': ['HDFCBANK.NS', 'ICICIBANK.NS', 'KOTAKBANK.NS', 'AXISBANK.NS', 'SBIN.NS'],
+            'FMCG': ['HINDUNILVR.NS', 'NESTLEIND.NS', 'ITC.NS', 'TITAN.NS'],
+            'Automobile': ['MARUTI.NS', 'TATAMOTORS.NS', 'M&M.NS', 'HEROMOTOCO.NS', 'BAJAJ-AUTO.NS'],
+            'Pharma': ['SUNPHARMA.NS', 'DRREDDY.NS', 'CIPLA.NS'],
+            'Energy': ['RELIANCE.NS', 'NTPC.NS', 'ONGC.NS', 'COALINDIA.NS'],
+            'Metals': ['TATASTEEL.NS', 'HINDALCO.NS', 'JSWSTEEL.NS'],
+            'Telecom': ['BHARTIARTL.NS'],
+            'Consumer Services': ['TRENT.NS', 'ASIANPAINT.NS'],
+            'Capital Goods': ['LT.NS', 'ULTRACEMCO.NS', 'GRASIM.NS'],
+            'Financial Services': ['BAJFINANCE.NS', 'BAJAJFINSV.NS', 'HDFCLIFE.NS', 'SBILIFE.NS', 'INDUSINDBK.NS'],
+            'Others': []
+        }
+        
+        sector_weights = {}
+        total_value = self.calculate_portfolio_value(holdings)
+        
+        for sector, stocks in sectors.items():
+            sector_value = 0
+            for stock in stocks:
+                if stock in holdings:
+                    sector_value += holdings[stock]['quantity'] * holdings[stock]['current_price']
+            sector_weights[sector] = (sector_value / total_value) * 100 if total_value > 0 else 0
+            
+        return sector_weights
+    
+    def analyze_portfolio(self, holdings: Dict[str, Dict], current_portfolio_value: float) -> Dict:
+        """Perform complete portfolio analysis"""
+        try:
+            portfolio_value = self.calculate_portfolio_value(holdings)
+            sector_allocation = self.get_sector_allocation(holdings)
+            
+            # Prepare holdings data for response
+            holdings_list = []
+            for symbol, data in holdings.items():
+                holdings_list.append({
+                    'Stock': data['name'],
+                    'Symbol': symbol,
+                    'Quantity': data['quantity'],
+                    'Current Price': f"₹{data['current_price']:.2f}",
+                    'Value': f"₹{data['quantity'] * data['current_price']:,.0f}",
+                    'Allocation': f"{(data['quantity'] * data['current_price'] / portfolio_value) * 100:.1f}%"
+                })
+            
+            return {
+                'portfolio_value': portfolio_value,
+                'number_of_holdings': len(holdings),
+                'sector_allocation': sector_allocation,
+                'holdings': holdings_list,
+                'portfolio_vs_benchmark': ((portfolio_value/current_portfolio_value - 1) * 100)
+            }
+        except Exception as e:
+            raise AnalysisException(f"Portfolio analysis failed: {str(e)}")

app/services/swarm_service.py

@@ -0,0 +1,89 @@
+import requests
+from typing import Dict, Any
+from app.core.config import settings
+from app.core.exceptions import SwarmException
+
+def create_portfolio_swarm(portfolio_data: str, client_profile: str, economic_context: str) -> Dict[str, Any]:
+    """Create swarm for portfolio analysis"""
+    
+    headers = {
+        "x-api-key": settings.SWARMS_API_KEY,
+        "Content-Type": "application/json"
+    }
+    
+    swarm_config = {
+        "name": "Investment Portfolio Analysis Swarm",
+        "description": "AI swarm specialized for Indian investment portfolio analysis",
+        "agents": [
+            {
+                "agent_name": "Asset Allocation Specialist", 
+                "system_prompt": settings.ASSET_ALLOCATION_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+            },
+            {
+                "agent_name": "Market Analyst",
+                "system_prompt": settings.MARKET_ANALYST_PROMPT,
+                "model_name": "gpt-4o", 
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+            },
+            {
+                "agent_name": "Risk Analyst",
+                "system_prompt": settings.RISK_ANALYST_PROMPT,
+                "model_name": "gpt-4o", 
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+            },
+            {
+                "agent_name": "Fixed Income Specialist",
+                "system_prompt": settings.FIXED_INCOME_PROMPT,
+                "model_name": "gpt-4o", 
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+            },
+            {
+                "agent_name": "Equity Specialist",
+                "system_prompt": settings.EQUITY_PROMPT,
+                "model_name": "gpt-4o", 
+                "role": "worker",
+                "max_loops": 2,
+                "max_tokens": 4096,
+                "temperature": 0.5,
+            },
+            {
+                "agent_name": "Investment Manager",
+                "system_prompt": settings.INVESTMENT_MANAGER_PROMPT,
+                "model_name": "gpt-4o",
+                "role": "worker",
+                "max_loops": 1,
+                "max_tokens": 4096,
+                "temperature": 0.3,
+            },
+        ],
+        "max_loops": 2,
+        "swarm_type": "ConcurrentWorkflow",
+        "task": f"""Analyze the following Indian investment portfolio:\n\n{portfolio_data}\n\n
+        Client Profile:\n{client_profile}\n\n
+        Economic Context:\n{economic_context}"""
+    }
+    
+    try:
+        response = requests.post(
+            f"{settings.BASE_URL}/v1/swarm/completions",
+            headers=headers,
+            json=swarm_config,
+            timeout=120
+        )
+        return response.json()
+    except Exception as e:
+        raise SwarmException(f"Swarm analysis failed: {str(e)}")

main.py

@@ -0,0 +1,66 @@
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+import time
+import logging
+
+from app.api.routes import router
+from app.core.exceptions import PortfolioException
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Investment Portfolio Decision Support System API",
+    description="API for AI-powered portfolio analysis for Indian markets",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust this in production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Add request logging middleware
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    start_time = time.time()
+    response = await call_next(request)
+    process_time = time.time() - start_time
+    logger.info(f"Request: {request.method} {request.url} - Completed in {process_time:.4f}s")
+    return response
+
+# Exception handler
+@app.exception_handler(PortfolioException)
+async def portfolio_exception_handler(request: Request, exc: PortfolioException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"message": exc.detail}
+    )
+
+# Include API routes
+app.include_router(router, prefix="/api/v1")
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "message": "API is running"}
+
+# Root endpoint
+@app.get("/")
+async def root():
+    return {
+        "message": "Investment Portfolio Decision Support System API",
+        "version": "1.0.0",
+        "docs": "/docs"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)