Create app.py

app.py

@@ -0,0 +1,771 @@
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import gradio as gr
+from datetime import datetime, timedelta
+import warnings
+import logging
+from typing import List, Dict, Tuple
+import os
+import json
+
+# Hugging Face and LangChain imports
+from langchain.docstore.document import Document
+from langchain_huggingface import HuggingFaceEmbeddings, HuggingFacePipeline
+from langchain.vectorstores import Chroma
+from langchain.chains import RetrievalQA
+from langchain.prompts import PromptTemplate
+import transformers
+from transformers import AutoTokenizer
+
+warnings.filterwarnings('ignore')
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class MutualFundRAG:
+    """RAG system for mutual fund portfolio optimization with LLM"""
+    
+    def __init__(self):
+        # Popular mutual fund tickers
+        self.fund_tickers = [
+            'VTIAX',  # Vanguard Total International Stock Index
+            'VTSAX',  # Vanguard Total Stock Market Index
+            'VBTLX',  # Vanguard Total Bond Market Index
+            'VTBLX',  # Vanguard Total International Bond Index
+            'VGIAX',  # Vanguard Growth Index
+            'VIMAX',  # Vanguard Mid-Cap Index
+            'VSMAX',  # Vanguard Small-Cap Index
+            'VGSLX',  # Vanguard Real Estate Index
+            'VHDYX',  # Vanguard High Dividend Yield Index
+            'VTAPX'   # Vanguard Target Retirement 2065
+        ]
+        
+        # Additional popular funds
+        self.extended_tickers = [
+            'FXNAX',  # Fidelity US Bond Index
+            'FSKAX',  # Fidelity Total Market Index
+            'FTIHX',  # Fidelity Total International Index
+            'SPY',    # SPDR S&P 500 ETF
+            'QQQ',    # Invesco QQQ Trust
+            'VTI',    # Vanguard Total Stock Market ETF
+            'BND',    # Vanguard Total Bond Market ETF
+        ]
+        
+        self.fund_data = None
+        self.embeddings = None
+        self.vectorstore = None
+        self.qa_chain = None
+        self.llm = None
+        
+        # Market indicators
+        self.market_indicators = {}
+        
+        # User profile
+        self.user_profile = {
+            'risk_tolerance': 'moderate',
+            'investment_amount': 50000,
+            'investment_horizon': 5,
+            'preferred_sectors': []
+        }
+    
+    def initialize_llm(self, model_name="Qwen/Qwen3-0.6B-Base"):
+        """Initialize the LLM for RAG system"""
+        try:
+            logger.info(f"Initializing LLM: {model_name}")
+            
+            # Initialize tokenizer and model
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            
+            model = transformers.AutoModelForCausalLM.from_pretrained(
+                model_name,
+                device_map="auto",
+                torch_dtype="auto"
+            )
+            
+            # Create pipeline
+            pipeline = transformers.pipeline(
+                "text-generation",
+                model=model,
+                tokenizer=tokenizer,
+                max_new_tokens=512,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=tokenizer.eos_token_id
+            )
+            
+            self.llm = HuggingFacePipeline(pipeline=pipeline)
+            logger.info("LLM initialized successfully")
+            return "✅ LLM initialized successfully"
+            
+        except Exception as e:
+            logger.error(f"Error initializing LLM: {e}")
+            return f"❌ Error initializing LLM: {str(e)}"
+    
+    def fetch_fund_data(self, tickers: List[str] = None, period: str = '1y') -> pd.DataFrame:
+        """Fetch real mutual fund data from Yahoo Finance"""
+        if tickers is None:
+            tickers = self.fund_tickers
+        
+        fund_data = []
+        
+        logger.info("Fetching mutual fund data from Yahoo Finance...")
+        
+        for ticker in tickers:
+            try:
+                fund = yf.Ticker(ticker)
+                hist = fund.history(period=period)
+                info = fund.info
+                
+                if hist.empty:
+                    continue
+                
+                # Calculate metrics
+                returns = hist['Close'].pct_change().dropna()
+                avg_return = returns.mean() * 252  # Annualized
+                volatility = returns.std() * np.sqrt(252)  # Annualized
+                sharpe_ratio = avg_return / volatility if volatility != 0 else 0
+                
+                # Get latest NAV
+                latest_nav = hist['Close'].iloc[-1]
+                
+                # Risk categorization
+                if volatility < 0.1:
+                    risk_level = 'Low'
+                elif volatility < 0.2:
+                    risk_level = 'Medium'
+                else:
+                    risk_level = 'High'
+                
+                # Get fund information
+                fund_name = info.get('longName', ticker)
+                category = info.get('category', 'Unknown')
+                expense_ratio = info.get('annualReportExpenseRatio', np.nan)
+                
+                # Estimate sector exposure (simplified)
+                sector_exposure = self.estimate_sector_exposure(fund_name, category)
+                
+                fund_data.append({
+                    'Ticker': ticker,
+                    'Name': fund_name[:50] + '...' if len(fund_name) > 50 else fund_name,
+                    'Category': category,
+                    'NAV': round(latest_nav, 2),
+                    'Annual_Return_%': round(avg_return * 100, 2),
+                    'Volatility_%': round(volatility * 100, 2),
+                    'Sharpe_Ratio': round(sharpe_ratio, 3),
+                    'Risk_Level': risk_level,
+                    'Expense_Ratio_%': round(expense_ratio * 100, 2) if not np.isnan(expense_ratio) else 'N/A',
+                    **sector_exposure
+                })
+                
+                logger.info(f"Successfully fetched data for {ticker}")
+                
+            except Exception as e:
+                logger.error(f"Error fetching {ticker}: {e}")
+                continue
+        
+        self.fund_data = pd.DataFrame(fund_data)
+        return self.fund_data
+    
+    def estimate_sector_exposure(self, fund_name: str, category: str) -> Dict:
+        """Estimate sector exposure based on fund type"""
+        sector_exposure = {
+            'Technology_%': 0,
+            'Healthcare_%': 0,
+            'Finance_%': 0,
+            'Energy_%': 0,
+            'Consumer_%': 0,
+            'Real_Estate_%': 0
+        }
+        
+        fund_name_lower = fund_name.lower()
+        category_lower = category.lower()
+        
+        if 'technology' in fund_name_lower or 'tech' in fund_name_lower:
+            sector_exposure['Technology_%'] = np.random.uniform(60, 90)
+        elif 'real estate' in fund_name_lower or 'reit' in fund_name_lower:
+            sector_exposure['Real_Estate_%'] = np.random.uniform(70, 95)
+        elif 'total' in fund_name_lower or 'market' in fund_name_lower:
+            # Diversified fund
+            total = 100
+            for sector in sector_exposure.keys():
+                if total > 0:
+                    allocation = np.random.uniform(10, 25)
+                    allocation = min(allocation, total)
+                    sector_exposure[sector] = round(allocation, 1)
+                    total -= allocation
+        else:
+            # Random allocation for other funds
+            remaining = 100
+            sectors = list(sector_exposure.keys())
+            for i, sector in enumerate(sectors[:-1]):
+                if remaining > 0:
+                    allocation = np.random.uniform(0, min(30, remaining))
+                    sector_exposure[sector] = round(allocation, 1)
+                    remaining -= allocation
+            sector_exposure[sectors[-1]] = round(remaining, 1)
+        
+        return sector_exposure
+    
+    def get_market_indicators(self) -> Dict:
+        """Fetch current market indicators"""
+        try:
+            # Fetch 10-year treasury yield
+            treasury = yf.Ticker("^TNX")
+            treasury_hist = treasury.history(period="5d")
+            interest_rate = treasury_hist['Close'].iloc[-1] if not treasury_hist.empty else 3.5
+            
+            # VIX for market volatility
+            vix = yf.Ticker("^VIX")
+            vix_hist = vix.history(period="5d")
+            market_volatility = vix_hist['Close'].iloc[-1] if not vix_hist.empty else 20
+            
+            self.market_indicators = {
+                'Interest_Rate_%': round(interest_rate, 2),
+                'Inflation_Rate_%': 3.2,  # Static for demo
+                'Market_Volatility_VIX': round(market_volatility, 2),
+                'Last_Updated': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            }
+            
+            return self.market_indicators
+            
+        except Exception as e:
+            logger.error(f"Error fetching market indicators: {e}")
+            return {
+                'Interest_Rate_%': 3.5,
+                'Inflation_Rate_%': 3.2,
+                'Market_Volatility_VIX': 20.0,
+                'Last_Updated': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            }
+    
+    def prepare_documents(self) -> List[Document]:
+        """Convert fund data to documents for ChromaDB"""
+        if self.fund_data is None or self.fund_data.empty:
+            return []
+        
+        documents = []
+        
+        for _, row in self.fund_data.iterrows():
+            content = f"""
+            Fund: {row['Ticker']} - {row['Name']}
+            Category: {row['Category']}
+            NAV: ${row['NAV']}
+            Annual Return: {row['Annual_Return_%']}%
+            Volatility: {row['Volatility_%']}%
+            Sharpe Ratio: {row['Sharpe_Ratio']}
+            Risk Level: {row['Risk_Level']}
+            Expense Ratio: {row['Expense_Ratio_%']}%
+            Sector Allocation - Technology: {row['Technology_%']}%, Healthcare: {row['Healthcare_%']}%, 
+            Finance: {row['Finance_%']}%, Energy: {row['Energy_%']}%, 
+            Consumer: {row['Consumer_%']}%, Real Estate: {row['Real_Estate_%']}%
+            Market Context - Interest Rate: {self.market_indicators.get('Interest_Rate_%', 'N/A')}%, 
+            Inflation: {self.market_indicators.get('Inflation_Rate_%', 'N/A')}%, 
+            VIX: {self.market_indicators.get('Market_Volatility_VIX', 'N/A')}
+            """
+            
+            documents.append(Document(page_content=content.strip()))
+        
+        return documents
+    
+    def setup_rag_system(self):
+        """Setup the complete RAG system"""
+        try:
+            logger.info("Setting up RAG system...")
+            
+            # Initialize embeddings
+            self.embeddings = HuggingFaceEmbeddings(
+                model_name="sentence-transformers/all-MiniLM-L6-v2"
+            )
+            
+            # Prepare documents
+            documents = self.prepare_documents()
+            
+            if not documents:
+                return "❌ No documents to process. Please fetch fund data first."
+            
+            # Setup ChromaDB
+            self.vectorstore = Chroma.from_documents(
+                documents=documents,
+                collection_name="mutual_fund_optimization",
+                embedding=self.embeddings,
+                persist_directory="./mutual_fund_db"
+            )
+            
+            # Setup QA chain if LLM is available
+            if self.llm is not None:
+                template = """
+                You are a financial advisor specializing in mutual fund portfolio optimization.
+                
+                Based on the following mutual fund data, provide specific investment recommendations.
+                
+                Context: {context}
+                
+                Question: {question}
+                
+                Please provide:
+                1. Recommended portfolio allocation percentages
+                2. Risk assessment based on the user's profile
+                3. Expected returns analysis
+                4. Sector diversification recommendations
+                5. Specific fund recommendations with rationale
+                
+                Keep your response concise and actionable.
+                
+                Answer:
+                """
+                
+                prompt = PromptTemplate(
+                    input_variables=["context", "question"],
+                    template=template
+                )
+                
+                self.qa_chain = RetrievalQA.from_chain_type(
+                    llm=self.llm,
+                    chain_type="stuff",
+                    retriever=self.vectorstore.as_retriever(search_kwargs={"k": 5}),
+                    chain_type_kwargs={"prompt": prompt}
+                )
+            
+            logger.info("RAG system setup complete")
+            return "✅ RAG system initialized successfully"
+            
+        except Exception as e:
+            logger.error(f"Error setting up RAG system: {e}")
+            return f"❌ Error setting up RAG system: {str(e)}"
+    
+    def get_ai_recommendations(self, user_query: str) -> str:
+        """Get AI-powered investment recommendations"""
+        try:
+            if self.qa_chain is None:
+                return "❌ AI system not initialized. Please setup the RAG system first."
+            
+            # Add user profile context to query
+            contextual_query = f"""
+            User Profile:
+            - Risk Tolerance: {self.user_profile['risk_tolerance']}
+            - Investment Amount: ${self.user_profile['investment_amount']:,}
+            - Investment Horizon: {self.user_profile['investment_horizon']} years
+            
+            Market Context:
+            - Interest Rate: {self.market_indicators.get('Interest_Rate_%', 'N/A')}%
+            - Market Volatility (VIX): {self.market_indicators.get('Market_Volatility_VIX', 'N/A')}
+            
+            User Question: {user_query}
+            """
+            
+            logger.info("Generating AI recommendations...")
+            result = self.qa_chain({"query": contextual_query})
+            
+            return result.get('result', 'No recommendation generated')
+            
+        except Exception as e:
+            logger.error(f"Error getting AI recommendations: {e}")
+            return f"❌ Error generating recommendations: {str(e)}"
+    
+    def calculate_portfolio_metrics(self, selected_funds: List[str], weights: List[float]) -> Dict:
+        """Calculate portfolio-level metrics"""
+        try:
+            # Fetch historical data for selected funds
+            tickers_str = ' '.join(selected_funds)
+            data = yf.download(tickers_str, period='1y', progress=False)['Close']
+            
+            if data.empty:
+                return {"error": "No data available for selected funds"}
+            
+            # Calculate returns
+            returns = data.pct_change().dropna()
+            
+            # Portfolio returns
+            weights = np.array(weights) / np.sum(weights)  # Normalize weights
+            portfolio_returns = returns.dot(weights)
+            
+            # Portfolio metrics
+            annual_return = portfolio_returns.mean() * 252
+            annual_volatility = portfolio_returns.std() * np.sqrt(252)
+            sharpe_ratio = annual_return / annual_volatility if annual_volatility != 0 else 0
+            
+            # Risk metrics
+            var_95 = np.percentile(portfolio_returns, 5)
+            max_drawdown = self.calculate_max_drawdown(portfolio_returns)
+            
+            return {
+                'Annual Return (%)': round(annual_return * 100, 2),
+                'Annual Volatility (%)': round(annual_volatility * 100, 2),
+                'Sharpe Ratio': round(sharpe_ratio, 3),
+                'VaR (95%)': round(var_95 * 100, 2),
+                'Max Drawdown (%)': round(max_drawdown * 100, 2)
+            }
+            
+        except Exception as e:
+            return {"error": f"Error calculating portfolio metrics: {str(e)}"}
+    
+    def calculate_max_drawdown(self, returns: pd.Series) -> float:
+        """Calculate maximum drawdown"""
+        cumulative = (1 + returns).cumprod()
+        rolling_max = cumulative.expanding().max()
+        drawdowns = (cumulative - rolling_max) / rolling_max
+        return drawdowns.min()
+
+# Initialize the RAG system
+rag_system = MutualFundRAG()
+
+def initialize_system():
+    """Initialize the complete system"""
+    try:
+        # Initialize LLM
+        llm_status = rag_system.initialize_llm()
+        
+        # Fetch market indicators
+        rag_system.get_market_indicators()
+        
+        return llm_status
+    except Exception as e:
+        return f"❌ Error initializing system: {str(e)}"
+
+def fetch_data_interface(include_extended: bool = False):
+    """Interface function to fetch fund data"""
+    try:
+        tickers = rag_system.fund_tickers + (rag_system.extended_tickers if include_extended else [])
+        df = rag_system.fetch_fund_data(tickers)
+        
+        if df.empty:
+            return "❌ No data fetched. Please check your internet connection.", None
+        
+        # Setup RAG system after fetching data
+        rag_status = rag_system.setup_rag_system()
+        
+        status = f"✅ Successfully fetched data for {len(df)} funds\n{rag_status}"
+        return status, df
+        
+    except Exception as e:
+        return f"❌ Error fetching data: {str(e)}", None
+
+def get_ai_recommendation_interface(user_query: str, risk_tolerance: str, investment_amount: float, horizon: int):
+    """Interface function for AI recommendations"""
+    try:
+        if not user_query.strip():
+            return "❌ Please enter a question about your investment needs."
+        
+        # Update user profile
+        rag_system.user_profile.update({
+            'risk_tolerance': risk_tolerance.lower(),
+            'investment_amount': investment_amount,
+            'investment_horizon': horizon
+        })
+        
+        # Get AI recommendations
+        recommendation = rag_system.get_ai_recommendations(user_query)
+        
+        return recommendation
+        
+    except Exception as e:
+        return f"❌ Error getting AI recommendations: {str(e)}"
+
+def calculate_metrics_interface(selected_funds_text: str, weights_text: str):
+    """Interface function to calculate portfolio metrics"""
+    try:
+        if not selected_funds_text.strip() or not weights_text.strip():
+            return "Please provide both fund tickers and weights"
+        
+        # Parse inputs
+        selected_funds = [ticker.strip().upper() for ticker in selected_funds_text.split(',')]
+        weights = [float(w.strip()) for w in weights_text.split(',')]
+        
+        if len(selected_funds) != len(weights):
+            return "Number of funds and weights must match"
+        
+        metrics = rag_system.calculate_portfolio_metrics(selected_funds, weights)
+        
+        if 'error' in metrics:
+            return metrics['error']
+        
+        # Format metrics for display
+        formatted_metrics = "\n".join([f"{key}: {value}" for key, value in metrics.items()])
+        return f"📊 Portfolio Metrics:\n\n{formatted_metrics}"
+        
+    except Exception as e:
+        return f"❌ Error calculating metrics: {str(e)}"
+
+# Initialize system on startup
+print("🚀 Initializing Mutual Fund RAG System...")
+init_status = initialize_system()
+print(init_status)
+
+# Create the Gradio interface
+with gr.Blocks(title="AI-Powered Mutual Fund Optimizer", theme="default") as app:
+    
+    gr.Markdown("""
+    # 🤖 AI-Powered Mutual Fund Portfolio Optimizer
+    
+    Get personalized investment recommendations using real Yahoo Finance data and advanced AI analysis.
+    """)
+    
+    with gr.Tabs():
+        
+        # Data Fetching Tab
+        with gr.Tab("📊 Fund Data"):
+            gr.Markdown("### Fetch Real-Time Mutual Fund Data")
+            
+            with gr.Row():
+                with gr.Column():
+                    include_extended = gr.Checkbox(
+                        label="Include Extended Fund List", 
+                        value=False,
+                        info="Include additional ETFs and funds"
+                    )
+                    fetch_btn = gr.Button("🔄 Fetch Fund Data", variant="primary")
+                    
+                with gr.Column():
+                    fetch_status = gr.Textbox(
+                        label="Status", 
+                        interactive=False,
+                        placeholder="Click 'Fetch Fund Data' to start",
+                        lines=3
+                    )
+            
+            fund_data_display = gr.Dataframe(
+                label="📋 Available Mutual Funds",
+                interactive=False,
+                wrap=True
+            )
+            
+            fetch_btn.click(
+                fn=fetch_data_interface,
+                inputs=[include_extended],
+                outputs=[fetch_status, fund_data_display]
+            )
+        
+        # AI Recommendations Tab
+        with gr.Tab("🤖 AI Investment Advisor"):
+            gr.Markdown("### Get Personalized AI Investment Recommendations")
+            
+            with gr.Row():
+                with gr.Column():
+                    user_query = gr.Textbox(
+                        label="Your Investment Question",
+                        placeholder="e.g., 'I want to invest $50,000 for retirement in 20 years with moderate risk'",
+                        lines=3,
+                        info="Ask about portfolio allocation, fund selection, or investment strategy"
+                    )
+                    
+                    with gr.Row():
+                        risk_tolerance = gr.Radio(
+                            choices=["Conservative", "Moderate", "Aggressive"],
+                            label="Risk Tolerance",
+                            value="Moderate"
+                        )
+                        
+                        investment_amount = gr.Number(
+                            label="Investment Amount ($)",
+                            value=50000,
+                            minimum=1000
+                        )
+                        
+                        investment_horizon = gr.Slider(
+                            label="Investment Horizon (Years)",
+                            minimum=1,
+                            maximum=30,
+                            value=5,
+                            step=1
+                        )
+                    
+                    get_recommendation_btn = gr.Button("🧠 Get AI Recommendation", variant="primary")
+                
+                with gr.Column():
+                    ai_recommendation = gr.Textbox(
+                        label="💡 AI Investment Recommendation",
+                        interactive=False,
+                        lines=15,
+                        placeholder="AI recommendations will appear here..."
+                    )
+            
+            # Example questions
+            gr.Markdown("### 💡 Example Questions:")
+            with gr.Row():
+                example1 = gr.Button("Conservative portfolio for retirement", size="sm")
+                example2 = gr.Button("Growth-focused portfolio for young investor", size="sm")
+                example3 = gr.Button("Balanced portfolio with international exposure", size="sm")
+            
+            # Connect example buttons
+            example1.click(
+                lambda: "I'm 55 years old and want a conservative portfolio for retirement in 10 years. What funds should I choose?",
+                outputs=[user_query]
+            )
+            example2.click(
+                lambda: "I'm 25 years old and want an aggressive growth portfolio for long-term wealth building. What's your recommendation?",
+                outputs=[user_query]
+            )
+            example3.click(
+                lambda: "I want a balanced portfolio with both US and international exposure. What allocation do you recommend?",
+                outputs=[user_query]
+            )
+            
+            get_recommendation_btn.click(
+                fn=get_ai_recommendation_interface,
+                inputs=[user_query, risk_tolerance, investment_amount, investment_horizon],
+                outputs=[ai_recommendation]
+            )
+        
+        # Portfolio Analysis Tab
+        with gr.Tab("📈 Portfolio Analysis"):
+            gr.Markdown("### Analyze Custom Portfolio Metrics")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**Enter your fund selection:**")
+                    custom_funds = gr.Textbox(
+                        label="Fund Tickers",
+                        placeholder="e.g., VTSAX, VTIAX, VBTLX",
+                        info="Comma-separated list of fund tickers"
+                    )
+                    
+                    custom_weights = gr.Textbox(
+                        label="Allocation Weights",
+                        placeholder="e.g., 50, 30, 20",
+                        info="Comma-separated percentages (should sum to 100)"
+                    )
+                    
+                    analyze_btn = gr.Button("📊 Calculate Metrics", variant="primary")
+                
+                with gr.Column():
+                    metrics_output = gr.Textbox(
+                        label="Portfolio Metrics",
+                        interactive=False,
+                        lines=10,
+                        placeholder="Enter fund tickers and weights, then click 'Calculate Metrics'"
+                    )
+            
+            analyze_btn.click(
+                fn=calculate_metrics_interface,
+                inputs=[custom_funds, custom_weights],
+                outputs=[metrics_output]
+            )
+        
+        # System Status Tab
+        with gr.Tab("⚙️ System Status"):
+            gr.Markdown("### AI System Status and Information")
+            
+            with gr.Row():
+                with gr.Column():
+                    system_status = gr.Textbox(
+                        label="🤖 AI System Status",
+                        value=init_status,
+                        interactive=False,
+                        lines=3
+                    )
+                    
+                    market_indicators = gr.JSON(
+                        label="📊 Current Market Indicators",
+                        value=rag_system.market_indicators
+                    )
+                
+                with gr.Column():
+                    gr.Markdown("""
+                    ### 🧠 AI Capabilities
+                    
+                    **LLM Model**: Microsoft DialoGPT
+                    **Embeddings**: Sentence Transformers
+                    **Vector Database**: ChromaDB
+                    **Data Source**: Yahoo Finance
+                    
+                    **What the AI can help with:**
+                    - Personalized portfolio recommendations
+                    - Risk assessment and analysis
+                    - Fund selection based on your goals
+                    - Market-aware investment strategies
+                    - Sector allocation suggestions
+                    """)
+            
+            refresh_status_btn = gr.Button("🔄 Refresh Status", variant="secondary")
+            
+            def refresh_system_status():
+                rag_system.get_market_indicators()
+                return "✅ System operational", rag_system.market_indicators
+            
+            refresh_status_btn.click(
+                fn=refresh_system_status,
+                outputs=[system_status, market_indicators]
+            )
+        
+        # User Guide Tab
+        with gr.Tab("📖 User Guide"):
+            gr.Markdown("""
+            ## How to Use the AI-Powered Mutual Fund Optimizer
+            
+            ### 1. 📊 **Setup Data**
+            - Go to "Fund Data" tab and click "Fetch Fund Data"
+            - This loads real-time data and initializes the AI system
+            - Review available funds and their characteristics
+            
+            ### 2. 🤖 **Get AI Recommendations**
+            - Use the "AI Investment Advisor" tab
+            - Describe your investment goals and situation
+            - Set your risk tolerance and investment parameters
+            - Get personalized AI-powered recommendations
+            
+            ### 3. 📈 **Analyze Portfolios**
+            - Use "Portfolio Analysis" for custom calculations
+            - Enter specific fund combinations and weights
+            - Get detailed risk and return metrics
+            
+            ### 🤖 **AI System Architecture**
+            
+            **RAG (Retrieval-Augmented Generation)**:
+            - Real fund data stored in vector database
+            - AI retrieves relevant information for your query
+            - Generates contextual recommendations
+            
+            **Components**:
+            - **LLM**: Language model for generating advice
+            - **Embeddings**: Convert fund data to vectors
+            - **Vector Database**: ChromaDB for similarity search
+            - **Real Data**: Live Yahoo Finance integration
+            
+            ### 💡 **Sample Queries**
+            
+            - "I have $100k to invest for 15 years, what's the best allocation?"
+            - "Compare growth vs value funds for my situation"
+            - "Should I include international funds in my portfolio?"
+            - "What's the optimal bond allocation for a 40-year-old?"
+            - "How should I adjust my portfolio during market volatility?"
+            
+            ### ⚠️ **Important Notes**
+            
+            - AI recommendations are for educational purposes
+            - Always verify suggestions with financial advisors
+            - Past performance doesn't guarantee future results
+            - Consider your complete financial situation
+            - The AI learns from real fund data and market conditions
+            
+            ### 🔧 **Technical Details**
+            
+            - **Data Source**: Yahoo Finance API
+            - **AI Model**: Microsoft DialoGPT (can be upgraded)
+            - **Embeddings**: Sentence Transformers all-MiniLM-L6-v2
+            - **Vector DB**: ChromaDB with persistent storage
+            - **Update Frequency**: Real-time when data is refreshed
+            """)
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    **🤖 AI-Powered**: This system uses advanced AI to analyze real market data and provide personalized investment recommendations.
+    
+    **⚠️ Disclaimer**: AI recommendations are for educational purposes only. Always consult with qualified financial advisors before making investment decisions.
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    print("🚀 Starting AI-Powered Mutual Fund Portfolio Optimizer...")
+    print("🤖 LLM and RAG system initialized")
+    print("📊 Real-time Yahoo Finance data integration enabled")
+    print("🧠 AI investment advisor ready")
+    
+    app.launch(
+        share=True,
+        server_name="0.0.0.0",
+        show_error=True,
+    )