Upload 15 files

readme.md

@@ -0,0 +1,131 @@
+# StartupFinancePilot - AI-Powered Financial Assistant for Startups
+
+## Overview
+
+StartupFinancePilot is an advanced AI-powered financial assistant that helps startup founders make better financial decisions, monitor spending, and optimize their runway. The application provides five main features:
+
+1. **AI-Enhanced Financial Dashboard**: Visualize your startup's financial health with AI insights and recommendations
+2. **Decision Simulator with AI Analysis**: Test business decisions and get AI-powered impact analysis before implementation
+3. **Intelligent Fund Monitoring**: AI-powered detection of suspicious transactions and spending pattern analysis
+4. **Voice-Enabled AI Financial Advisor**: Get strategic guidance through a conversational interface with voice support
+5. **AI Advisor Booking System**: Schedule dedicated sessions with AI financial experts for deeper analysis
+
+## How AI Powers StartupFinancePilot
+
+StartupFinancePilot leverages advanced AI technologies to revolutionize startup financial management:
+
+### 1. Google Gemini AI Integration
+
+At the core of StartupFinancePilot is Google's Gemini AI, a powerful large language model that:
+
+- Analyzes financial data to identify trends, anomalies, and opportunities
+- Generates tailored recommendations based on your startup's specific situation
+- Provides natural language explanations of complex financial concepts
+- Creates personalized strategies for runway extension and fundraising
+
+### 2. ElevenLabs Voice Technology
+
+The AI Financial Advisor feature uses ElevenLabs' voice synthesis technology to:
+
+- Convert AI-generated financial advice into natural-sounding voice responses
+- Provide a more engaging and accessible way to receive financial guidance
+- Enable hands-free advisory sessions during busy founder days
+
+### 3. AI-Powered Fraud Detection
+
+Our proprietary AI algorithms for fraud detection:
+
+- Automatically flag suspicious transactions using multiple risk factors
+- Assign risk scores to transactions based on patterns and anomalies
+- Learn from your spending patterns to improve detection accuracy over time
+- Prevent fund misuse before it occurs
+
+### 4. Financial Modeling AI
+
+The Decision Simulator uses AI financial modeling to:
+
+- Predict the impact of business decisions on your runway and finances
+- Generate multiple scenarios based on different variables
+- Recommend the optimal timing and scope for major decisions
+- Assess risk levels and potential ROI for different options
+
+## Key Features
+
+### Financial Dashboard
+
+- AI-generated insights about your financial health
+- Interactive visualizations of runway, cash flow, and burn rate
+- Expense breakdown with AI-powered optimization recommendations
+- Fundraising readiness assessment based on your metrics
+
+### Decision Simulator
+
+- Test the impact of hiring, marketing, and other decisions before implementation
+- AI analysis of each decision with specific recommendations
+- Component-level impact visualization to understand effects
+- Risk assessment for different scenarios
+
+### Fund Monitoring
+
+- AI-powered detection of suspicious transactions
+- Risk scoring for all spending activities
+- Pattern recognition to identify concerning trends
+- AI-recommended spending controls and policies
+
+### AI Financial Advisor
+
+- Natural language chat interface for financial questions
+- Voice-enabled responses for hands-free guidance
+- Context-aware advice based on your financial situation
+- Library of common financial questions with instant answers
+
+### Book a Session
+
+- Schedule dedicated AI advisory sessions for deeper analysis
+- Multiple session types for different financial needs
+- AI-generated pre-session analysis and post-session reports
+- 30-day follow-up support for implementation guidance
+
+## Technical Implementation
+
+StartupFinancePilot is built using:
+
+- Streamlit for the web interface
+- Google's Gemini AI API for intelligent analysis and recommendations
+- ElevenLabs API for voice synthesis
+- Plotly for interactive data visualizations
+- Pandas for data processing and analysis
+
+## Getting Started
+
+### Local Installation
+
+1. Clone the repository
+2. Install requirements: `pip install -r requirements.txt`
+3. Set up environment variables:
+   - `GOOGLE_API_KEY`: Your Google API key for Gemini access
+   - `ELEVENLABS_API_KEY`: Your ElevenLabs API key for voice synthesis
+4. Run the application: `streamlit run app.py`
+
+### Hugging Face Deployment
+
+This application is also deployed on Hugging Face Spaces and can be accessed directly through the web interface.
+
+To enable all AI features when deploying to Hugging Face:
+
+1. Go to the Hugging Face Space settings
+2. Click on "Repository secrets"
+3. Add secrets for `GOOGLE_API_KEY` and `ELEVENLABS_API_KEY`
+
+## Data Privacy
+
+This application uses sample data for demonstration purposes. In a production environment:
+
+- All financial data remains private and secure
+- No data is shared with third parties without explicit consent
+- API calls are encrypted and secure
+- No financial data is stored in model training datasets
+
+## About
+
+StartupFinancePilot was created to democratize access to high-quality financial guidance for startups. By leveraging AI, we provide enterprise-level financial intelligence at a fraction of the cost of traditional consultants.

requirements-txt.txt

@@ -0,0 +1,6 @@
+streamlit==1.24.0
+google-generativeai==0.3.2
+pandas==2.0.0
+numpy==1.24.3
+plotly==5.14.1
+python-dotenv==1.0.0

requirements.txt

@@ -0,0 +1,15 @@
+# Core dependencies
+streamlit==1.28.0
+pandas==2.0.3
+numpy==1.24.3
+plotly==5.18.0
+python-dateutil==2.8.2
+pillow==10.0.1
+
+# AI and ML libraries
+google-generativeai==0.3.2
+# elevenlabs==0.2.24 # Uncomment when implementing voice synthesis
+
+# Data processing
+pytz==2023.3
+openpyxl==3.1.2

src/__init__ .py

@@ -0,0 +1,3 @@
+# Import necessary modules for easy access
+from . import utils
+from . import pages

src/app.py

