Upload 21 files

app/api/endpoints/ai.py

@@ -0,0 +1,99 @@
+from fastapi import APIRouter, Depends, HTTPException
+from app.services.ai_swarm import AISwarmService
+from app.models.ai_models import (
+    AIAnalysisRequest, AIAnalysisResponse,
+    AnalysisFocus, MarketView, InvestmentHorizon
+)
+
+router = APIRouter()
+
+@router.post("/analyze", response_model=AIAnalysisResponse)
+async def get_ai_recommendations(request: AIAnalysisRequest):
+    """
+    Get AI-powered investment recommendations based on client profile, portfolio, and goals
+    """
+    try:
+        ai_service = AISwarmService()
+        result = ai_service.get_enhanced_analysis(request)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating AI recommendations: {str(e)}")
+
+@router.post("/fund-selection")
+async def get_fund_selection_recommendations(
+    client_profile: dict,
+    goals_data: dict,
+    market_conditions: MarketView = MarketView.NEUTRAL,
+    investment_horizon: InvestmentHorizon = InvestmentHorizon.MEDIUM_TERM
+):
+    """
+    Get AI-powered fund selection recommendations
+    """
+    try:
+        ai_service = AISwarmService()
+        
+        request = AIAnalysisRequest(
+            client_profile=client_profile,
+            portfolio_data={},
+            goals_data=goals_data,
+            analysis_focus=[AnalysisFocus.FUND_SELECTION],
+            market_conditions=market_conditions,
+            investment_horizon=investment_horizon
+        )
+        
+        result = ai_service.get_enhanced_analysis(request)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating fund selection recommendations: {str(e)}")
+
+@router.post("/risk-assessment")
+async def get_risk_assessment(
+    client_profile: dict,
+    portfolio_data: dict,
+    market_conditions: MarketView = MarketView.NEUTRAL
+):
+    """
+    Get AI-powered risk assessment for a portfolio
+    """
+    try:
+        ai_service = AISwarmService()
+        
+        request = AIAnalysisRequest(
+            client_profile=client_profile,
+            portfolio_data=portfolio_data,
+            goals_data={},
+            analysis_focus=[AnalysisFocus.RISK_ASSESSMENT],
+            market_conditions=market_conditions,
+            investment_horizon=InvestmentHorizon.MEDIUM_TERM
+        )
+        
+        result = ai_service.get_enhanced_analysis(request)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating risk assessment: {str(e)}")
+
+@router.post("/goal-planning")
+async def get_goal_planning_recommendations(
+    client_profile: dict,
+    goals_data: dict,
+    investment_horizon: InvestmentHorizon = InvestmentHorizon.MEDIUM_TERM
+):
+    """
+    Get AI-powered goal planning recommendations
+    """
+    try:
+        ai_service = AISwarmService()
+        
+        request = AIAnalysisRequest(
+            client_profile=client_profile,
+            portfolio_data={},
+            goals_data=goals_data,
+            analysis_focus=[AnalysisFocus.GOAL_ALIGNMENT],
+            market_conditions=MarketView.NEUTRAL,
+            investment_horizon=investment_horizon
+        )
+        
+        result = ai_service.get_enhanced_analysis(request)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating goal planning recommendations: {str(e)}")

app/api/endpoints/funds.py