@@ -0,0 +1,154 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+
+# Import local modules
+from src.pages import dashboard, decision_simulator, fund_monitoring, financial_advisor
+from src.utils.data_processing import (
+    generate_sample_startup_data, 
+    generate_sample_cash_flow_data, 
+    generate_sample_transactions_data
+)
+
+# Load environment variables
+load_dotenv()
+
+# Constants
+DEFAULT_GROWTH_RATE = 0.08  # 8% monthly growth
+DEFAULT_BURN_RATE = 85000   # $85,000 monthly burn
+ENGINEER_SALARY = 10000     # $10,000 monthly cost per engineer ($120K/year)
+
+def main():
+    """
+    Main application entry point for Startup Finance Pilot
+    """
+    # App configuration
+    st.set_page_config(
+        page_title="StartupFinancePilot",
+        page_icon="💰",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+
+    # Custom CSS (you might want to move this to a separate file in a larger project)
+    st.markdown("""
+    <style>
+        /* Your existing CSS styles from previous implementation */
+        .main-header { font-size: 2.5rem; color: #0066cc; }
+        .sub-header { font-size: 1.5rem; color: #5c5c5c; }
+        /* Add more styles as needed */
+    </style>
+    """, unsafe_allow_html=True)
+
+    # Initialize session state
+    if 'startups' not in st.session_state:
+        st.session_state.startups = {}
+    
+    if 'current_startup' not in st.session_state:
+        st.session_state.current_startup = None
+    
+    if 'current_page' not in st.session_state:
+        st.session_state.current_page = 'upload'
+    
+    if 'insights_cache' not in st.session_state:
+        st.session_state.insights_cache = {}
+
+    # Add sample data for demonstration
+    sample_startup = generate_sample_startup_data()
+    st.session_state.startups[sample_startup['name']] = {
+        'profile': sample_startup,
+        'cash_flow': generate_sample_cash_flow_data(),
+        'transactions': generate_sample_transactions_data()
+    }
+    st.session_state.current_startup = sample_startup['name']
+
+    # Sidebar navigation
+    with st.sidebar:
+        st.title("💰 StartupFinancePilot")
+        st.write("AI-powered financial assistant for startups")
+
+        # Startup selector
+        if st.session_state.startups:
+            startup_names = list(st.session_state.startups.keys())
+            selected_startup = st.selectbox(
+                "Choose Startup", 
+                startup_names,
+                index=startup_names.index(st.session_state.current_startup)
+            )
+
+    st.session_state.current_startup = selected_startup
+                
+                # Show basic startup info
+                startup_data = st.session_state.startups[selected_startup]['profile']
+                st.markdown(f"""
+                **Stage:** {startup_data['stage']}  
+                **Cash:** ${startup_data['cash']:,}  
+                **Monthly Burn:** ${startup_data['burn_rate']:,}  
+                **Monthly Revenue:** ${startup_data['revenue']:,}  
+                """)
+
+            # Navigation buttons
+            st.markdown("<hr>", unsafe_allow_html=True)
+            
+            page_options = {
+                "📊 Financial Dashboard": "dashboard",
+                "🔮 Decision Simulator": "simulator", 
+                "🕵️ Fund Monitoring": "monitoring",
+                "🤖 AI Financial Advisor": "advisor"
+            }
+            
+            for label, page_key in page_options.items():
+                if st.button(label, use_container_width=True):
+                    st.session_state.current_page = page_key
+                    st.experimental_rerun()
+
+        # Render the correct page
+        if st.session_state.current_page == 'dashboard':
+            dashboard.render_financial_dashboard(
+                st.session_state.startups[st.session_state.current_startup]['profile'],
+                st.session_state.startups[st.session_state.current_startup]['cash_flow']
+            )
+        elif st.session_state.current_page == 'simulator':
+            decision_simulator.render_decision_simulator(
+                st.session_state.startups[st.session_state.current_startup]['profile']
+            )
+        elif st.session_state.current_page == 'monitoring':
+            fund_monitoring.render_fund_monitoring(
+                st.session_state.startups[st.session_state.current_startup]['transactions']
+            )
+        elif st.session_state.current_page == 'advisor':
+            financial_advisor.render_ai_financial_advisor(
+                st.session_state.startups[st.session_state.current_startup]['profile']
+            )
+
+def validate_gemini_api_key():
+    """
+    Validate the Google Generative AI API key
+    
+    Returns:
+        bool: True if API key is valid, False otherwise
+    """
+    try:
+        import google.generativeai as genai
+        api_key = os.getenv('GOOGLE_API_KEY')
+        
+        if not api_key:
+            st.error("🚨 Google API Key not found. Please set GOOGLE_API_KEY in your .env file.")
+            return False
+        
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-pro')
+        
+        # Try a simple test generation
+        test_response = model.generate_content("Hello, can you confirm the API is working?")
+        return True
+    except Exception as e:
+        st.error(f"🚨 Error validating API key: {e}")
+        return False
+
+if __name__ == "__main__":
+    # Check API key before running
+    if validate_gemini_api_key():
+        main()
+    else:
+        st.warning("Please set up your Google Generative AI API key to use the application.")

src/env-template.txt

@@ -0,0 +1,2 @@
+# Google Generative AI API Key
+GOOGLE_API_KEY=your_google_generative_ai_api_key_here

src/pages/__init__.py

@@ -0,0 +1,5 @@
+# Import all page modules for easier access
+from . import dashboard
+from . import decision_simulator
+from . import fund_monitoring
+from . import financial_advisor

src/pages/dashboard-page.py

@@ -0,0 +1,390 @@
+import streamlit as st
+import plotly.express as px
+import plotly.graph_objs as go
+import pandas as pd
+from datetime import date
+
+# Import local utilities
+from ..utils.ai_helpers import generate_ai_response
+from ..utils.data_processing import calculate_runway
+
+def render_financial_dashboard(startup_data, cash_flow_df):
+    """
+    Render the AI-powered financial dashboard page.
+    
+    This dashboard uses AI to analyze financial data and provide actionable insights
+    to startup founders, helping them make better decisions about their runway,
+    spending, and financial health.
+    
+    Args:
+        startup_data (dict): Dictionary containing startup financial profile
+        cash_flow_df (pd.DataFrame): DataFrame with monthly cash flow details
+    """
+    st.markdown("<h1 class='main-header'>Financial Dashboard</h1>", unsafe_allow_html=True)
+    st.markdown("<p class='sub-header'>AI-powered financial insights at a glance</p>", unsafe_allow_html=True)
+    
+    # Initialize insights cache if not exists
+    if 'insights_cache' not in st.session_state:
+        st.session_state.insights_cache = {}
+    
+    # AI Insights Explanation
+    with st.expander("ℹ️ How AI enhances your financial dashboard"):
+        st.markdown("""
+        ### How AI Powers Your Financial Dashboard
+        
+        The financial dashboard uses AI to transform raw financial data into actionable intelligence:
+        
+        - **Automated Analysis**: Our AI model analyzes your data and highlights critical trends
+        - **Predictive Forecasting**: AI forecasts your runway using advanced analytics
+        - **Anomaly Detection**: Identifies unusual spending patterns or concerning financial trends
+        - **Strategic Recommendations**: Provides tailored recommendations to optimize your runway
+        - **Benchmark Comparison**: Compares your metrics against industry standards
+        
+        This helps founders make data-driven decisions quickly and confidently.
+        """)
+    
+    # Generate AI Insights
+    insights_key = f"dashboard_{date.today().isoformat()}"
+    if insights_key not in st.session_state.insights_cache:
+        try:
+            insights = generate_ai_response(f"""
+            You are a financial advisor for startups. Based on this startup's data:
+            - Current cash: ${startup_data['cash']:,}
+            - Monthly burn rate: ${startup_data['burn_rate']:,}
+            - Monthly revenue: ${startup_data['revenue']:,}
+            - Monthly growth rate: {startup_data['growth_rate'] * 100:.2f}%
+            
+            Provide the top 3 most important financial insights that the founder should know today.
+            Format each insight as a brief, action-oriented bullet point.
+            """)
+            st.session_state.insights_cache[insights_key] = insights
+        except Exception as e:
+            st.session_state.insights_cache[insights_key] = f"Error generating insights: {str(e)}"
+    
+    # Display AI Insights
+    with st.expander("📊 AI Financial Insights", expanded=True):
+        st.markdown("<span class='ai-badge'>AI-Generated Insights</span>", unsafe_allow_html=True)
+        st.markdown(st.session_state.insights_cache[insights_key])
+    
+    # Key Metrics Section
+    col1, col2, col3, col4 = st.columns(4)
+    
+    # Calculate Runway
+    try:
+        runway_months, runway_df = calculate_runway(
+            startup_data['cash'], 
+            startup_data['burn_rate'], 
+            startup_data['revenue'], 
+            startup_data['growth_rate']
+        )
+    except Exception as e:
+        st.error(f"Error calculating runway: {e}")
+        runway_months = 0
+        runway_df = pd.DataFrame()  # Placeholder
+    
+    # Determine Metric Status Colors
+    runway_status = (
+        "danger-metric" if runway_months < 6 else 
+        "warning-metric" if runway_months < 9 else 
+        "good-metric"
+    )
+    burn_status = (
+        "danger-metric" if startup_data['burn_rate'] > 100000 else 
+        "warning-metric" if startup_data['burn_rate'] > 80000 else 
+        "good-metric"
+    )
+    revenue_status = (
+        "good-metric" if startup_data['revenue'] > 20000 else 
+        "warning-metric" if startup_data['revenue'] > 10000 else 
+        "danger-metric"
+    )
+    
+    # Display Key Metrics
+    metrics_display = [
+        ("Current Cash", f"${startup_data['cash']:,}", None),
+        ("Monthly Burn", f"${startup_data['burn_rate']:,}", burn_status),
+        ("Monthly Revenue", f"${startup_data['revenue']:,}", revenue_status),
+        ("Runway", f"{runway_months} months", runway_status)
+    ]
+    
+    for i, (label, value, status) in enumerate(metrics_display):
+        with [col1, col2, col3, col4][i]:
+            status_class = f"metric-value {status}" if status else "metric-value"
+            st.markdown(f"""
+            <div class='metric-card'>
+                <p class='metric-label'>{label}</p>
+                <p class='{status_class}'>{value}</p>
+            </div>
+            """, unsafe_allow_html=True)
+    
+    # Financial Overview Tabs
+    st.subheader("Financial Overview")
+    tab1, tab2, tab3 = st.tabs([
+        "Runway Projection", 
+        "Revenue vs. Expenses", 
+        "Burn Rate Trend"
+    ])
+    
+    with tab1:
+        # Runway Projection Chart
+        if not runway_df.empty:
+            fig = px.line(
+                runway_df.reset_index(), 
+                x='index', 
+                y='Cumulative_Cash', 
+                title="Cash Runway Projection",
+                labels={'index': 'Month', 'Cumulative_Cash': 'Remaining Cash ($)'},
+                color_discrete_sequence=['#0066cc']
+            )
+            fig.add_hline(y=0, line_dash="dash", line_color="red", annotation_text="Out of Cash")
+            fig.update_layout(
+                height=400,
+                plot_bgcolor='rgba(240,247,255,0.8)',
+                xaxis_title="Month",
+                yaxis_title="Cash Balance ($)",
+                font=dict(family="Arial, sans-serif", size=12),
+                margin=dict(l=20, r=20, t=40, b=20),
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        
+        # Runway Analysis
+        with st.expander("🔍 AI Runway Analysis", expanded=True):
+            runway_key = f"runway_{date.today().isoformat()}"
+            if runway_key not in st.session_state.insights_cache:
+                try:
+                    runway_analysis = get_runway_analysis(startup_data)
+                    st.session_state.insights_cache[runway_key] = runway_analysis
+                except Exception as e:
+                    st.session_state.insights_cache[runway_key] = f"Error generating runway analysis: {str(e)}"
+            
+            st.markdown("<span class='ai-badge'>AI Financial Analysis</span>", unsafe_allow_html=True)
+            st.markdown(st.session_state.insights_cache[runway_key])
+    
+    with tab2:
+        # Revenue vs Expenses Chart
+        rev_exp_df = cash_flow_df.copy()
+        fig = px.bar(
+            rev_exp_df, 
+            x='Month', 
+            y=['Revenue', 'Total_Expenses'],
+            title="Revenue vs. Expenses",
+            barmode='group',
+            labels={'value': 'Amount ($)', 'variable': 'Category'},
+            color_discrete_sequence=['#28a745', '#dc3545']
+        )
+        fig.update_layout(
+            height=400,
+            plot_bgcolor='rgba(240,247,255,0.8)',
+            xaxis_title="Month",
+            yaxis_title="Amount ($)",
+            font=dict(family="Arial, sans-serif", size=12),
+            legend_title="",
+            margin=dict(l=20, r=20, t=40, b=20),
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Revenue Growth Calculations
+        try:
+            revenue_growth = [
+                (cash_flow_df['Revenue'].iloc[i] / cash_flow_df['Revenue'].iloc[i-1] - 1) * 100 
+                if i > 0 else 0 
+                for i in range(len(cash_flow_df))
+            ]
+            avg_growth = sum(revenue_growth[1:]) / len(revenue_growth[1:])
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Average Monthly Revenue Growth", f"{avg_growth:.1f}%")
+            with col2:
+                expense_growth = (
+                    cash_flow_df['Total_Expenses'].iloc[-1] / 
+                    cash_flow_df['Total_Expenses'].iloc[0] - 1
+                ) * 100
+                st.metric(
+                    "Total Expense Growth", 
+                    f"{expense_growth:.1f}%", 
+                    delta=f"{expense_growth - avg_growth:.1f}%", 
+                    delta_color="inverse"
+                )
+        except Exception as e:
+            st.error(f"Error calculating growth metrics: {e}")
+    
+    with tab3:
+        # Burn Rate Trend Chart
+        fig = px.line(
+            cash_flow_df, 
+            x='Month', 
+            y='Net_Burn',
+            title="Monthly Net Burn Trend",
+            labels={'Net_Burn': 'Net Burn ($)'},
+            color_discrete_sequence=['#dc3545']
+        )
+        fig.update_layout(
+            height=400,
+            plot_bgcolor='rgba(240,247,255,0.8)',
+            xaxis_title="Month",
+            yaxis_title="Net Burn ($)",
+            font=dict(family="Arial, sans-serif", size=12),
+            margin=dict(l=20, r=20, t=40, b=20),
+        )
+        
+        # Efficiency Ratio Calculation
+        try:
+            efficiency_ratio = [
+                cash_flow_df['Revenue'].iloc[i] / cash_flow_df['Total_Expenses'].iloc[i] * 100 
+                for i in range(len(cash_flow_df))
+            ]
+            
+            fig.add_trace(go.Scatter(
+                x=cash_flow_df['Month'], 
+                y=efficiency_ratio,
+                name='Efficiency Ratio (%)',
+                yaxis='y2',
+                line=dict(color='#0066cc', width=2, dash='dot')
+            ))
+            
+            fig.update_layout(
+                yaxis2=dict(
+                    title='Efficiency Ratio (%)',
+                    overlaying='y',
+                    side='right',
+                    range=[0, max(efficiency_ratio) * 1.2]
+                )
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+            
+            with st.expander("🔎 Understanding Efficiency Ratio"):
+                st.info(
+                    "The efficiency ratio measures how efficiently your startup is generating "
+                    "revenue relative to expenses. A higher percentage means you're getting "
+                    "more revenue per dollar spent. Venture-backed startups typically aim "
+                    "for at least 40% before Series B funding."
+                )
+        except Exception as e:
+            st.error(f"Error calculating efficiency ratio: {e}")
+    
+    # Fundraising Readiness Assessment
+    st.subheader("Fundraising Readiness")
+    
+    # Get AI analysis of fundraising readiness
+    fundraising_key = f"fundraising_{date.today().isoformat()}"
+    if fundraising_key not in st.session_state.insights_cache:
+        try:
+            fundraising_analysis = get_fundraising_readiness_analysis(startup_data, cash_flow_df)
+            st.session_state.insights_cache[fundraising_key] = fundraising_analysis
+        except Exception as e:
+            st.session_state.insights_cache[fundraising_key] = f"Error generating fundraising analysis: {str(e)}"
+    
+    st.markdown("<div class='advisor-card'>", unsafe_allow_html=True)
+    st.markdown("<span class='ai-badge'>AI Fundraising Assessment</span>", unsafe_allow_html=True)
+    st.markdown(
+        f"<p class='advice-text'>{st.session_state.insights_cache[fundraising_key]}</p>", 
+        unsafe_allow_html=True
+    )
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Call-to-action for advisor
+    st.info("📅 Need personalized guidance on fundraising? [Book a session](#book-a-session) with our AI financial advisor.")
+
+def get_runway_analysis(financial_data):
+    """
+    Generate runway analysis using AI
+    
+    Args:
+        financial_data (dict): Startup financial data
+    
+    Returns:
+        str: AI-generated runway analysis
+    """
+    prompt = f"""
+    You are a financial advisor for startups. Analyze this startup's financial data:
+    - Current cash: ${financial_data['cash']:,}
+    - Monthly burn rate: ${financial_data['burn_rate']:,}
+    - Monthly revenue: ${financial_data['revenue']:,}
+    - Monthly growth rate: {financial_data['growth_rate'] * 100:.2f}%
+
+    Provide a detailed analysis of their runway and financial health. Include:
+    1. Exact runway calculation in months
+    2. Assessment of financial health (critical, concerning, stable, or healthy)
+    3. Benchmarks compared to similar seed-stage startups
+    4. Three specific, actionable recommendations to improve runway
+    5. Key metrics they should focus on
+
+    Format your response in a structured, easy-to-read format with clear sections and bullet points.
+    """
+    
+    return generate_ai_response(prompt)
+
+def get_fundraising_readiness_analysis(startup_data, cash_flow_df):
+    """
+    Generate fundraising readiness analysis using AI
+    
+    Args:
+        startup_data (dict): Startup financial profile
+        cash_flow_df (pd.DataFrame): Monthly cash flow data
+    
+    Returns:
+        str: AI-generated fundraising readiness analysis
+    """
+    # Calculate key metrics with error handling
+    try:
+        mrr_growth = (
+            cash_flow_df['Revenue'].iloc[-1] / 
+            cash_flow_df['Revenue'].iloc[-2] - 1
+        ) * 100
+    except Exception:
+        mrr_growth = 0
+    
+    try:
+        gross_margin = (
+            cash_flow_df['Revenue'].iloc[-1] - 
+            cash_flow_df['Total_Expenses'].iloc[-1] / 2
+        ) / cash_flow_df['Revenue'].iloc[-1] * 100
+    except Exception:
+        gross_margin = 0
+    
+    # Predefined metrics with example values
+    metrics = {
+        "MRR Growth": f"{mrr_growth:.1f}%",
+        "Gross Margin": f"{gross_margin:.1f}%",
+        "CAC": "$950",  # Customer Acquisition Cost
+        "LTV": "$4,500",  # Lifetime Value
+        "Churn": "3.2%",
+    }
+    
+    # Convert metrics to formatted text
+    metrics_text = "\n".join([f"- {k}: {v}" for k, v in metrics.items()])
+    
+    # Calculate runway
+    try:
+        runway = startup_data['cash'] / (startup_data['burn_rate'] - startup_data['revenue'])
+    except Exception:
+        runway = 0
+    
+    # Prepare prompt for AI analysis
+    prompt = f"""
+    You are a startup fundraising advisor. Analyze this startup's readiness for their next funding round:
+    
+    Company Profile:
+    - Stage: {startup_data['stage']}
+    - Last Funding: {startup_data.get('last_funding', 'N/A')}
+    - Current Cash: ${startup_data['cash']:,}
+    - Monthly Burn: ${startup_data['burn_rate']:,}
+    - Runway: {runway:.1f} months
+    
+    Key Metrics:
+    {metrics_text}
+    
+    Provide a comprehensive fundraising readiness assessment:
+    1. Overall fundraising readiness score (0-10)
+    2. Assessment of current metrics compared to investor expectations for next round
+    3. Identify the 3 most critical metrics to improve before fundraising
+    4. Recommend specific targets for each key metric
+    5. Suggest timeline and specific milestones for fundraising preparation
+    6. Estimate reasonable valuation range based on metrics and market conditions
+    
+    Be specific with numbers, timelines, and actionable targets.
+    """
+    
+    return generate_ai_response(prompt)

src/pages/dashboard-pages-init.py

@@ -0,0 +1,2 @@
+# Import the main rendering function for easier access
+from .dashboard import render_financial_dashboard

src/pages/decision-simulator.py

@@ -0,0 +1,321 @@
+def render_decision_simulator(startup_data):
+    """
+    Render the AI-powered decision simulator page.
+    
+    This feature helps startup founders test the financial impact of business
+    decisions before implementing them, using AI to analyze risks and benefits.
+    """
+    st.markdown("<h1 class='main-header'>Decision Simulator</h1>", unsafe_allow_html=True)
+    st.markdown("<p class='sub-header'>AI-powered analysis of business decisions</p>", unsafe_allow_html=True)
+    
+    # How AI helps with decision-making
+    with st.expander("ℹ️ How AI enhances your decision-making"):
+        st.markdown("""
+        ### How AI Powers Your Decision Simulator
+        
+        The decision simulator uses AI to help you make better strategic decisions:
+        
+        - **Scenario Analysis**: Our AI model simulates multiple financial scenarios based on your input variables
+        - **Risk Assessment**: The system automatically evaluates risk levels based on your cash runway and growth metrics
+        - **Return Prediction**: AI algorithms predict potential returns on investments like hiring or marketing
+        - **Opportunity Cost Analysis**: The model compares different allocations of capital to maximize growth
+        - **Personalized Recommendations**: Based on your specific situation, the AI provides tailored alternatives
+        
+        This helps founders make data-driven decisions with less guesswork, avoid costly mistakes, and optimize resource allocation.
+        """)
+    
+    st.write("Test the financial impact of key business decisions before implementing them. Our AI advisor will analyze the risks and benefits.")
+    
+    # Quick decision templates
+    st.subheader("Common Scenarios")
+    
+    decision_templates = {
+        "Hiring Engineering Team": {
+            "description": "Evaluate the impact of growing your engineering team",
+            "new_hires": 3,
+            "new_marketing": 0,
+            "other_expenses": 2000,
+            "growth_impact": 0.02,
+            "question": "We're considering hiring 3 more engineers to accelerate product development. How will this affect our runway and what growth impact should we expect to justify this investment?"
+        },
+        "Marketing Expansion": {
+            "description": "Test increasing your marketing budget",
+            "new_hires": 0,
+            "new_marketing": 15000,
+            "other_expenses": 0,
+            "growth_impact": 0.04,
+            "question": "We want to increase our marketing spend by $15K/month to drive growth. What growth rate would we need to achieve to make this financially viable?"
+        },
+        "Office Expansion": {
+            "description": "Analyze the cost of moving to a larger office",
+            "new_hires": 0,
+            "new_marketing": 0,
+            "other_expenses": 8000,
+            "growth_impact": 0.01,
+            "question": "We're considering moving to a larger office space that would add $8K/month to our expenses. Is this justified at our current stage?"
+        },
+        "Custom Scenario": {
+            "description": "Create your own custom scenario",
+            "new_hires": 0,
+            "new_marketing": 0,
+            "other_expenses": 0,
+            "growth_impact": 0.0,
+            "question": ""
+        }
+    }
+    
+    # Template selection
+    template_cols = st.columns(4)
+    selected_template = None
+    
+    for i, (template_name, template) in enumerate(decision_templates.items()):
+        with template_cols[i]:
+            if st.button(f"{template_name}\n{template['description']}", key=f"template_{i}"):
+                selected_template = template_name
+    
+    # Initialize form values based on selected template
+    if selected_template and selected_template != "Custom Scenario":
+        new_hires = decision_templates[selected_template]["new_hires"]
+        new_marketing = decision_templates[selected_template]["new_marketing"]
+        other_expenses = decision_templates[selected_template]["other_expenses"]
+        growth_impact = decision_templates[selected_template]["growth_impact"]
+        question = decision_templates[selected_template]["question"]
+    else:
+        new_hires = 0
+        new_marketing = 0
+        other_expenses = 0
+        growth_impact = 0.0
+        question = ""
+    
+    # Decision input form
+    with st.form("decision_form"):
+        st.subheader("Scenario Parameters")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_hires = st.number_input("New Engineering Hires", min_value=0, max_value=10, value=new_hires, 
+                                       help=f"Each engineer costs ${ENGINEER_SALARY:,} per month")
+            st.caption(f"Monthly Cost: ${new_hires * ENGINEER_SALARY:,}")
+            
+            new_marketing = st.number_input("Additional Monthly Marketing Budget", 
+                                           min_value=0, max_value=50000, value=new_marketing, step=1000,
+                                           help="Additional marketing spend per month")
+        
+        with col2:
+            other_expenses = st.number_input("Other Additional Monthly Expenses", 
+                                            min_value=0, max_value=50000, value=other_expenses, step=1000,
+                                            help="Any other additional monthly expenses")
+            
+            growth_impact = st.slider("Estimated Impact on Monthly Growth Rate", 
+                                     min_value=0.0, max_value=0.10, value=growth_impact, step=0.01, 
+                                     format="%.2f",
+                                     help="Estimated increase in monthly growth rate due to these investments")
+            st.caption(f"New Growth Rate: {(startup_data['growth_rate'] + growth_impact) * 100:.1f}% (current: {startup_data['growth_rate'] * 100:.1f}%)")
+        
+        question = st.text_area("Describe your decision scenario", 
+                               value=question,
+                               height=100, 
+                               placeholder="E.g., We're considering hiring two more engineers and increasing our marketing budget...")
+        
+        decision_summary = f"""
+        - {new_hires} new engineers: ${new_hires * ENGINEER_SALARY:,}/month
+        - Marketing increase: ${new_marketing:,}/month
+        - Other expenses: ${other_expenses:,}/month
+        - Total additional burn: ${new_hires * ENGINEER_SALARY + new_marketing + other_expenses:,}/month
+        - Growth impact: +{growth_impact * 100:.1f}% monthly growth
+        """
+        
+        st.markdown(f"**Decision Summary:**\n{decision_summary}")
+        
+        submitted = st.form_submit_button("Simulate Decision")
+    
+    if submitted:
+        # Calculate current and new runway
+        current_runway, new_runway, current_df, new_df = simulate_decision(
+            startup_data['cash'],
+            startup_data['burn_rate'],
+            startup_data['revenue'],
+            startup_data['growth_rate'],
+            other_expenses,
+            new_hires,
+            new_marketing,
+            growth_impact
+        )
+        
+        # Display results
+        st.markdown("<h3>Decision Impact Analysis</h3>", unsafe_allow_html=True)
+        
+        # Summary metrics
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Current Runway", f"{current_runway} months")
+        with col2:
+            runway_change = new_runway - current_runway
+            st.metric("New Runway", f"{new_runway} months", 
+                     delta=f"{runway_change} months", 
+                     delta_color="off" if runway_change == 0 else ("normal" if runway_change > 0 else "inverse"))
+        with col3:
+            new_burn = startup_data['burn_rate'] + other_expenses + (new_hires * ENGINEER_SALARY) + new_marketing
+            burn_change = new_burn - startup_data['burn_rate']
+            burn_percentage = burn_change / startup_data['burn_rate'] * 100
+            st.metric("New Monthly Burn", f"${new_burn:,}", 
+                     delta=f"${burn_change:,} ({burn_percentage:.1f}%)", 
+                     delta_color="inverse")
+        
+        # Cash projection comparison
+        st.subheader("Cash Projection Comparison")
+        
+        # Combine dataframes for comparison
+        current_df['Scenario'] = 'Current'
+        new_df['Scenario'] = 'After Decision'
+        
+        combined_df = pd.concat([current_df, new_df])
+        combined_df = combined_df.reset_index()
+        combined_df = combined_df.rename(columns={'index': 'Date'})
+        
+        # Plot comparison
+        fig = px.line(combined_df, x='Date', y='Cumulative_Cash', color='Scenario',
+                     title="Cash Runway Comparison",
+                     labels={'Cumulative_Cash': 'Remaining Cash'},
+                     color_discrete_sequence=['#4c78a8', '#f58518'])
+        
+        fig.add_hline(y=0, line_dash="dash", line_color="red", annotation_text="Out of Cash")
+        
+        fig.update_layout(
+            height=400,
+            plot_bgcolor='rgba(240,247,255,0.8)',
+            xaxis_title="Date",
+            yaxis_title="Cash Balance ($)",
+            font=dict(family="Arial, sans-serif", size=12),
+            margin=dict(l=20, r=20, t=40, b=20),
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Get AI analysis
+        if question:
+            decision_params = {
+                "new_hires": new_hires,
+                "new_marketing": new_marketing,
+                "other_expenses": other_expenses,
+                "growth_impact": growth_impact
+            }
+            
+            analysis = get_decision_analysis(question, startup_data, decision_params)
+            
+            st.markdown("<div class='advisor-card'>", unsafe_allow_html=True)
+            st.markdown("<span class='ai-badge'>AI Decision Analysis</span>", unsafe_allow_html=True)
+            st.markdown(f"<p class='advice-text'>{analysis}</p>", unsafe_allow_html=True)
+            st.markdown("</div>", unsafe_allow_html=True)
+            
+            # Break down impacts of each component
+            st.subheader("Component Impact Analysis")
+            
+            # Calculate the impact of each component in isolation
+            _, hiring_runway, _, _ = simulate_decision(
+                startup_data['cash'],
+                startup_data['burn_rate'],
+                startup_data['revenue'],
+                startup_data['growth_rate'],
+                0,
+                new_hires,
+                0,
+                0
+            )
+            
+            _, marketing_runway, _, _ = simulate_decision(
+                startup_data['cash'],
+                startup_data['burn_rate'],
+                startup_data['revenue'],
+                startup_data['growth_rate'],
+                0,
+                0,
+                new_marketing,
+                growth_impact
+            )
+            
+            _, expenses_runway, _, _ = simulate_decision(
+                startup_data['cash'],
+                startup_data['burn_rate'],
+                startup_data['revenue'],
+                startup_data['growth_rate'],
+                other_expenses,
+                0,
+                0,
+                0
+            )
+            
+            component_data = {
+                "Component": ["Engineering Hires", "Marketing Increase", "Other Expenses", "Combined Impact"],
+                "Runway Impact (months)": [
+                    hiring_runway - current_runway,
+                    marketing_runway - current_runway,
+                    expenses_runway - current_runway,
+                    new_runway - current_runway
+                ]
+            }
+            
+            component_df = pd.DataFrame(component_data)
+            
+            fig = px.bar(component_df, x='Component', y='Runway Impact (months)',
+                        title="Impact of Each Component on Runway",
+                        color='Runway Impact (months)',
+                        color_continuous_scale=['#dc3545', '#ffc107', '#28a745'],
+                        text='Runway Impact (months)')
+            
+            fig.update_layout(
+                height=400,
+                plot_bgcolor='rgba(240,247,255,0.8)',
+                font=dict(family="Arial, sans-serif", size=12),
+                margin=dict(l=20, r=20, t=40, b=20),
+            )
+            
+            fig.update_traces(texttemplate='%{text:.1f}', textposition='outside')
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Risk assessment
+            risk_level = "High" if new_runway < 3 else ("Medium" if new_runway < 6 else "Low")
+            risk_color = "danger-metric" if risk_level == "High" else ("warning-metric" if risk_level == "Medium" else "good-metric")
+            
+            st.markdown(f"""
+            <div class='metric-card'>
+                <p class='metric-label'>Risk Assessment</p>
+                <p class='metric-value {risk_color}'>{risk_level} Risk Decision</p>
+                <p>This decision would give you {new_runway} months of runway.</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # Recommendations
+            st.info("💡 **Want personalized guidance on this decision?** [Book a session](#book-a-session) with our AI financial advisor for detailed analysis.")
+
+def get_decision_analysis(question, financial_data, decision_params):
+    """Get AI analysis for a specific business decision."""
+    prompt = f"""
+    You are a financial advisor for startups. A founder asks:
+    "{question}"
+
+    Here's their current financial situation:
+    - Current cash: ${financial_data['cash']}
+    - Monthly burn rate: ${financial_data['burn_rate']}
+    - Monthly revenue: ${financial_data['revenue']}
+    - Monthly growth rate: {financial_data['growth_rate'] * 100}%
+    
+    They're considering these changes:
+    - Adding {decision_params['new_hires']} new engineers (${ENGINEER_SALARY}/month each)
+    - Increasing marketing budget by ${decision_params['new_marketing']}/month
+    - Adding ${decision_params['other_expenses']}/month in other expenses
+    - Expecting {decision_params['growth_impact'] * 100}% additional monthly growth
+
+    Analyze this decision thoroughly:
+    1. Quantify the impact on runway (exact calculation)
+    2. Assess the risk level (low, medium, high)
+    3. Compare the ROI potential
+    4. Provide 3 specific recommendations or alternatives
+    5. Suggest timeline and milestones for implementation if approved
+
+    Be direct and specific with numbers and timeframes.
+    """
+    
+    return generate_ai_response(prompt)

src/pages/financial-advisor.py

@@ -0,0 +1,210 @@
+def render_ai_financial_advisor(startup_data):
+    """
+    Render the AI financial advisor page with voice chat capabilities.
+    
+    This feature provides conversational financial guidance to founders through a 
+    natural chat interface with both text and voice responses.
+    """
+    st.markdown("<h1 class='main-header'>AI Financial Advisor</h1>", unsafe_allow_html=True)
+    st.markdown("<p class='sub-header'>Get expert financial guidance through our AI-powered advisor</p>", unsafe_allow_html=True)
+    
+    # How AI helps with financial advisory
+    with st.expander("ℹ️ How AI powers your financial advisor"):
+        st.markdown("""
+        ### How AI Powers Your Financial Advisor
+        
+        Our AI financial advisor combines advanced language models with financial expertise:
+        
+        - **Natural Language Understanding**: The system interprets complex financial questions in plain English
+        - **Domain-Specific Knowledge**: Our AI is trained on startup finance, venture capital, and financial modeling
+        - **Context-Aware Responses**: The advisor takes into account your specific financial situation and history
+        - **Voice Synthesis**: ElevenLabs voice technology creates natural, high-quality voice responses
+        - **Customized Guidance**: AI tailors advice specifically to your stage, industry, and financial position
+        
+        This gives founders 24/7 access to high-quality financial guidance without the high cost of consultants.
+        """)
+    
+    # Chat container
+    st.markdown("<div style='background-color: #f8f9fa; padding: 20px; border-radius: 10px; margin-bottom: 20px;'>", unsafe_allow_html=True)
+    
+    # Display chat history
+    st.subheader("Chat with your Financial Advisor")
+    
+    # Initialize chat history if needed
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = [
+            {"role": "assistant", "content": "Hi there! I'm your AI financial advisor. How can I help with your startup's finances today?"}
+        ]
+    
+    # Display chat messages
+    for message in st.session_state.chat_history:
+        if message["role"] == "user":
+            st.markdown(f"<div style='background-color: #e6f7ff; padding: 10px; border-radius: 10px; margin-bottom: 10px;'><strong>You:</strong> {message['content']}</div>", unsafe_allow_html=True)
+        else:
+            st.markdown(f"<div style='background-color: #f0f7ff; padding: 10px; border-radius: 10px; margin-bottom: 10px;'><strong>Financial Advisor:</strong> {message['content']}</div>", unsafe_allow_html=True)
+            
+            # Show play button for voice if it exists
+            if 'audio' in message and message['audio']:
+                st.audio(message['audio'], format='audio/mp3')
+    
+    # Input for new message
+    col1, col2 = st.columns([5, 1])
+    
+    with col1:
+        user_input = st.text_input("Ask a financial question", key="user_question")
+    
+    with col2:
+        use_voice = st.checkbox("Enable voice", value=True)
+    
+    # Common financial questions
+    st.markdown("### Common Questions")
+    question_cols = st.columns(3)
+    
+    common_questions = [
+        "How much runway do we have at our current burn rate?",
+        "Should we increase our marketing spend given our growth rate?",
+        "When should we start preparing for our next fundraising round?",
+        "How can we optimize our burn rate without impacting growth?",
+        "What metrics should we focus on improving right now?",
+        "How do our unit economics compare to similar startups?"
+    ]
+    
+    selected_question = None
+    
+    for i, question in enumerate(common_questions):
+        with question_cols[i % 3]:
+            if st.button(question, key=f"q_{i}"):
+                selected_question = question
+    
+    # Process user input (either from text input or selected question)
+    if user_input or selected_question:
+        question = user_input or selected_question
+        
+        # Add user message to chat history
+        st.session_state.chat_history.append({"role": "user", "content": question})
+        
+        # Get AI response
+        response = get_advisory_guidance(question, startup_data)
+        
+        # Generate voice response if enabled
+        audio_data = None
+        if use_voice:
+            audio_data = generate_voice_response(response)
+        
+        # Add AI response to chat history
+        st.session_state.chat_history.append({
+            "role": "assistant", 
+            "content": response,
+            "audio": audio_data
+        })
+        
+        # Rerun to display updated chat
+        st.experimental_rerun()
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Advanced options
+    st.subheader("Advanced Tools")
+    
+    tool_cols = st.columns(3)
+    
+    with tool_cols[0]:
+        st.markdown("""
+        <div style='background-color: white; padding: 15px; border-radius: 10px; height: 200px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);'>
+            <h4>Financial Model Review</h4>
+            <p>Upload your financial model for AI analysis and recommendations.</p>
+            <div style='position: absolute; bottom: 15px;'>
+                <input type='file' disabled/>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with tool_cols[1]:
+        st.markdown("""
+        <div style='background-color: white; padding: 15px; border-radius: 10px; height: 200px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);'>
+            <h4>Investor Pitch Review</h4>
+            <p>Get AI feedback on your investor pitch deck and financial projections.</p>
+            <div style='position: absolute; bottom: 15px;'>
+                <input type='file' disabled/>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with tool_cols[2]:
+        st.markdown("""
+        <div style='background-color: white; padding: 15px; border-radius: 10px; height: 200px; box-shadow: 0 4px 6px rgba(0,0,0,0.1);'>
+            <h4>Fundraising Strategy</h4>
+            <p>Generate a customized fundraising strategy based on your metrics.</p>
+            <div style='position: absolute; bottom: 15px;'>
+                <button disabled>Generate Strategy</button>
+            </div>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Book a session CTA
+    st.markdown("""
+    <div style='background-color: #e6f7ff; padding: 20px; border-radius: 10px; margin-top: 30px;'>
+        <h3>Need more in-depth guidance?</h3>
+        <p>Book a dedicated session with our AI financial advisor for comprehensive analysis and personalized advice.</p>
+        <a href='#book-a-session'><button>Book a Session</button></a>
+    </div>
+    """, unsafe_allow_html=True)
+
+def get_advisory_guidance(question, financial_data):
+    """Get strategic guidance for a startup question."""
+    prompt = f"""
+    You are a strategic financial advisor for startups. A founder asks:
+    "{question}"
+
+    Here's their current financial situation:
+    - Stage: {financial_data['stage']}
+    - Current cash: ${financial_data['cash']}
+    - Monthly burn rate: ${financial_data['burn_rate']}
+    - Monthly revenue: ${financial_data['revenue']}
+    - Monthly growth rate: {financial_data['growth_rate'] * 100}%
+    - Last funding: {financial_data['last_funding']}
+    - Team size: {financial_data['employees']}
+
+    Provide detailed, actionable advice addressing their question. Include:
+    1. Clear assessment of their current situation
+    2. 3-5 specific, actionable recommendations with expected outcomes
+    3. Relevant metrics they should track
+    4. Industry benchmarks for comparison
+    5. Timeline for implementation and results
+
+    Be specific with numbers, timeframes, and expected outcomes.
+    """
+    
+    return generate_ai_response(prompt)
+
+def generate_voice_response(text):
+    """Generate voice response using ElevenLabs API (simulated)."""
+    try:
+        # In a real implementation, this would call the ElevenLabs API
+        # For demonstration, we'll simulate an audio response
+        
+        # Simulated audio data (just an empty response)
+        audio_data = b''
+        
+        # In a real implementation, you would do something like:
+        # url = "https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
+        # headers = {
+        #     "Accept": "audio/mpeg",
+        #     "Content-Type": "application/json",
+        #     "xi-api-key": st.secrets["ELEVENLABS_API_KEY"]
+        # }
+        # data = {
+        #     "text": text,
+        #     "model_id": "eleven_monolingual_v1",
+        #     "voice_settings": {
+        #         "stability": 0.5,
+        #         "similarity_boost": 0.5
+        #     }
+        # }
+        # response = requests.post(url, json=data, headers=headers)
+        # audio_data = response.content
+        
+        return audio_data
+    except Exception as e:
+        st.warning(f"Error generating voice response: {e}")
+        return None

src/pages/fund-monitoring.py

@@ -0,0 +1,334 @@
+def render_fund_monitoring(transactions_df):
+    """
+    Render the AI-powered fund monitoring page.
+    
+    This feature helps startups monitor spending, detect fraudulent transactions,
+    and maintain investor trust through AI-powered analysis.
+    """
+    st.markdown("<h1 class='main-header'>Investor Fund Monitoring</h1>", unsafe_allow_html=True)
+    st.markdown("<p class='sub-header'>AI-powered fraud detection and spending analysis</p>", unsafe_allow_html=True)
+    
+    # How AI helps with fund monitoring
+    with st.expander("ℹ️ How AI enhances fund monitoring"):
+        st.markdown("""
+        ### How AI Powers Your Fund Monitoring
+        
+        The fund monitoring system uses AI to help maintain investor trust and optimize spending:
+        
+        - **Anomaly Detection**: Our AI models identify unusual transactions that don't match typical startup spending patterns
+        - **Risk Scoring**: Each transaction is assigned a risk score based on multiple factors like amount, category, vendor, and description
+        - **Pattern Recognition**: The system identifies potentially concerning spending trends across categories over time
+        - **Fraud Prevention**: AI algorithms flag transactions that match known patterns of misuse before they become issues
+        - **Investor-Ready Reporting**: Generate reports that demonstrate responsible financial stewardship to investors
+        
+        This helps founders maintain investor trust, prevent misuse of funds, and create transparency in financial operations.
+        """)
+    
+    st.write("Monitor your startup's spending to maintain investor trust and ensure proper fund usage. Our AI algorithms automatically flag suspicious transactions and identify spending patterns.")
+    
+    # AI insights for fund monitoring
+    insights_key = f"fund_monitoring_{date.today().isoformat()}"
+    if insights_key not in st.session_state.insights_cache:
+        insights = generate_ai_response("""
+        You are a financial fraud detection expert. Provide 2-3 critical spending patterns that investors typically look for when monitoring startup fund usage.
+        Format as brief bullet points focused on maintaining investor trust.
+        """, simulate=True)
+        st.session_state.insights_cache[insights_key] = insights
+    
+    with st.expander("🔍 AI Monitoring Insights", expanded=True):
+        st.markdown("<span class='ai-badge'>AI-Generated Insights</span>", unsafe_allow_html=True)
+        st.markdown(st.session_state.insights_cache[insights_key])
+    
+    # Process transactions to detect suspicious ones with AI enhancement
+    processed_df = detect_suspicious_transactions(transactions_df)
+    
+    # Summary metrics
+    total_transactions = len(processed_df)
+    suspicious_transactions = processed_df[processed_df['Suspicious']].copy()
+    suspicious_count = len(suspicious_transactions)
+    suspicious_amount = suspicious_transactions['Amount'].sum()
+    total_amount = processed_df['Amount'].sum()
+    
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.markdown(f"""
+        <div class='metric-card'>
+            <p class='metric-label'>Total Transactions</p>
+            <p class='metric-value'>{total_transactions}</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        flagged_percent = suspicious_count/total_transactions*100 if total_transactions > 0 else 0
+        status = "danger-metric" if flagged_percent > 10 else ("warning-metric" if flagged_percent > 5 else "good-metric")
+        st.markdown(f"""
+        <div class='metric-card'>
+            <p class='metric-label'>Flagged Transactions</p>
+            <p class='metric-value {status}'>{suspicious_count} ({flagged_percent:.1f}%)</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col3:
+        amount_percent = suspicious_amount/total_amount*100 if total_amount > 0 else 0
+        status = "danger-metric" if amount_percent > 15 else ("warning-metric" if amount_percent > 7 else "good-metric")
+        st.markdown(f"""
+        <div class='metric-card'>
+            <p class='metric-label'>Flagged Amount</p>
+            <p class='metric-value {status}'>${suspicious_amount:,.0f} ({amount_percent:.1f}%)</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col4:
+        avg_risk = suspicious_transactions['Risk_Score'].mean() if not suspicious_transactions.empty else 0
+        status = "danger-metric" if avg_risk > 50 else ("warning-metric" if avg_risk > 30 else "good-metric")
+        st.markdown(f"""
+        <div class='metric-card'>
+            <p class='metric-label'>Average Risk Score</p>
+            <p class='metric-value {status}'>{avg_risk:.1f}/100</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Tabs for different views
+    tab1, tab2 = st.tabs(["Flagged Transactions", "All Transactions"])
+    
+    with tab1:
+        if suspicious_count > 0:
+            # Add risk score visualization (color coded)
+            suspicious_view = suspicious_transactions.copy()
+            
+            # Format for display
+            def colorize_risk(val):
+                color = "red" if val > 50 else ("orange" if val > 30 else "blue")
+                return f'background-color: {color}; color: white; font-weight: bold'
+            
+            # Apply styling
+            styled_suspicious = suspicious_view.style.applymap(
+                lambda x: colorize_risk(x) if x > 0 else '', 
+                subset=['Risk_Score']
+            )
+            
+            st.dataframe(
+                suspicious_view[['Date', 'Category', 'Vendor', 'Amount', 'Description', 'Risk_Score', 'Reason']], 
+                use_container_width=True
+            )
+            
+            # Get AI analysis of suspicious transactions
+            fraud_key = f"fraud_{date.today().isoformat()}"
+            if fraud_key not in st.session_state.insights_cache:
+                fraud_analysis = get_fraud_analysis(suspicious_transactions)
+                st.session_state.insights_cache[fraud_key] = fraud_analysis
+            
+            st.markdown("<div class='advisor-card'>", unsafe_allow_html=True)
+            st.markdown("<span class='ai-badge'>AI Fraud Analysis</span>", unsafe_allow_html=True)
+            st.markdown(f"<p class='advice-text'>{st.session_state.insights_cache[fraud_key]}</p>", unsafe_allow_html=True)
+            st.markdown("</div>", unsafe_allow_html=True)
+            
+            # Action buttons
+            st.subheader("Recommended Actions")
+            
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                if st.button("🔍 Investigate All Flagged"):
+                    st.session_state.investigation_started = True
+            with col2:
+                if st.button("📝 Generate Investor Report"):
+                    st.session_state.report_generated = True  
+            with col3:
+                if st.button("✅ Mark Reviewed"):
+                    st.session_state.marked_reviewed = True
+            
+            # Simulate action responses
+            if 'investigation_started' in st.session_state and st.session_state.investigation_started:
+                st.success("Investigation initiated for all flagged transactions. Your financial team will be notified.")
+            
+            if 'report_generated' in st.session_state and st.session_state.report_generated:
+                st.success("Investor report generated and ready for review before sending.")
+                
+            if 'marked_reviewed' in st.session_state and st.session_state.marked_reviewed:
+                st.success("All transactions marked as reviewed. Status will be updated in the system.")
+        else:
+            st.success("No suspicious transactions detected by our AI system. Your spending appears to be normal for a startup at your stage.")
+    
+    with tab2:
+        st.dataframe(processed_df[['Date', 'Category', 'Vendor', 'Amount', 'Description', 'Suspicious', 'Risk_Score']], 
+                    use_container_width=True)
+    
+    # Spending patterns
+    st.subheader("Spending Pattern Analysis")
+    
+    # Category breakdown
+    category_spending = processed_df.groupby('Category')['Amount'].sum().reset_index()
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        fig = px.bar(category_spending, x='Category', y='Amount',
+                    title="Spending by Category",
+                    labels={'Amount': 'Total Spent ($)'},
+                    color='Amount',
+                    color_continuous_scale='Blues')
+        fig.update_layout(
+            height=400,
+            plot_bgcolor='rgba(240,247,255,0.8)',
+            xaxis_title="Category",
+            yaxis_title="Amount Spent ($)",
+            font=dict(family="Arial, sans-serif", size=12),
+            margin=dict(l=20, r=20, t=40, b=20),
+        )
+        st.plotly_chart(fig, use_container_width=True)
+    
+    with col2:
+        # AI spending pattern analysis
+        spending_key = f"spending_pattern_{date.today().isoformat()}"
+        if spending_key not in st.session_state.insights_cache:
+            spending_pattern_analysis = generate_ai_response("""
+            You are a startup spending analyst. Review the spending patterns and provide 3 key insights about:
+            1. Categories that appear to have unusually high spending
+            2. Potential areas where spending could be optimized
+            3. Changes in spending patterns that investors might find concerning
+            
+            Format as concise, actionable bullet points.
+            """, simulate=True)
+            st.session_state.insights_cache[spending_key] = spending_pattern_analysis
+        
+        st.markdown("<div class='insight-card'>", unsafe_allow_html=True)
+        st.markdown("<span class='ai-badge'>AI Spending Analysis</span>", unsafe_allow_html=True)
+        st.markdown(st.session_state.insights_cache[spending_key])
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Time series of spending
+    processed_df['Date'] = pd.to_datetime(processed_df['Date'])
+    processed_df['Week'] = processed_df['Date'].dt.isocalendar().week
+    weekly_spending = processed_df.groupby(['Week', 'Category'])['Amount'].sum().reset_index()
+    
+    fig = px.line(weekly_spending, x='Week', y='Amount', color='Category',
+                title="Weekly Spending Trends",
+                labels={'Amount': 'Amount Spent ($)'},
+                color_discrete_sequence=px.colors.qualitative.Bold)
+    fig.update_layout(
+        height=400,
+        plot_bgcolor='rgba(240,247,255,0.8)',
+        xaxis_title="Week",
+        yaxis_title="Amount Spent ($)",
+        font=dict(family="Arial, sans-serif", size=12),
+        margin=dict(l=20, r=20, t=40, b=20),
+    )
+    st.plotly_chart(fig, use_container_width=True)
+    
+    # AI-powered spending controls recommendation
+    st.subheader("AI-Recommended Spending Controls")
+    
+    # Get AI recommendations for spending controls
+    controls_key = f"spending_controls_{date.today().isoformat()}"
+    if controls_key not in st.session_state.insights_cache:
+        controls_recommendations = generate_ai_response("""
+        You are a financial controls expert for startups. Based on the spending patterns and suspicious transactions, 
+        recommend 3-4 specific spending controls that the startup should implement to prevent misuse of funds.
+        
+        For each control, provide:
+        1. A clear policy statement
+        2. Implementation steps
+        3. Expected impact
+        
+        Format as concise, actionable recommendations.
+        """, simulate=True)
+        st.session_state.insights_cache[controls_key] = controls_recommendations
+    
+    st.markdown("<div class='advisor-card'>", unsafe_allow_html=True)
+    st.markdown("<span class='ai-badge'>AI Control Recommendations</span>", unsafe_allow_html=True)
+    st.markdown(f"<p class='advice-text'>{st.session_state.insights_cache[controls_key]}</p>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+    
+    # Call-to-action
+    st.info("📅 Need help implementing financial controls? [Book a session](#book-a-session) with our AI financial advisor.")
+
+def detect_suspicious_transactions(transactions_df):
+    """AI-enhanced suspicious transaction detection."""
+    df = transactions_df.copy()
+    
+    # Define thresholds for each category
+    category_thresholds = {
+        "Travel": 3000,
+        "Marketing": 10000,
+        "Office": 7000,
+        "Software": 6000,
+        "Consulting": 5000,
+        "Legal": 6000
+    }
+    
+    # Define suspicious terms
+    suspicious_terms = ['luxury', 'cruise', 'premium', 'personal', 'gift']
+    
+    # Add suspicious column
+    df['Suspicious'] = False
+    df['Reason'] = ""
+    df['Risk_Score'] = 0
+    
+    # Check for suspicious patterns
+    for idx, row in df.iterrows():
+        reasons = []
+        risk_score = 0
+        
+        # Check if amount exceeds category threshold
+        if row['Category'] in category_thresholds:
+            if row['Amount'] > category_thresholds[row['Category']]:
+                reasons.append(f"Amount exceeds typical spending for {row['Category']}")
+                risk_score += 30
+                
+                # Higher risk for significantly exceeding threshold
+                excess_percentage = (row['Amount'] - category_thresholds[row['Category']]) / category_thresholds[row['Category']] * 100
+                if excess_percentage > 100:  # More than double the threshold
+                    risk_score += 20
+        
+        # Check for suspicious vendors or descriptions
+        if any(term in str(row['Vendor']).lower() for term in suspicious_terms):
+            reasons.append(f"Vendor name contains suspicious term")
+            risk_score += 25
+        
+        if any(term in str(row['Description']).lower() for term in suspicious_terms):
+            reasons.append(f"Description contains suspicious term")
+            risk_score += 20
+        
+        # Check for rounded amounts (potential indicator of estimation/fabrication)
+        if row['Amount'] % 1000 == 0 and row['Amount'] > 3000:
+            reasons.append(f"Suspiciously round amount")
+            risk_score += 15
+        
+        # Mark as suspicious if risk score is high enough
+        if risk_score >= 30:
+            df.at[idx, 'Suspicious'] = True
+            df.at[idx, 'Reason'] = "; ".join(reasons)
+            df.at[idx, 'Risk_Score'] = risk_score
+    
+    # Sort by risk score
+    df = df.sort_values(by='Risk_Score', ascending=False)
+    
+    return df
+
+def get_fraud_analysis(transactions_df):
+    """Get AI analysis of potentially fraudulent transactions."""
+    suspicious_df = transactions_df[transactions_df['Suspicious']].copy()
+    
+    if len(suspicious_df) == 0:
+        return "No suspicious transactions detected."
+    
+    transactions_text = suspicious_df[['Date', 'Category', 'Vendor', 'Amount', 'Description', 'Risk_Score']].to_string(index=False)
+    
+    prompt = f"""
+    You are a financial forensics expert specializing in startup spending oversight.
+    Review these flagged transactions:
+
+    {transactions_text}
+
+    Provide a detailed analysis:
+    1. Identify the most concerning transactions and explain why
+    2. Calculate the total financial impact of these suspicious transactions
+    3. Identify spending patterns or potential policy violations
+    4. Recommend specific actions the startup should take immediately
+    5. Suggest controls to prevent similar issues in the future
+
+    Be specific about which transactions are most concerning and why investors would have questions.
+    """
+    
+    return generate_ai_response(prompt)

src/utils/__init__.py

@@ -0,0 +1,3 @@
+# Import utility modules
+from . import ai_helpers
+from . import data_processing

src/utils/ai-helpers.py

@@ -0,0 +1,66 @@
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure the Gemini API
+genai.configure(api_key=os.getenv('GOOGLE_API_KEY'))
+
+def generate_ai_response(prompt, model_name='gemini-pro', temperature=0.7, max_tokens=1000):
+    """
+    Generate an AI response using Google's Generative AI (Gemini)
+    
+    Args:
+        prompt (str): The input prompt for the AI
+        model_name (str, optional): The Gemini model to use. Defaults to 'gemini-pro'.
+        temperature (float, optional): Controls randomness. Defaults to 0.7.
+        max_tokens (int, optional): Maximum length of the generated response. Defaults to 1000.
+    
+    Returns:
+        str: The generated AI response
+    """
+    try:
+        # Select the model
+        model = genai.GenerativeModel(model_name)
+        
+        # Generate content
+        response = model.generate_content(
+            prompt,
+            generation_config=genai.types.GenerationConfig(
+                temperature=temperature,
+                max_output_tokens=max_tokens
+            )
+        )
+        
+        # Return the text of the response
+        return response.text
+    
+    except Exception as e:
+        print(f"Error generating AI response: {e}")
+        return f"An error occurred while generating the response: {str(e)}"
+
+def simulate_ai_response(prompt):
+    """
+    Simulated AI response for development and testing
+    
+    Args:
+        prompt (str): The input prompt
+    
+    Returns:
+        str: A simulated response based on the prompt
+    """
+    # This is a placeholder for simulated responses during development
+    # In a real implementation, this would be removed or more sophisticatedly implemented
+    import random
+    
+    simulated_responses = [
+        "Based on the current financial data, here are some key insights...",
+        "The AI suggests optimizing your spending in these key areas...",
+        "Your startup shows promising growth potential with these recommendations...",
+        "We've identified potential areas for financial improvement...",
+        "Here's a strategic overview of your financial situation..."
+    ]
+    
+    return random.choice(simulated_responses)

src/utils/data-processing.py

@@ -0,0 +1,118 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+
+def calculate_runway(current_cash, burn_rate, monthly_revenue, growth_rate, months=12):
+    """
+    Calculate the startup's runway based on financial parameters
+    
+    Args:
+        current_cash (float): Current cash balance
+        burn_rate (float): Monthly burn rate
+        monthly_revenue (float): Current monthly revenue
+        growth_rate (float): Monthly revenue growth rate
+        months (int, optional): Projection period. Defaults to 12.
+    
+    Returns:
+        tuple: (runway months, runway dataframe)
+    """
+    # Create projection dataframe
+    df = pd.DataFrame(index=range(months))
+    
+    # Initialize first month
+    df.loc[0, 'Revenue'] = monthly_revenue
+    df.loc[0, 'Burn_Rate'] = burn_rate
+    df.loc[0, 'Net_Burn'] = burn_rate - monthly_revenue
+    df.loc[0, 'Cumulative_Cash'] = current_cash - df.loc[0, 'Net_Burn']
+    
+    # Project forward
+    for i in range(1, months):
+        # Grow revenue
+        df.loc[i, 'Revenue'] = df.loc[i-1, 'Revenue'] * (1 + growth_rate)
+        
+        # Adjust burn rate (simplified model)
+        df.loc[i, 'Burn_Rate'] = burn_rate  # Could make this more sophisticated
+        
+        # Calculate net burn
+        df.loc[i, 'Net_Burn'] = df.loc[i, 'Burn_Rate'] - df.loc[i, 'Revenue']
+        
+        # Calculate cumulative cash
+        df.loc[i, 'Cumulative_Cash'] = df.loc[i-1, 'Cumulative_Cash'] - df.loc[i, 'Net_Burn']
+        
+        # Stop if out of cash
+        if df.loc[i, 'Cumulative_Cash'] <= 0:
+            break
+    
+    # Calculate runway months
+    runway_months = df[df['Cumulative_Cash'] > 0].shape[0]
+    
+    return runway_months, df
+
+def generate_sample_startup_data():
+    """
+    Generate sample startup financial data for demonstration
+    
+    Returns:
+        dict: Sample startup financial data
+    """
+    return {
+        "name": "TechHealth AI",
+        "stage": "Seed",
+        "founded": "18 months ago",
+        "employees": 12,
+        "last_funding": "$1.2M seed round 10 months ago",
+        "cash": 320000,
+        "burn_rate": 85000,
+        "revenue": 15000,
+        "growth_rate": 0.08
+    }
+
+def generate_sample_cash_flow_data():
+    """
+    Generate sample cash flow data for demonstration
+    
+    Returns:
+        pd.DataFrame: Sample cash flow DataFrame
+    """
+    cash_flow_data = {
+        "Month": [f"Month {i}" for i in range(1, 11)],
+        "Revenue": [8000, 8500, 9200, 10000, 10800, 11700, 12600, 13600, 14700, 15800],
+        "Payroll": [60000, 60000, 62000, 62000, 65000, 65000, 70000, 70000, 75000, 75000],
+        "Marketing": [8000, 9000, 10000, 12000, 15000, 18000, 15000, 12000, 10000, 8000],
+        "Office": [5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000, 5000],
+        "Software": [3000, 3200, 3500, 3800, 4000, 4200, 4500, 4800, 5000, 5200],
+        "Travel": [2000, 1800, 2500, 3000, 4000, 4500, 3500, 3000, 2500, 2000],
+        "Legal": [1500, 1000, 800, 1200, 800, 2000, 1500, 1000, 3000, 1200],
+        "Misc": [1000, 1200, 1300, 1500, 1700, 1800, 2000, 2200, 2500, 2800]
+    }
+    
+    # Create DataFrame
+    df = pd.DataFrame(cash_flow_data)
+    
+    # Add calculated fields
+    df["Total_Expenses"] = df[["Payroll", "Marketing", "Office", "Software", "Travel", "Legal", "Misc"]].sum(axis=1)
+    df["Net_Burn"] = df["Total_Expenses"] - df["Revenue"]
+    
+    return df
+
+def generate_sample_transactions_data():
+    """
+    Generate sample transactions data for demonstration
+    
+    Returns:
+        pd.DataFrame: Sample transactions DataFrame
+    """
+    transactions = pd.DataFrame([
+        {"Date": "2023-11-05", "Category": "Travel", "Vendor": "Caribbean Cruises", "Amount": 8500, "Description": "Team Retreat Planning", "Flag": "Suspicious"},
+        {"Date": "2023-11-12", "Category": "Marketing", "Vendor": "LuxuryGifts Inc", "Amount": 4200, "Description": "Client Appreciation", "Flag": "Suspicious"},
+        {"Date": "2023-11-22", "Category": "Office", "Vendor": "Premium Furniture", "Amount": 12000, "Description": "Office Upgrades", "Flag": "Suspicious"},
+        {"Date": "2023-11-28", "Category": "Consulting", "Vendor": "Strategic Vision LLC", "Amount": 7500, "Description": "Strategy Consulting", "Flag": "Suspicious"},
+        {"Date": "2023-12-05", "Category": "Software", "Vendor": "Personal Apple Store", "Amount": 3200, "Description": "Development Tools", "Flag": "Suspicious"},
+        {"Date": "2023-12-12", "Category": "Legal", "Vendor": "Anderson Brothers", "Amount": 5800, "Description": "Legal Services", "Flag": "Normal"},
+        {"Date": "2023-12-20", "Category": "Payroll", "Vendor": "November Payroll", "Amount": 75000, "Description": "Monthly Payroll", "Flag": "Normal"},
+        {"Date": "2023-12-22", "Category": "Marketing", "Vendor": "Google Ads", "Amount": 8000, "Description": "Ad Campaign", "Flag": "Normal"},
+        {"Date": "2023-12-25", "Category": "Office", "Vendor": "WeWork", "Amount": 5000, "Description": "Monthly Rent", "Flag": "Normal"},
+        {"Date": "2023-12-28", "Category": "Software", "Vendor": "AWS", "Amount": 5200, "Description": "Cloud Services", "Flag": "Normal"}
+    ])
+    
+    return transactions