@@ -0,0 +1,184 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import List, Dict, Any, Optional
+from app.services.data_fetcher import MutualFundDataFetcher
+from app.services.sip_calculator import SIPCalculator
+from app.models.fund_models import (
+    FundNAVResponse, FundAnalysisRequest, FundAnalysisResponse
+)
+from app.models.goal_models import (
+    SIPCalculationRequest, SIPCalculationResponse,
+    RequiredSIPRequest, RequiredSIPResponse
+)
+
+# Popular mutual fund categories with scheme codes
+POPULAR_FUNDS = {
+    'Large Cap Equity': {
+        'HDFC Top 100 Fund': '120503',
+        'ICICI Pru Bluechip Fund': '120505', 
+        'SBI Bluechip Fund': '125497',
+        'Axis Bluechip Fund': '120503',
+        'Kotak Bluechip Fund': '118989'
+    },
+    'Mid Cap Equity': {
+        'HDFC Mid-Cap Opportunities Fund': '118551',
+        'ICICI Pru Mid Cap Fund': '120544',
+        'Kotak Emerging Equity Fund': '118999',
+        'SBI Magnum Mid Cap Fund': '100281',
+        'DSP Mid Cap Fund': '112618'
+    },
+    'Small Cap Equity': {
+        'SBI Small Cap Fund': '122639',
+        'DSP Small Cap Fund': '112618',
+        'HDFC Small Cap Fund': '118551',
+        'Axis Small Cap Fund': '125487',
+        'Kotak Small Cap Fund': '119028'
+    },
+    'ELSS (Tax Saving)': {
+        'Axis Long Term Equity Fund': '125494',
+        'HDFC Tax Saver': '100277',
+        'SBI Tax Saver': '125497',
+        'ICICI Pru ELSS Tax Saver': '120503',
+        'Kotak Tax Saver': '118989'
+    },
+    'Debt Funds': {
+        'HDFC Corporate Bond Fund': '101762',
+        'ICICI Pru Corporate Bond Fund': '120503',
+        'SBI Corporate Bond Fund': '125497',
+        'Kotak Corporate Bond Fund': '118989',
+        'Axis Corporate Debt Fund': '125494'
+    },
+    'Hybrid Funds': {
+        'HDFC Hybrid Equity Fund': '118551',
+        'ICICI Pru Balanced Advantage Fund': '120505',
+        'SBI Equity Hybrid Fund': '125497',
+        'Kotak Equity Hybrid Fund': '118999',
+        'Axis Hybrid Fund': '125494'
+    }
+}
+
+router = APIRouter()
+
+@router.get("/schemes")
+async def get_all_schemes():
+    """
+    Get all available mutual fund schemes
+    """
+    try:
+        fetcher = MutualFundDataFetcher()
+        schemes = fetcher.get_all_schemes()
+        return {"schemes": schemes}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching schemes: {str(e)}")
+
+@router.get("/nav/{scheme_code}", response_model=FundNAVResponse)
+async def get_fund_nav_history(scheme_code: str):
+    """
+    Get NAV history for a specific mutual fund scheme
+    """
+    try:
+        fetcher = MutualFundDataFetcher()
+        nav_data, fund_meta = fetcher.get_fund_nav_history(scheme_code)
+        
+        return FundNAVResponse(
+            meta=fund_meta,
+            data=nav_data.to_dict('records')
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching NAV data: {str(e)}")
+
+@router.get("/popular")
+async def get_popular_funds():
+    """
+    Get list of popular mutual funds by category
+    """
+    return POPULAR_FUNDS
+
+@router.post("/sip-calculate", response_model=SIPCalculationResponse)
+async def calculate_sip(request: SIPCalculationRequest, 
+                        include_yearly_breakdown: bool = Query(False, description="Include yearly breakdown in response")):
+    """
+    Calculate SIP maturity amount based on monthly investment, expected return, and time period
+    """
+    try:
+        calculator = SIPCalculator()
+        result = calculator.get_sip_calculation(request, include_yearly_breakdown)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error calculating SIP: {str(e)}")
+
+@router.post("/required-sip", response_model=RequiredSIPResponse)
+async def calculate_required_sip(request: RequiredSIPRequest):
+    """
+    Calculate required SIP amount to reach a target amount
+    """
+    try:
+        calculator = SIPCalculator()
+        result = calculator.get_required_sip(request)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error calculating required SIP: {str(e)}")
+
+@router.post("/analyze", response_model=FundAnalysisResponse)
+async def analyze_funds(request: FundAnalysisRequest):
+    """
+    Analyze performance of selected mutual funds over a specified period
+    """
+    try:
+        fetcher = MutualFundDataFetcher()
+        calculator = SIPCalculator()
+        
+        analysis_results = []
+        
+        for fund_name in request.fund_names:
+            # Find scheme code for the fund
+            scheme_code = None
+            fund_category = None
+            
+            for category, funds in POPULAR_FUNDS.items():
+                if fund_name in funds:
+                    scheme_code = funds[fund_name]
+                    fund_category = category
+                    break
+            
+            if not scheme_code:
+                continue
+                
+            # Fetch NAV data
+            nav_data, fund_meta = fetcher.get_fund_nav_history(scheme_code)
+            
+            if not nav_data.empty:
+                returns_data = calculator.calculate_fund_returns(
+                    nav_data, request.investment_amount, request.start_date, request.end_date
+                )
+                
+                if returns_data:
+                    analysis_results.append({
+                        'fund_name': fund_name,
+                        'category': fund_category,
+                        'scheme_code': scheme_code,
+                        'fund_house': fund_meta.fund_house,
+                        'returns_data': returns_data,
+                        'nav_data': nav_data.to_dict('records'),
+                        'fund_meta': fund_meta.dict()
+                    })
+        
+        # Prepare comparison data
+        comparison_data = []
+        for result in analysis_results:
+            returns = result['returns_data']
+            comparison_data.append({
+                'Fund Name': result['fund_name'],
+                'Category': result['category'],
+                'Fund House': result['fund_house'],
+                'Investment': f"₹{returns['investment_amount']:,.0f}",
+                'Current Value': f"₹{returns['final_value']:,.0f}",
+                'Total Return': f"{returns['total_return']:.2f}%",
+                'Absolute Gain': f"₹{returns['final_value'] - returns['investment_amount']:,.0f}"
+            })
+        
+        return FundAnalysisResponse(
+            results=analysis_results,
+            comparison_data=comparison_data
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error analyzing funds: {str(e)}")

app/api/endpoints/goals.py

@@ -0,0 +1,81 @@
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List, Dict, Any
+from app.models.goal_models import (
+    ClientProfile, InvestmentGoal, GoalsDashboard,
+    SIPCalculationRequest, SIPCalculationResponse,
+    RequiredSIPRequest, RequiredSIPResponse, GoalsDashboardRequest
+)
+from app.services.sip_calculator import SIPCalculator
+
+router = APIRouter()
+
+@router.post("/dashboard", response_model=GoalsDashboard)
+async def get_goals_dashboard(request: GoalsDashboardRequest):
+    """
+    Calculate goals dashboard metrics including total required SIP, shortfall/surplus
+    """
+    try:
+        total_required_sip = sum(goal.required_sip for goal in request.goals)
+        shortfall = max(0, total_required_sip - request.monthly_savings)
+        surplus = max(0, request.monthly_savings - total_required_sip)
+        
+        return GoalsDashboard(
+            goals=request.goals,
+            total_required_sip=total_required_sip,
+            monthly_savings=request.monthly_savings,
+            shortfall=shortfall,
+            surplus=surplus
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error calculating goals dashboard: {str(e)}")
+
+@router.post("/calculate-sip", response_model=SIPCalculationResponse)
+async def calculate_sip(
+    request: SIPCalculationRequest,
+    include_yearly_breakdown: bool = False
+):
+    """
+    Calculate SIP maturity amount based on monthly investment, expected return, and time period
+    """
+    try:
+        calculator = SIPCalculator()
+        result = calculator.get_sip_calculation(request, include_yearly_breakdown)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error calculating SIP: {str(e)}")
+
+@router.post("/required-sip", response_model=RequiredSIPResponse)
+async def calculate_required_sip(request: RequiredSIPRequest):
+    """
+    Calculate required SIP amount to reach a target amount
+    """
+    try:
+        calculator = SIPCalculator()
+        result = calculator.get_required_sip(request)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error calculating required SIP: {str(e)}")
+
+@router.post("/inflation-adjusted")
+async def calculate_inflation_adjusted_amount(
+    target_amount: float,
+    years: int,
+    expected_inflation: float
+):
+    """
+    Calculate inflation-adjusted target amount for a goal
+    """
+    try:
+        inflation_adjusted_amount = target_amount * ((1 + expected_inflation/100) ** years)
+        calculator = SIPCalculator()
+        required_sip = calculator.calculate_required_sip(inflation_adjusted_amount, years, 12)
+        
+        return {
+            "original_amount": target_amount,
+            "inflation_adjusted_amount": inflation_adjusted_amount,
+            "required_sip": required_sip,
+            "years": years,
+            "expected_inflation": expected_inflation
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error calculating inflation-adjusted amount: {str(e)}")

app/api/endpoints/market.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter, Depends, HTTPException
+from app.services.data_fetcher import MutualFundDataFetcher
+from app.models.fund_models import MarketIndicesResponse
+
+router = APIRouter()
+
+@router.get("/indices", response_model=MarketIndicesResponse)
+async def get_market_indices():
+    """
+    Get current market indices data including Nifty 50, Sensex, etc.
+    """
+    try:
+        fetcher = MutualFundDataFetcher()
+        indices_data = fetcher.get_market_indices()
+        return indices_data
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching market indices: {str(e)}")

app/api/endpoints/portfolio.py

@@ -0,0 +1,72 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import Dict, Any, List
+from app.services.portfolio_analyzer import PortfolioAnalyzer
+from app.models.portfolio_models import (
+    Portfolio, PortfolioMetrics, PortfolioTemplate,
+    RebalanceAnalysis, PerformanceReport
+)
+
+router = APIRouter()
+
+@router.post("/metrics", response_model=PortfolioMetrics)
+async def calculate_portfolio_metrics(portfolio: Portfolio):
+    """
+    Calculate portfolio-level metrics including total value, gains, and category allocation
+    """
+    try:
+        analyzer = PortfolioAnalyzer()
+        metrics = analyzer.calculate_portfolio_metrics(portfolio.holdings)
+        return metrics
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error calculating portfolio metrics: {str(e)}")
+
+@router.post("/rebalance", response_model=RebalanceAnalysis)
+async def generate_rebalance_analysis(portfolio: Portfolio):
+    """
+    Generate detailed rebalancing analysis and recommendations for a portfolio
+    """
+    try:
+        analyzer = PortfolioAnalyzer()
+        rebalance_analysis = analyzer.generate_rebalance_analysis(portfolio.holdings)
+        return rebalance_analysis
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating rebalance analysis: {str(e)}")
+
+@router.post("/performance", response_model=PerformanceReport)
+async def generate_performance_report(portfolio: Portfolio):
+    """
+    Generate comprehensive performance report for a portfolio
+    """
+    try:
+        analyzer = PortfolioAnalyzer()
+        performance_report = analyzer.generate_performance_report(portfolio.holdings)
+        return performance_report
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating performance report: {str(e)}")
+
+@router.get("/template/{template}")
+async def get_portfolio_template(template: PortfolioTemplate):
+    """
+    Get a predefined portfolio template (Conservative, Balanced, Aggressive, Custom Sample)
+    """
+    try:
+        analyzer = PortfolioAnalyzer()
+        template_portfolio = analyzer.get_template_portfolio(template)
+        return {"template": template_portfolio}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting portfolio template: {str(e)}")
+
+@router.get("/templates")
+async def get_all_portfolio_templates():
+    """
+    Get all available portfolio templates
+    """
+    try:
+        templates = {}
+        for template in PortfolioTemplate:
+            analyzer = PortfolioAnalyzer()
+            template_portfolio = analyzer.get_template_portfolio(template)
+            templates[template.value] = template_portfolio
+        return templates
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting portfolio templates: {str(e)}")

app/config.py

@@ -0,0 +1,25 @@
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    # API Configuration
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "Mutual Fund Investment API"
+    
+    # External API Keys
+    SWARMS_API_KEY: str = os.getenv("SWARMS_API_KEY", "")
+    SWARMS_BASE_URL: str = "https://api.swarms.world"
+    
+    # Mutual Fund API
+    MFAPI_BASE_URL: str = "https://api.mfapi.in/mf"
+    
+    # CORS Configuration
+    BACKEND_CORS_ORIGINS: list[str] = ["http://localhost:8501", "http://localhost:3000"]
+    
+    # Cache TTL (in seconds)
+    CACHE_TTL: int = 3600
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

app/models/ai_models.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional, Any
+from enum import Enum
+
+class AnalysisFocus(str, Enum):
+    FUND_SELECTION = "Fund Selection"
+    RISK_ASSESSMENT = "Risk Assessment"
+    GOAL_ALIGNMENT = "Goal Alignment"
+    TAX_OPTIMIZATION = "Tax Optimization"
+    REBALANCING = "Rebalancing"
+
+class MarketView(str, Enum):
+    BULLISH = "Bullish"
+    NEUTRAL = "Neutral"
+    BEARISH = "Bearish"
+    VOLATILE = "Volatile"
+
+class InvestmentHorizon(str, Enum):
+    SHORT_TERM = "Short Term (1-3 years)"
+    MEDIUM_TERM = "Medium Term (3-7 years)"
+    LONG_TERM = "Long Term (7+ years)"
+
+class AIAnalysisRequest(BaseModel):
+    client_profile: Dict[str, Any]
+    portfolio_data: Dict[str, Any]
+    goals_data: Dict[str, Any]
+    analysis_focus: List[AnalysisFocus]
+    market_conditions: MarketView
+    investment_horizon: InvestmentHorizon
+
+class AISwarmAgent(BaseModel):
+    agent_name: str
+    content: Optional[str] = None
+
+class AIAnalysisResponse(BaseModel):
+    success: bool
+    error: Optional[str] = None
+    output: Optional[List[AISwarmAgent]] = None

app/models/fund_models.py

@@ -0,0 +1,62 @@
+from pydantic import BaseModel, Field, field_validator
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+
+class FundMeta(BaseModel):
+    fund_house: Optional[str] = None
+    scheme_type: Optional[str] = None
+    scheme_category: Optional[str] = None
+    scheme_code: Optional[str] = None
+    
+    @field_validator('scheme_code', mode='before')
+    @classmethod
+    def convert_scheme_code_to_str(cls, v):
+        if v is not None:
+            return str(v)
+        return v
+
+class NAVData(BaseModel):
+    date: datetime
+    nav: float
+
+class FundNAVResponse(BaseModel):
+    meta: FundMeta
+    data: List[NAVData]
+
+class MarketIndex(BaseModel):
+    name: str
+    symbol: str
+    current_price: float
+    change: float
+    change_pct: float
+
+class MarketIndicesResponse(BaseModel):
+    indices: List[MarketIndex]
+    last_updated: datetime
+
+class FundAnalysisRequest(BaseModel):
+    fund_names: List[str]
+    investment_amount: float = Field(gt=0)
+    start_date: datetime
+    end_date: datetime
+
+class FundReturn(BaseModel):
+    start_nav: float
+    end_nav: float
+    units: float
+    final_value: float
+    total_return: float
+    investment_amount: float
+
+class FundAnalysisResult(BaseModel):
+    fund_name: str
+    category: str
+    scheme_code: str
+    fund_house: str
+    returns_data: FundReturn
+    nav_data: List[NAVData]
+    fund_meta: FundMeta
+
+class FundAnalysisResponse(BaseModel):
+    results: List[FundAnalysisResult]
+    comparison_data: List[Dict[str, Any]]

app/models/goal_models.py

@@ -0,0 +1,74 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+from enum import Enum
+
+class RiskTolerance(str, Enum):
+    CONSERVATIVE = "Conservative"
+    MODERATE = "Moderate"
+    AGGRESSIVE = "Aggressive"
+
+class InvestmentExperience(str, Enum):
+    BEGINNER = "Beginner"
+    INTERMEDIATE = "Intermediate"
+    ADVANCED = "Advanced"
+
+class TaxBracket(str, Enum):
+    TEN_PERCENT = "10%"
+    TWENTY_PERCENT = "20%"
+    THIRTY_PERCENT = "30%"
+
+class PriorityLevel(str, Enum):
+    LOW = "Low"
+    MEDIUM = "Medium"
+    HIGH = "High"
+    CRITICAL = "Critical"
+
+class ClientProfile(BaseModel):
+    age: int = Field(ge=18, le=100)
+    monthly_income: float = Field(gt=0)
+    risk_tolerance: RiskTolerance
+    investment_experience: InvestmentExperience
+    tax_bracket: TaxBracket
+    monthly_savings: float = Field(gt=0)
+
+class InvestmentGoal(BaseModel):
+    name: str
+    amount: float = Field(gt=0)
+    inflation_adjusted_amount: float = Field(gt=0)
+    years: int = Field(ge=1, le=40)
+    priority: PriorityLevel
+    required_sip: float = Field(ge=0)
+    expected_inflation: float = Field(ge=0, le=20)
+    id: int
+
+class GoalsDashboard(BaseModel):
+    goals: List[InvestmentGoal]
+    total_required_sip: float
+    monthly_savings: float
+    shortfall: float
+    surplus: float
+
+class SIPCalculationRequest(BaseModel):
+    monthly_amount: float = Field(gt=0)
+    annual_return: float = Field(ge=0)
+    years: int = Field(ge=1)
+
+class SIPCalculationResponse(BaseModel):
+    maturity_amount: float
+    total_invested: float
+    gains: float
+    return_multiple: float
+    yearly_breakdown: Optional[List[Dict[str, Any]]] = None
+
+class RequiredSIPRequest(BaseModel):
+    target_amount: float = Field(gt=0)
+    years: int = Field(ge=1)
+    expected_return: float = Field(ge=0)
+
+class RequiredSIPResponse(BaseModel):
+    required_sip: float
+
+class GoalsDashboardRequest(BaseModel):
+    goals: List[InvestmentGoal]
+    monthly_savings: float

app/models/portfolio_models.py

@@ -0,0 +1,62 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional, Any
+from datetime import datetime
+from enum import Enum
+
+class InvestmentType(str, Enum):
+    LUMP_SUM = "Lump Sum"
+    SIP_MONTHLY = "SIP (Monthly)"
+    STP = "STP"
+
+class PortfolioHolding(BaseModel):
+    scheme_code: str
+    category: str
+    fund_house: str
+    invested_amount: float = Field(gt=0)
+    current_value: float = Field(gt=0)
+    units: float = Field(gt=0)
+    current_nav: float = Field(gt=0)
+    investment_type: InvestmentType
+    nav_data: List[Any] = []
+
+class Portfolio(BaseModel):
+    holdings: Dict[str, PortfolioHolding] = {}
+
+class PortfolioMetrics(BaseModel):
+    total_value: float
+    total_invested: float
+    total_gains: float
+    category_allocation: Dict[str, float]
+
+class PortfolioTemplate(str, Enum):
+    CONSERVATIVE = "Conservative"
+    BALANCED = "Balanced"
+    AGGRESSIVE = "Aggressive"
+    CUSTOM_SAMPLE = "Custom Sample"
+
+class RebalanceAction(BaseModel):
+    category: str
+    current_pct: float
+    target_pct: float
+    difference: float
+    amount_change: float
+    action: str  # "INCREASE" or "DECREASE"
+
+class RebalanceAnalysis(BaseModel):
+    actions: List[RebalanceAction]
+    recommended_strategy: str
+    target_allocation: Dict[str, float]
+
+class PerformanceReport(BaseModel):
+    total_invested: float
+    total_value: float
+    total_gains: float
+    overall_return_pct: float
+    fund_performance: List[Dict[str, Any]]
+    best_performer: Optional[str] = None
+    worst_performer: Optional[str] = None
+    max_return: float
+    min_return: float
+    volatility: float
+    sharpe_ratio: float
+    portfolio_metrics: PortfolioMetrics

app/services/ai_swarm.py

@@ -0,0 +1,338 @@
+import requests
+import json
+from typing import Dict, Any, List
+from app.config import settings
+from app.models.ai_models import AIAnalysisRequest, AIAnalysisResponse, AISwarmAgent
+import pandas as pd
+
+# Popular mutual fund categories with scheme codes
+POPULAR_FUNDS = {
+    'Large Cap Equity': {
+        'HDFC Top 100 Fund': '120503',
+        'ICICI Pru Bluechip Fund': '120505', 
+        'SBI Bluechip Fund': '125497',
+        'Axis Bluechip Fund': '120503',
+        'Kotak Bluechip Fund': '118989'
+    },
+    'Mid Cap Equity': {
+        'HDFC Mid-Cap Opportunities Fund': '118551',
+        'ICICI Pru Mid Cap Fund': '120544',
+        'Kotak Emerging Equity Fund': '118999',
+        'SBI Magnum Mid Cap Fund': '100281',
+        'DSP Mid Cap Fund': '112618'
+    },
+    'Small Cap Equity': {
+        'SBI Small Cap Fund': '122639',
+        'DSP Small Cap Fund': '112618',
+        'HDFC Small Cap Fund': '118551',
+        'Axis Small Cap Fund': '125487',
+        'Kotak Small Cap Fund': '119028'
+    },
+    'ELSS (Tax Saving)': {
+        'Axis Long Term Equity Fund': '125494',
+        'HDFC Tax Saver': '100277',
+        'SBI Tax Saver': '125497',
+        'ICICI Pru ELSS Tax Saver': '120503',
+        'Kotak Tax Saver': '118989'
+    },
+    'Debt Funds': {
+        'HDFC Corporate Bond Fund': '101762',
+        'ICICI Pru Corporate Bond Fund': '120503',
+        'SBI Corporate Bond Fund': '125497',
+        'Kotak Corporate Bond Fund': '118989',
+        'Axis Corporate Debt Fund': '125494'
+    },
+    'Hybrid Funds': {
+        'HDFC Hybrid Equity Fund': '118551',
+        'ICICI Pru Balanced Advantage Fund': '120505',
+        'SBI Equity Hybrid Fund': '125497',
+        'Kotak Equity Hybrid Fund': '118999',
+        'Axis Hybrid Fund': '125494'
+    }
+}
+
+# AI Agent Prompts for Mutual Funds
+FUND_SELECTION_PROMPT = """
+You are an expert Indian mutual fund selection specialist with deep knowledge of fund analysis, 
+performance evaluation, and fund house comparisons for Indian mutual fund markets.
+Your responsibilities:
+1. Analyze fund performance across different time periods (1Y, 3Y, 5Y)
+2. Evaluate expense ratios and their impact on long-term returns  
+3. Assess fund manager track record and consistency
+4. Compare funds within categories using quantitative metrics
+5. Identify funds with consistent alpha generation
+6. Evaluate fund house stability and investor service quality
+Focus areas for Indian mutual fund analysis:
+- Performance consistency across market cycles
+- Expense ratio optimization (direct vs regular plans)
+- Fund manager tenure and investment philosophy  
+- AUM growth and scalability
+- Category benchmarking and peer comparison
+- Tax efficiency and dividend distribution policy
+- Goal-based fund recommendations
+Provide specific recommendations with rationale for Indian investors.
+"""
+
+GOAL_PLANNING_PROMPT = """
+You are an expert in goal-based financial planning specialized in mapping investment 
+goals to appropriate mutual fund strategies for Indian investors.
+Your responsibilities:
+1. Analyze client goals for timeline, amount, and priority
+2. Map goals to appropriate fund categories and asset allocation
+3. Design SIP strategies aligned with goal timelines  
+4. Recommend optimal fund combinations for multiple goals
+5. Plan step-up SIP strategies for inflation adjustment
+6. Create tax-efficient investment strategies including ELSS
+Goal-based fund mapping expertise:
+- Short-term goals (1-3 years): Debt funds, liquid funds
+- Medium-term goals (3-7 years): Hybrid funds, large cap equity
+- Long-term goals (7+ years): Mid cap, small cap equity
+- Tax-saving goals: ELSS funds with 3-year lock-in
+- Retirement planning: Systematic equity exposure with debt balancing
+- Emergency funds: Liquid funds with instant redemption capability
+Provide actionable SIP recommendations with specific amounts and fund selections.
+"""
+
+RISK_ASSESSMENT_PROMPT = """
+You are an expert in mutual fund risk analysis with extensive knowledge of 
+fund-specific risks, category risks, and portfolio risk management for Indian mutual fund investments.
+Your responsibilities:
+1. Assess fund-specific risks including manager risk, style drift
+2. Analyze category concentration and diversification needs
+3. Evaluate expense ratio impact on long-term wealth creation
+4. Assess liquidity risks across different fund categories
+5. Identify regulatory and tax-related risks
+6. Recommend risk mitigation strategies
+Focus on Indian mutual fund risk factors:
+- Fund manager tenure and philosophy changes
+- Category concentration and overlap analysis
+- Expense ratio drag on returns over long periods
+- Exit load structures and liquidity constraints
+- Tax implications of different fund types
+- Market timing risks in equity fund investments
+- Credit risks in debt fund categories
+Provide practical risk management recommendations for Indian mutual fund investors.
+"""
+
+FUND_ALLOCATION_PROMPT = """
+You are an expert in mutual fund portfolio allocation and performance analysis, with deep knowledge of fund analysis, performance evaluation, and fund house comparisons for the Indian mutual fund market. Your role is to evaluate fund performance, provide insights on key metrics, and generate tailored recommendations based on individual investor needs and goals.
+Your Responsibilities:
+1. Fund Performance Analysis:
+    Analyze fund performance over different time periods (1Y, 3Y, 5Y) to assess consistency and growth potential.
+2. Expense Ratio Evaluation:
+    Evaluate expense ratios (direct vs regular plans) and their long-term impact on net returns for different types of investors.
+3. Fund Manager Analysis:
+    Assess the track record and investment philosophy of the fund manager. Determine consistency in management and its impact on performance.
+4. Category Comparison:
+    Compare funds within categories (e.g., equity, debt, hybrid) using quantitative metrics such as:
+      Risk-adjusted returns
+      Sharpe ratio
+      Alpha generation
+      Drawdowns and volatility
+5. Alpha Generation Identification:
+    Identify funds that consistently generate alpha (outperform the benchmark) and assess the strategies that lead to such performance.
+6. Fund House Stability:
+    Evaluate the fund house's financial stability, reputation, and investor service quality.
+    Analyze AUM growth and scalability of the fund house to ensure long-term reliability.
+7. Tax Efficiency & Dividend Distribution Policy:
+    Evaluate the tax efficiency of each fund considering capital gains tax, dividend distribution, and holding period taxation.
+    Provide insights into how these factors impact long-term returns for Indian investors.
+8. Goal-Based Fund Recommendations:
+    Provide goal-based fund recommendations (e.g., retirement, education, wealth creation) with tailored suggestions based on:
+      Risk tolerance
+      Investment horizon
+      Tax considerations
+
+Key Areas of Focus for Indian Mutual Fund Analysis:
+ Performance Consistency Across Market Cycles:
+  Assess how well the fund performs in different market environments (bullish, bearish, sideways).
+ Expense Ratio Optimization (Direct vs Regular Plans):
+  Evaluate the trade-off between cost efficiency and accessibility, recommending the most suitable fund plans for different investor types.
+ Fund Manager Tenure & Investment Philosophy:
+  Assess the impact of a fund manager's tenure and their investment philosophy on the fund's consistency and long-term performance.
+ AUM Growth & Scalability:
+  Determine how AUM growth impacts a fund's ability to scale and maintain performance. Large AUM may affect liquidity and flexibility, but also signal trust.
+ Category Benchmarking & Peer Comparison:
+  Compare funds against category benchmarks (e.g., Nifty 50 for equity, Crisil for debt) and identify top performers within their category.
+ Tax Efficiency & Dividend Policies:
+  Evaluate tax efficiency considering capital gains, dividends, and fund turnover. Provide strategies to minimize tax liabilities over the investment horizon.
+ Goal-Based Recommendations:
+  Provide tailored investment solutions based on individual investor goals, such as:
+   Retirement planning
+   Wealth creation
+   Education funding
+   Short-term goals
+
+Recommendations for Indian Investors:
+1. Equity Funds (Growth-Oriented):
+    Focus on funds with strong long-term performance, consistently high alpha, and low expense ratios. These funds are suitable for growth-focused investors seeking capital appreciation.
+2. Debt Funds (Risk-Averse):
+    For investors with a low risk tolerance, recommend low-volatility funds with stable returns and a track record of consistency. Ensure tax-efficient funds for better after-tax returns.
+3. Hybrid Funds (Balanced Approach):
+    Combine equity and debt for a diversified approach. These funds are suitable for investors seeking a balance between risk and reward, particularly those with a medium-term horizon.
+4. Tax Efficiency:
+    Recommend funds that are tax-efficient, such as those with lower turnover and capital gains distributions. Focus on LTCG tax advantages for long-term investors.
+5. Goal-Based Recommendations:
+    For retirement planning, suggest equity funds for long-term growth. For short-term goals, recommend debt funds or hybrid funds based on the investor's risk appetite.
+Provide specific recommendations with rationale for Indian investors.
+Make use of the following advanced portfolio techniques where applicable:
+1. Modern Portfolio Theory (MPT) – Efficient Frontier 
+2. Risk Parity Allocation
+3. Black-Litterman Model
+4. Monte Carlo Simulation
+"""
+
+class AISwarmService:
+    """Service for creating AI swarms for mutual fund analysis"""
+    
+    def __init__(self):
+        self.api_key = settings.SWARMS_API_KEY
+        self.base_url = settings.SWARMS_BASE_URL
+        self.headers = {
+            "x-api-key": self.api_key,
+            "Content-Type": "application/json"
+        }
+    
+    def create_mutual_fund_swarm(self, portfolio_data: Dict[str, Any], 
+                                 client_profile: Dict[str, Any], 
+                                 goals_data: Dict[str, Any]) -> AIAnalysisResponse:
+        """Create AI swarm for mutual fund analysis"""
+        
+        swarm_config = {
+            "name": "Mutual Fund Investment Analysis Swarm",
+            "description": "AI swarm for Indian mutual fund investment analysis and recommendations",
+            "agents": [
+                {
+                    "agent_name": "Fund Selection Specialist",
+                    "system_prompt": FUND_SELECTION_PROMPT,
+                    "model_name": "gpt-4o",
+                    "role": "worker",
+                    "max_loops": 1,
+                    "max_tokens": 4096,
+                    "temperature": 0.3,
+                },
+                {
+                    "agent_name": "Goal Planning Specialist", 
+                    "system_prompt": GOAL_PLANNING_PROMPT,
+                    "model_name": "gpt-4o",
+                    "role": "worker", 
+                    "max_loops": 1,
+                    "max_tokens": 4096,
+                    "temperature": 0.3,
+                },
+                {
+                    "agent_name": "Risk Assessment Specialist",
+                    "system_prompt": RISK_ASSESSMENT_PROMPT,
+                    "model_name": "gpt-4o",
+                    "role": "worker",
+                    "max_loops": 1, 
+                    "max_tokens": 4096,
+                    "temperature": 0.3,
+                },
+                {
+                    "agent_name": "Fund Allocation Specialist",
+                    "system_prompt": FUND_ALLOCATION_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 mutual fund investment requirements:
+            
+            Client Profile: {client_profile}
+            Current Portfolio: {portfolio_data}  
+            Investment Goals: {goals_data}
+            
+            Provide comprehensive recommendations for:
+            1. Fund selection and optimization
+            2. Goal-based SIP planning
+            3. Risk assessment and mitigation
+            4. Tax-efficient strategies
+            5. Implementation roadmap
+            """
+        }
+        
+        try:
+            if self.api_key:
+                response = requests.post(
+                    f"{self.base_url}/v1/swarm/completions",
+                    headers=self.headers,
+                    json=swarm_config,
+                    timeout=120
+                )
+                
+                if response.status_code == 200:
+                    result = response.json()
+                    
+                    # Parse the output to extract agent responses
+                    output_agents = []
+                    if "output" in result and isinstance(result["output"], list):
+                        for agent_output in result["output"]:
+                            if isinstance(agent_output, dict):
+                                output_agents.append(AISwarmAgent(
+                                    agent_name=agent_output.get("agent_name", ""),
+                                    content=agent_output.get("content", "")
+                                ))
+                    
+                    return AIAnalysisResponse(
+                        success=True,
+                        output=output_agents
+                    )
+                else:
+                    return AIAnalysisResponse(
+                        success=False,
+                        error=f"API request failed with status code {response.status_code}"
+                    )
+            else:
+                return AIAnalysisResponse(
+                    success=False,
+                    error="Swarms API key not configured"
+                )
+        except Exception as e:
+            return AIAnalysisResponse(
+                success=False,
+                error=f"Swarm analysis failed: {str(e)}"
+            )
+    
+    def get_enhanced_analysis(self, request: AIAnalysisRequest) -> AIAnalysisResponse:
+        """Get enhanced AI analysis with additional context"""
+        
+        # Prepare comprehensive data for AI analysis
+        client_profile = request.client_profile
+        
+        portfolio_data = {
+            'holdings': request.portfolio_data.get('holdings', []),
+            'categories': request.portfolio_data.get('categories', []),
+            'total_value': request.portfolio_data.get('total_value', 0),
+            'total_invested': request.portfolio_data.get('total_invested', 0),
+            'total_gains': request.portfolio_data.get('total_gains', 0),
+            'category_allocation': request.portfolio_data.get('category_allocation', {})
+        }
+        
+        goals_data = {
+            'goals': request.goals_data.get('goals', []),
+            'goal_details': request.goals_data.get('goal_details', []),
+            'total_required_sip': request.goals_data.get('total_required_sip', 0),
+            'timeline_range': request.goals_data.get('timeline_range', ""),
+            'priority_goals': request.goals_data.get('priority_goals', [])
+        }
+        
+        # Enhanced context
+        analysis_context = {
+            'market_conditions': request.market_conditions.value,
+            'investment_horizon': request.investment_horizon.value,
+            'analysis_focus': [focus.value for focus in request.analysis_focus],
+            'current_date': str(pd.Timestamp.now())
+        }
+        
+        # Run AI analysis
+        return self.create_mutual_fund_swarm(
+            {**portfolio_data, **analysis_context}, 
+            client_profile, 
+            goals_data
+        )

app/services/data_fetcher.py

@@ -0,0 +1,101 @@
+import requests
+import yfinance as yf
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional, Tuple
+from app.config import settings
+from app.models.fund_models import FundMeta, NAVData, FundNAVResponse, MarketIndex, MarketIndicesResponse
+
+class MutualFundDataFetcher:
+    """Fetch mutual fund data from MFAPI.in and Yahoo Finance for indices"""
+    
+    def __init__(self):
+        self.mfapi_base = settings.MFAPI_BASE_URL
+        
+    def get_all_schemes(self) -> List[Dict[str, Any]]:
+        """Fetch all mutual fund schemes"""
+        try:
+            response = requests.get(self.mfapi_base)
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return []
+        except Exception as e:
+            print(f"Error fetching schemes: {e}")
+            return []
+    
+    def get_fund_nav_history(self, scheme_code: str) -> Tuple[pd.DataFrame, FundMeta]:
+        """Fetch NAV history for a specific scheme"""
+        try:
+            url = f"{self.mfapi_base}/{scheme_code}"
+            response = requests.get(url)
+            if response.status_code == 200:
+                data = response.json()
+                nav_data = data.get('data', [])
+                
+                # Convert to DataFrame
+                df = pd.DataFrame(nav_data)
+                if not df.empty:
+                    df['date'] = pd.to_datetime(df['date'], format='%d-%m-%Y')
+                    df['nav'] = pd.to_numeric(df['nav'])
+                    df = df.sort_values('date')
+                
+                # Create FundMeta object
+                meta_data = data.get('meta', {})
+                fund_meta = FundMeta(
+                    fund_house=meta_data.get('fund_house'),
+                    scheme_type=meta_data.get('scheme_type'),
+                    scheme_category=meta_data.get('scheme_category'),
+                    scheme_code=str(meta_data.get('scheme_code', scheme_code))
+                )
+                
+                return df, fund_meta
+            else:
+                return pd.DataFrame(), FundMeta()
+        except Exception as e:
+            print(f"Error fetching NAV data: {e}")
+            return pd.DataFrame(), FundMeta()
+    
+    def get_market_indices(self) -> MarketIndicesResponse:
+        """Fetch Indian market indices using Yahoo Finance"""
+        indices = {
+            '^NSEI': 'Nifty 50',
+            '^BSESN': 'BSE Sensex',
+            '^NSEBANK': 'Nifty Bank',
+            '^CNXIT': 'Nifty IT',
+            '^NSEMDCP50': 'Nifty Midcap 50',           
+            'NIFTYSMLCAP50.NS': 'Nifty Smallcap 50',   
+            '^CNXPHARMA': 'Nifty Pharma',              
+            '^CNXAUTO': 'Nifty Auto',
+            '^CNXFMCG': 'Nifty FMCG',
+            '^CNXENERGY': 'Nifty Energy',
+            '^CNXREALTY': 'Nifty Realty',              
+            '^NSMIDCP': 'Nifty Next 50',               
+        }
+        
+        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.append(MarketIndex(
+                        name=name,
+                        symbol=symbol,
+                        current_price=current_price,
+                        change=change,
+                        change_pct=change_pct
+                    ))
+            except Exception as e:
+                print(f"Could not fetch {name}: {e}")
+                
+        return MarketIndicesResponse(
+            indices=indices_data,
+            last_updated=datetime.now()
+        )

app/services/portfolio_analyzer.py

@@ -0,0 +1,296 @@
+import numpy as np
+import pandas as pd
+from typing import Dict, Any, List, Tuple, Optional
+from app.models.portfolio_models import (
+    Portfolio, PortfolioMetrics, PortfolioTemplate, 
+    RebalanceAction, RebalanceAnalysis, PerformanceReport
+)
+
+class PortfolioAnalyzer:
+    """Analyze mutual fund portfolio performance and allocation"""
+    
+    @staticmethod
+    def calculate_portfolio_metrics(portfolio_holdings: Dict[str, Any]) -> PortfolioMetrics:
+        """Calculate portfolio-level metrics"""
+        if not portfolio_holdings:
+            return PortfolioMetrics(
+                total_value=0,
+                total_invested=0,
+                total_gains=0,
+                category_allocation={}
+            )
+            
+        total_value = sum(holding.current_value for holding in portfolio_holdings.values())
+        
+        metrics = {
+            'total_value': total_value,
+            'total_invested': sum(holding.invested_amount for holding in portfolio_holdings.values()),
+            'total_gains': total_value - sum(holding.invested_amount for holding in portfolio_holdings.values()),
+            'category_allocation': {}
+        }
+        
+        # Calculate category allocation
+        for fund_name, holding in portfolio_holdings.items():
+            category = holding.category if hasattr(holding, 'category') else 'Other'
+            if category not in metrics['category_allocation']:
+                metrics['category_allocation'][category] = 0
+            metrics['category_allocation'][category] += holding.current_value
+        
+        # Convert to percentages
+        for category in metrics['category_allocation']:
+            metrics['category_allocation'][category] = (
+                metrics['category_allocation'][category] / total_value
+            ) * 100 if total_value > 0 else 0
+            
+        return PortfolioMetrics(**metrics)
+    
+    @staticmethod
+    def generate_rebalance_analysis(portfolio: Dict[str, Any]) -> RebalanceAnalysis:
+        """Generate detailed rebalancing analysis and recommendations"""
+        if not portfolio:
+            return RebalanceAnalysis(
+                actions=[],
+                recommended_strategy="No portfolio data available",
+                target_allocation={}
+            )
+        
+        portfolio_metrics = PortfolioAnalyzer.calculate_portfolio_metrics(portfolio)
+        current_allocation = portfolio_metrics.category_allocation
+        
+        # Define target allocations based on common strategies
+        target_allocations = {
+            'Conservative': {
+                'Large Cap Equity': 30, 'Debt Funds': 40, 'Hybrid Funds': 25, 
+                'ELSS (Tax Saving)': 5, 'Mid Cap Equity': 0, 'Small Cap Equity': 0
+            },
+            'Balanced': {
+                'Large Cap Equity': 40, 'Mid Cap Equity': 25, 'ELSS (Tax Saving)': 15, 
+                'Debt Funds': 15, 'Hybrid Funds': 5, 'Small Cap Equity': 0
+            },
+            'Aggressive': {
+                'Large Cap Equity': 35, 'Mid Cap Equity': 30, 'Small Cap Equity': 25,
+                'ELSS (Tax Saving)': 10, 'Debt Funds': 0, 'Hybrid Funds': 0
+            }
+        }
+        
+        # Determine closest target allocation
+        total_equity = (current_allocation.get('Large Cap Equity', 0) + 
+                       current_allocation.get('Mid Cap Equity', 0) + 
+                       current_allocation.get('Small Cap Equity', 0))
+        
+        if total_equity >= 70:
+            recommended_strategy = 'Aggressive'
+        elif total_equity >= 45:
+            recommended_strategy = 'Balanced'
+        else:
+            recommended_strategy = 'Conservative'
+        
+        target = target_allocations[recommended_strategy]
+        total_portfolio_value = portfolio_metrics.total_value
+        
+        # Calculate rebalancing requirements
+        rebalance_actions = []
+        for category in target:
+            current_pct = current_allocation.get(category, 0)
+            target_pct = target[category]
+            difference = target_pct - current_pct
+            
+            if abs(difference) > 5:  # Only suggest rebalancing if difference > 5%
+                current_value = (current_pct / 100) * total_portfolio_value
+                target_value = (target_pct / 100) * total_portfolio_value
+                amount_change = target_value - current_value
+                
+                action = "INCREASE" if difference > 0 else "DECREASE"
+                rebalance_actions.append(RebalanceAction(
+                    category=category,
+                    current_pct=current_pct,
+                    target_pct=target_pct,
+                    difference=difference,
+                    amount_change=amount_change,
+                    action=action
+                ))
+        
+        return RebalanceAnalysis(
+            actions=rebalance_actions,
+            recommended_strategy=recommended_strategy,
+            target_allocation=target
+        )
+    
+    @staticmethod
+    def generate_performance_report(portfolio: Dict[str, Any]) -> PerformanceReport:
+        """Generate comprehensive performance report"""
+        if not portfolio:
+            return PerformanceReport(
+                total_invested=0,
+                total_value=0,
+                total_gains=0,
+                overall_return_pct=0,
+                fund_performance=[],
+                max_return=0,
+                min_return=0,
+                volatility=0,
+                sharpe_ratio=0,
+                portfolio_metrics=PortfolioMetrics(
+                    total_value=0,
+                    total_invested=0,
+                    total_gains=0,
+                    category_allocation={}
+                )
+            )
+        
+        portfolio_metrics = PortfolioAnalyzer.calculate_portfolio_metrics(portfolio)
+        
+        # Calculate performance metrics
+        total_invested = portfolio_metrics.total_invested
+        total_value = portfolio_metrics.total_value
+        total_gains = portfolio_metrics.total_gains
+        
+        if total_invested > 0:
+            overall_return_pct = (total_gains / total_invested) * 100
+        else:
+            overall_return_pct = 0
+        
+        # Fund-wise performance
+        fund_performance = []
+        best_performer = None
+        worst_performer = None
+        max_return = float('-inf')
+        min_return = float('inf')
+        
+        for fund_name, holding in portfolio.items():
+            invested = holding.invested_amount
+            current = holding.current_value
+            gain_loss = current - invested
+            return_pct = (gain_loss / invested * 100) if invested > 0 else 0
+            
+            fund_performance.append({
+                'fund': fund_name,
+                'category': holding.category if hasattr(holding, 'category') else 'Other',
+                'invested': invested,
+                'current_value': current,
+                'gain_loss': gain_loss,
+                'return_pct': return_pct
+            })
+            
+            if return_pct > max_return:
+                max_return = return_pct
+                best_performer = fund_name
+            
+            if return_pct < min_return:
+                min_return = return_pct
+                worst_performer = fund_name
+        
+        # Risk metrics (simplified)
+        returns = [perf['return_pct'] for perf in fund_performance]
+        if len(returns) > 1:
+            volatility = np.std(returns)
+            sharpe_ratio = (np.mean(returns) - 6) / volatility if volatility > 0 else 0  # Assuming 6% risk-free rate
+        else:
+            volatility = 0
+            sharpe_ratio = 0
+        
+        return PerformanceReport(
+            total_invested=total_invested,
+            total_value=total_value,
+            total_gains=total_gains,
+            overall_return_pct=overall_return_pct,
+            fund_performance=fund_performance,
+            best_performer=best_performer,
+            worst_performer=worst_performer,
+            max_return=max_return,
+            min_return=min_return,
+            volatility=volatility,
+            sharpe_ratio=sharpe_ratio,
+            portfolio_metrics=portfolio_metrics
+        )
+    
+    @staticmethod
+    def get_template_portfolio(template: PortfolioTemplate) -> Dict[str, Any]:
+        """Get a predefined portfolio template"""
+        templates = {
+            PortfolioTemplate.CONSERVATIVE: {
+                'HDFC Corporate Bond Fund': {
+                    'scheme_code': '101762', 'category': 'Debt Funds',
+                    'invested_amount': 40000, 'current_value': 42000, 'units': 800, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'HDFC Top 100 Fund': {
+                    'scheme_code': '120503', 'category': 'Large Cap Equity',
+                    'invested_amount': 30000, 'current_value': 33000, 'units': 600, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'HDFC Hybrid Equity Fund': {
+                    'scheme_code': '118551', 'category': 'Hybrid Funds',
+                    'invested_amount': 30000, 'current_value': 32000, 'units': 600, 
+                    'investment_type': 'SIP (Monthly)'
+                }
+            },
+            PortfolioTemplate.BALANCED: {
+                'HDFC Top 100 Fund': {
+                    'scheme_code': '120503', 'category': 'Large Cap Equity',
+                    'invested_amount': 40000, 'current_value': 45000, 'units': 800, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'ICICI Pru Mid Cap Fund': {
+                    'scheme_code': '120544', 'category': 'Mid Cap Equity',
+                    'invested_amount': 30000, 'current_value': 36000, 'units': 400, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'HDFC Tax Saver': {
+                    'scheme_code': '100277', 'category': 'ELSS (Tax Saving)',
+                    'invested_amount': 20000, 'current_value': 23000, 'units': 400, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'HDFC Corporate Bond Fund': {
+                    'scheme_code': '101762', 'category': 'Debt Funds',
+                    'invested_amount': 10000, 'current_value': 10500, 'units': 200, 
+                    'investment_type': 'Lump Sum'
+                }
+            },
+            PortfolioTemplate.AGGRESSIVE: {
+                'SBI Small Cap Fund': {
+                    'scheme_code': '122639', 'category': 'Small Cap Equity',
+                    'invested_amount': 30000, 'current_value': 38000, 'units': 500, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'ICICI Pru Mid Cap Fund': {
+                    'scheme_code': '120544', 'category': 'Mid Cap Equity',
+                    'invested_amount': 30000, 'current_value': 36000, 'units': 400, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'HDFC Top 100 Fund': {
+                    'scheme_code': '120503', 'category': 'Large Cap Equity',
+                    'invested_amount': 25000, 'current_value': 28000, 'units': 500, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'Kotak Emerging Equity Fund': {
+                    'scheme_code': '118999', 'category': 'Mid Cap Equity',
+                    'invested_amount': 15000, 'current_value': 18000, 'units': 200, 
+                    'investment_type': 'SIP (Monthly)'
+                }
+            },
+            PortfolioTemplate.CUSTOM_SAMPLE: {
+                'HDFC Balanced Advantage Fund': {
+                    'scheme_code': '104248', 'category': 'Hybrid Funds',
+                    'invested_amount': 30000, 'current_value': 34000, 'units': 600, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'HDFC Top 100 Fund': {
+                    'scheme_code': '120503', 'category': 'Large Cap Equity',
+                    'invested_amount': 30000, 'current_value': 33000, 'units': 600, 
+                    'investment_type': 'SIP (Monthly)'
+                },
+                'HDFC Corporate Bond Fund': {
+                    'scheme_code': '101762', 'category': 'Debt Funds',
+                    'invested_amount': 20000, 'current_value': 21000, 'units': 400, 
+                    'investment_type': 'Lump Sum'
+                },
+                'HDFC Tax Saver': {
+                    'scheme_code': '100277', 'category': 'ELSS (Tax Saving)',
+                    'invested_amount': 20000, 'current_value': 23000, 'units': 400, 
+                    'investment_type': 'SIP (Monthly)'
+                }
+            }
+        }
+        
+        return templates.get(template, {})

app/services/sip_calculator.py

@@ -0,0 +1,115 @@
+import pandas as pd
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+from app.models.goal_models import SIPCalculationRequest, SIPCalculationResponse, RequiredSIPRequest, RequiredSIPResponse
+
+class SIPCalculator:
+    """Calculate SIP returns and goal-based investments"""
+    
+    @staticmethod
+    def calculate_sip_maturity(monthly_amount: float, annual_return: float, years: int) -> float:
+        """Calculate SIP maturity amount"""
+        if annual_return == 0:
+            return monthly_amount * years * 12
+            
+        monthly_return = annual_return / 12 / 100
+        months = years * 12
+        
+        maturity_amount = monthly_amount * (
+            ((1 + monthly_return) ** months - 1) / monthly_return
+        ) * (1 + monthly_return)
+        
+        return maturity_amount
+    
+    @staticmethod  
+    def calculate_required_sip(target_amount: float, years: int, expected_return: float) -> float:
+        """Calculate required SIP amount for a target"""
+        if expected_return == 0:
+            return target_amount / (years * 12)
+            
+        monthly_return = expected_return / 12 / 100
+        months = years * 12
+        
+        required_sip = target_amount / (
+            ((1 + monthly_return) ** months - 1) / monthly_return
+        ) / (1 + monthly_return)
+        
+        return required_sip
+    
+    @staticmethod
+    def calculate_fund_returns(nav_data: pd.DataFrame, investment_amount: float, 
+                              start_date: datetime, end_date: datetime) -> Optional[Dict[str, Any]]:
+        """Calculate returns for a fund investment"""
+        try:
+            filtered_data = nav_data[
+                (nav_data['date'] >= pd.to_datetime(start_date)) & 
+                (nav_data['date'] <= pd.to_datetime(end_date))
+            ]
+            
+            if len(filtered_data) < 2:
+                return None
+                
+            start_nav = filtered_data.iloc[0]['nav']
+            end_nav = filtered_data.iloc[-1]['nav']
+            
+            units = investment_amount / start_nav
+            final_value = units * end_nav
+            total_return = ((final_value - investment_amount) / investment_amount) * 100
+            
+            return {
+                'start_nav': start_nav,
+                'end_nav': end_nav,
+                'units': units,
+                'final_value': final_value,
+                'total_return': total_return,
+                'investment_amount': investment_amount
+            }
+        except Exception as e:
+            print(f"Error calculating returns: {e}")
+            return None
+    
+    @staticmethod
+    def get_sip_calculation(request: SIPCalculationRequest, include_yearly_breakdown: bool = False) -> SIPCalculationResponse:
+        """Get SIP calculation with optional yearly breakdown"""
+        maturity_amount = SIPCalculator.calculate_sip_maturity(
+            request.monthly_amount, request.annual_return, request.years
+        )
+        
+        total_invested = request.monthly_amount * request.years * 12
+        gains = maturity_amount - total_invested
+        return_multiple = maturity_amount / total_invested if total_invested > 0 else 0
+        
+        yearly_breakdown = None
+        if include_yearly_breakdown:
+            yearly_breakdown = []
+            invested_cumulative = 0
+            
+            for year in range(1, request.years + 1):
+                maturity_year = SIPCalculator.calculate_sip_maturity(
+                    request.monthly_amount, request.annual_return, year
+                )
+                invested_year = request.monthly_amount * year * 12
+                
+                yearly_breakdown.append({
+                    'Year': year,
+                    'Invested': invested_year,
+                    'Maturity Value': maturity_year,
+                    'Gains': maturity_year - invested_year
+                })
+        
+        return SIPCalculationResponse(
+            maturity_amount=maturity_amount,
+            total_invested=total_invested,
+            gains=gains,
+            return_multiple=return_multiple,
+            yearly_breakdown=yearly_breakdown
+        )
+    
+    @staticmethod
+    def get_required_sip(request: RequiredSIPRequest) -> RequiredSIPResponse:
+        """Get required SIP amount for a target"""
+        required_sip = SIPCalculator.calculate_required_sip(
+            request.target_amount, request.years, request.expected_return
+        )
+        
+        return RequiredSIPResponse(required_sip=required_sip)