UPDATE: revamp frontend

streamlit_app.py → Home.py

@@ -3,17 +3,38 @@ import asyncio
 import json
 import re
 import os
-import pandas as pd
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 import yfinance as yf
-from datetime import datetime, timedelta
+import time
+
+try:
+    from prophet import Prophet
+except ImportError:
+    st.error("Prophet not installed. Please run: pip install prophet")
+    Prophet = None
 from dotenv import load_dotenv
 from openai import OpenAI
 from mcp.client.session import ClientSession
 from mcp.client.stdio import stdio_client
 from mcp import StdioServerParameters, types
 
+# Import resource monitoring
+try:
+    from resource_monitor import (
+        start_resource_monitoring,
+        stop_resource_monitoring,
+        get_resource_stats,
+        create_resource_dashboard,
+        get_resource_summary,
+        export_resource_data,
+        resource_monitor,
+    )
+
+    RESOURCE_MONITORING_AVAILABLE = True
+except ImportError:
+    RESOURCE_MONITORING_AVAILABLE = False
+    st.warning("Resource monitoring not available. Install psutil: pip install psutil")
+
 # Load environment variables
 load_dotenv()
 
@@ -230,15 +251,222 @@ async def get_stock_data(ticker: str) -> str:
 
 
 def create_stock_chart(ticker: str):
-    """Create an interactive stock price chart for the given ticker."""
+    """Create an interactive stock price chart with Prophet predictions for the given ticker."""
     try:
-        # Get stock data
-        stock = yf.Ticker(ticker)
-        hist_data = stock.history(period="30d")
+        # Check if Prophet is available
+        if Prophet is None:
+            st.error("Prophet is not installed. Please install it with: uv add prophet")
+            return create_basic_stock_chart(ticker)
+
+        # Get stock data - 1 year for training Prophet
+        with st.spinner(f"📊 Fetching stock data for {ticker}..."):
+            stock = yf.Ticker(ticker)
+            hist_data = stock.history(period="1y")
+
+            # Track yfinance API call
+            if RESOURCE_MONITORING_AVAILABLE:
+                resource_monitor.increment_yfinance_calls()
 
         if hist_data.empty:
             st.warning(f"No data available for {ticker}")
-            return
+            return None
+
+        # Prepare data for Prophet with outlier removal
+        df = hist_data.reset_index()
+
+        # Remove outliers using IQR method for better model training
+        Q1 = df["Close"].quantile(0.25)
+        Q3 = df["Close"].quantile(0.75)
+        IQR = Q3 - Q1
+        lower_bound = Q1 - 1.5 * IQR
+        upper_bound = Q3 + 1.5 * IQR
+
+        # Filter out outliers
+        df = df[(df["Close"] >= lower_bound) & (df["Close"] <= upper_bound)]
+
+        # Remove timezone information from the Date column for Prophet compatibility
+        df["ds"] = df["Date"].dt.tz_localize(
+            None
+        )  # Prophet requires timezone-naive dates
+        df["y"] = df["Close"]  # Prophet requires 'y' column for values
+
+        # Train Prophet model with optimized configuration
+        start_time = time.time()
+        with st.spinner(f"Training Prophet model for {ticker}..."):
+            # Configure Prophet model with optimized parameters
+            model = Prophet(
+                yearly_seasonality=True,
+                weekly_seasonality=True,
+                daily_seasonality=False,
+                changepoint_prior_scale=0.01,  # Reduced for smoother trends
+                seasonality_prior_scale=10.0,  # Increased seasonality strength
+                seasonality_mode="multiplicative",
+                interval_width=0.8,  # Tighter confidence intervals
+                mcmc_samples=0,  # Disable MCMC for faster training
+            )
+
+            # Add custom seasonalities for better stock patterns
+            model.add_seasonality(name="monthly", period=30.5, fourier_order=5)
+
+            model.add_seasonality(name="quarterly", period=91.25, fourier_order=8)
+
+            model.fit(df[["ds", "y"]])
+
+            # Make predictions for next 30 days
+            future = model.make_future_dataframe(periods=30)
+            forecast = model.predict(future)
+
+            # Get the forecast data for the next 30 days (future predictions only)
+            # Find the last date in historical data
+            last_historical_date = df["ds"].max()
+
+            # Add one day to ensure we start from tomorrow
+            from datetime import timedelta
+
+            tomorrow = last_historical_date + timedelta(days=1)
+
+            # Filter for only future predictions (starting from tomorrow)
+            forecast_future = forecast[forecast["ds"] >= tomorrow].copy()
+
+        # Track Prophet training time
+        training_time = time.time() - start_time
+        if RESOURCE_MONITORING_AVAILABLE:
+            resource_monitor.add_prophet_training_time(training_time)
+
+        # Create interactive chart with historical data and predictions
+        fig = go.Figure()
+
+        # Add historical price data (full year for context)
+        # Ensure we only show actual historical data, not predictions
+        # Convert timezone-aware dates to timezone-naive for comparison
+        hist_data_filtered = hist_data[
+            hist_data.index.tz_localize(None) <= last_historical_date
+        ]
+        fig.add_trace(
+            go.Scatter(
+                x=hist_data_filtered.index,
+                y=hist_data_filtered["Close"],
+                mode="lines+markers",
+                name=f"{ticker} Historical Price (Last Year)",
+                line=dict(color="#1f77b4", width=2),
+                marker=dict(size=4),
+            )
+        )
+
+        # Add Prophet predictions for next 30 days (starting from tomorrow)
+        fig.add_trace(
+            go.Scatter(
+                x=forecast_future["ds"],
+                y=forecast_future["yhat"],
+                mode="lines+markers",
+                name=f"{ticker} Future Predictions (Next 30 Days)",
+                line=dict(color="#ff7f0e", width=2, dash="dash"),
+                marker=dict(size=4),
+            )
+        )
+
+        # Add confidence intervals for future predictions
+        fig.add_trace(
+            go.Scatter(
+                x=forecast_future["ds"].tolist() + forecast_future["ds"].tolist()[::-1],
+                y=forecast_future["yhat_upper"].tolist()
+                + forecast_future["yhat_lower"].tolist()[::-1],
+                fill="toself",
+                fillcolor="rgba(255, 127, 14, 0.3)",
+                line=dict(color="rgba(255, 127, 14, 0)"),
+                name="Prediction Confidence Interval",
+                showlegend=False,
+            )
+        )
+
+        # Update layout
+        fig.update_layout(
+            title=f"{ticker} Stock Price with Next 30-Day Predictions",
+            xaxis_title="Date",
+            yaxis_title="Price ($)",
+            height=500,
+            hovermode="x unified",
+            legend=dict(
+                orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1
+            ),
+        )
+
+        # Update axes
+        fig.update_xaxes(
+            title_text="Date",
+            tickformat="%b %d",
+            tickangle=45,
+        )
+        fig.update_yaxes(title_text="Price ($)")
+
+        # Display prediction summary
+        current_price = hist_data["Close"].iloc[-1]
+        predicted_price_30d = forecast_future["yhat"].iloc[-1]
+        price_change = predicted_price_30d - current_price
+        price_change_pct = (price_change / current_price) * 100
+
+        # Calculate confidence interval
+        confidence_lower = forecast_future["yhat_lower"].iloc[-1]
+        confidence_upper = forecast_future["yhat_upper"].iloc[-1]
+        confidence_range = confidence_upper - confidence_lower
+
+        # Display detailed prediction information
+        col1, col2, col3 = st.columns([1, 1, 1])
+
+        with col1:
+            st.metric(
+                "Current Price",
+                f"${current_price:.2f}",
+            )
+
+        with col2:
+            st.metric(
+                "30-Day Prediction",
+                f"${predicted_price_30d:.2f}",
+                delta=f"{price_change_pct:+.2f}%",
+            )
+
+        with col3:
+            st.metric(
+                "Expected Change",
+                f"${price_change:.2f} ({price_change_pct:+.2f}%)",
+            )
+
+        # Additional prediction details
+        st.info(
+            f"""
+        **📊 30-Day Prediction Details for {ticker}:**
+        - **Current Price:** ${current_price:.2f}
+        - **Predicted Price (30 days):** ${predicted_price_30d:.2f}
+        - **Expected Change:** ${price_change:.2f} ({price_change_pct:+.2f}%)
+        - **Confidence Range:** ${confidence_lower:.2f} - ${confidence_upper:.2f} (±${confidence_range/2:.2f})
+        - **Model Training Time:** {training_time:.2f}s
+        
+        ⚠️ **Disclaimer**: Stock predictions have approximately 51% accuracy. 
+        These forecasts are for informational purposes only and should not be used as 
+        the sole basis for investment decisions. Always conduct your own research 
+        and consider consulting with financial advisors.
+        """
+        )
+
+        return fig
+
+    except Exception as e:
+        st.error(f"Error creating chart for {ticker}: {e}")
+        return create_basic_stock_chart(ticker)
+
+
+def create_basic_stock_chart(ticker: str):
+    """Create a basic stock price chart without Prophet predictions."""
+    try:
+        # Get stock data with loading state
+        with st.spinner(f"📊 Fetching basic stock data for {ticker}..."):
+            stock = yf.Ticker(ticker)
+            hist_data = stock.history(period="30d")
+
+        if hist_data.empty:
+            st.warning(f"No data available for {ticker}")
+            return None
 
         # Create simple line chart
         fig = go.Figure()
@@ -326,11 +554,32 @@ async def execute_tool_call(tool_call):
     """Execute a tool call using MCP servers."""
     try:
         tool_name = tool_call.function.name
-        arguments = json.loads(tool_call.function.arguments)
+
+        # Clean and validate the arguments JSON
+        arguments_str = tool_call.function.arguments.strip()
+
+        # Try to extract valid JSON if there's extra content
+        try:
+            arguments = json.loads(arguments_str)
+        except json.JSONDecodeError:
+            # Try to find JSON within the string
+            import re
+
+            json_match = re.search(r"\{[^{}]*\}", arguments_str)
+            if json_match:
+                try:
+                    arguments = json.loads(json_match.group())
+                except json.JSONDecodeError:
+                    st.error(f"❌ Could not parse tool arguments: {arguments_str}")
+                    return f"Error: Invalid tool arguments format"
+            else:
+                st.error(f"❌ Could not parse tool arguments: {arguments_str}")
+                return f"Error: Invalid tool arguments format"
+
         ticker = arguments.get("ticker")
 
         with st.status(
-            f"🛠️ Executing {tool_name} for {ticker}...", expanded=False
+            f"🛠️ Executing {tool_name} for {ticker}...", expanded=True
         ) as status:
             if tool_name == "get_latest_news":
                 result = await get_news_data(ticker)
@@ -353,9 +602,6 @@ async def execute_tool_call(tool_call):
             else:
                 status.update(label=f"❌ Unknown tool: {tool_name}", state="error")
                 return f"Unknown tool: {tool_name}"
-    except json.JSONDecodeError as e:
-        st.error(f"❌ Invalid tool arguments format: {e}")
-        return f"Error: Invalid tool arguments format"
     except Exception as e:
         st.error(f"❌ Error executing tool {tool_call.function.name}: {e}")
         return f"Error executing tool {tool_call.function.name}: {e}"
@@ -399,7 +645,7 @@ async def run_agent(user_query, selected_ticker):
 
     try:
         # Get initial response from the model
-        with st.spinner("🤖 Analyzing your request..."):
+        with st.spinner("🤖 Generating analysis..."):
             response = client.chat.completions.create(
                 model=model,
                 messages=messages,
@@ -438,7 +684,7 @@ async def run_agent(user_query, selected_ticker):
                 )
 
             # Get final response from the model
-            with st.spinner("🤖 Generating analysis..."):
+            with st.spinner("🤖 Finalizing analysis..."):
                 final_response = client.chat.completions.create(
                     model="openai/gpt-4o-mini",  # Try a different model
                     messages=messages,
@@ -475,16 +721,24 @@ def display_top_news(ticker: str):
             clean_text = re.sub(r"\s+", " ", clean_text).strip()
             return clean_text
 
-        # Get news data
-        google_news = gnews.GNews(language="en", country="US", period="7d")
-        search_query = f'"{ticker}" stock market news'
-        articles = google_news.get_news(search_query)
+        # Check if news is already cached
+        news_cache_key = f"news_data_{ticker}"
+        if news_cache_key in st.session_state:
+            articles = st.session_state[news_cache_key]
+        else:
+            # Get news data with loading state
+            with st.spinner(f"📰 Loading news for {ticker}..."):
+                google_news = gnews.GNews(language="en", country="US", period="7d")
+                search_query = f'"{ticker}" stock market news'
+                articles = google_news.get_news(search_query)
+                # Cache the articles
+                st.session_state[news_cache_key] = articles
 
         if not articles:
             st.info(f"No recent news found for {ticker}")
             return
 
-            # Display top 5 articles
+        # Display top 5 articles
         for i, article in enumerate(articles[:5], 1):
             title = preprocess_text(article.get("title", ""))
             url = article.get("url", "")
@@ -517,55 +771,28 @@ def test_server_availability():
     # Test news server
     news_server_path = os.path.join(current_dir, "news_server.py")
     if not os.path.exists(news_server_path):
-        st.error(f"❌ news_server.py not found at {news_server_path}")
+        print(f"❌ ERROR: news_server.py not found at {news_server_path}")
         return False
 
     # Test stock data server
     stock_server_path = os.path.join(current_dir, "stock_data_server.py")
     if not os.path.exists(stock_server_path):
-        st.error(f"❌ stock_data_server.py not found at {stock_server_path}")
+        print(f"❌ ERROR: stock_data_server.py not found at {stock_server_path}")
         return False
 
     # Test if servers can be executed by checking if they can be imported
     import sys
     import importlib.util
 
-    # Initialize session state for notifications
-    if "notifications" not in st.session_state:
-        st.session_state.notifications = []
-    if "notification_times" not in st.session_state:
-        st.session_state.notification_times = {}
-    if "servers_importable_shown" not in st.session_state:
-        st.session_state.servers_importable_shown = False
-
-    current_time = time.time()
-
-    # Clean up old notifications (older than 10 seconds)
-    st.session_state.notifications = [
-        msg
-        for msg, timestamp in zip(
-            st.session_state.notifications, st.session_state.notification_times.values()
-        )
-        if current_time - timestamp < 10
-    ]
-    st.session_state.notification_times = {
-        k: v
-        for k, v in st.session_state.notification_times.items()
-        if current_time - v < 10
-    }
-
     try:
         # Test if news_server can be imported
         spec = importlib.util.spec_from_file_location("news_server", news_server_path)
         if spec is None or spec.loader is None:
-            st.warning("⚠️ Could not load news_server.py")
+            print("⚠️ WARNING: Could not load news_server.py")
         else:
-            # Add temporary success notification only once
-            if not st.session_state.servers_importable_shown:
-                st.success("✅ news_server.py is importable")
-                st.session_state.servers_importable_shown = True
+            print("✅ SUCCESS: news_server.py is importable")
     except Exception as e:
-        st.warning(f"⚠️ Could not import news_server.py: {e}")
+        print(f"⚠️ WARNING: Could not import news_server.py: {e}")
 
     try:
         # Test if stock_data_server can be imported
@@ -573,26 +800,29 @@ def test_server_availability():
             "stock_data_server", stock_server_path
         )
         if spec is None or spec.loader is None:
-            st.warning("⚠️ Could not load stock_data_server.py")
+            print("⚠️ WARNING: Could not load stock_data_server.py")
         else:
-            # Add temporary success notification only once
-            if not st.session_state.servers_importable_shown:
-                st.success("✅ stock_data_server.py is importable")
-                st.session_state.servers_importable_shown = True
+            print("✅ SUCCESS: stock_data_server.py is importable")
     except Exception as e:
-        st.warning(f"⚠️ Could not import stock_data_server.py: {e}")
+        print(f"⚠️ WARNING: Could not import stock_data_server.py: {e}")
 
     return True
 
 
 def main():
-    st.set_page_config(page_title="Financial Agent", page_icon="📈", layout="wide")
+    st.set_page_config(page_title="QueryStockAI", page_icon="📈", layout="wide")
 
-    st.title("📈 Financial Agent")
+    st.title("📈 QueryStockAI")
     st.markdown(
         "Get comprehensive financial analysis and insights for your selected stocks."
     )
 
+    # Initialize resource monitoring
+    if RESOURCE_MONITORING_AVAILABLE:
+        if "resource_monitoring_started" not in st.session_state:
+            start_resource_monitoring()
+            st.session_state.resource_monitoring_started = True
+
     # Initialize tools
     initialize_tools()
 
@@ -622,6 +852,20 @@ def main():
         placeholder="Select a ticker...",
     )
 
+    # Clear cache when ticker changes
+    if (
+        "current_ticker" in st.session_state
+        and st.session_state.current_ticker != selected_ticker
+    ):
+        # Clear all cached data for the previous ticker
+        for key in list(st.session_state.keys()):
+            if key.startswith("chart_") or key.startswith("news_"):
+                del st.session_state[key]
+
+    # Update current ticker
+    if selected_ticker:
+        st.session_state.current_ticker = selected_ticker
+
     # Main content area
     if not selected_ticker:
         st.info(
@@ -647,6 +891,11 @@ def main():
             f"✅ Selected: {selected_ticker} - {available_tickers[selected_ticker]}"
         )
 
+        # Add loading state for initial page load
+        if "page_loaded" not in st.session_state:
+            with st.spinner("🔄 Loading application..."):
+                st.session_state.page_loaded = True
+
         # Stock Chart and News Section
         st.header("📈 Stock Analysis")
 
@@ -655,59 +904,90 @@ def main():
 
         with col1:
             st.subheader("📈 Stock Price Chart")
-            # Create and display the stock chart
-            with st.spinner(f"Loading chart for {selected_ticker}..."):
-                chart_fig = create_stock_chart(selected_ticker)
-                if chart_fig:
-                    st.plotly_chart(chart_fig, use_container_width=True)
-                else:
-                    st.warning(f"Could not load chart for {selected_ticker}")
+            # Cache the chart to prevent rerendering
+            chart_key = f"chart_{selected_ticker}"
+            if chart_key not in st.session_state:
+                with st.spinner(f"📊 Loading chart for {selected_ticker}..."):
+                    chart_fig = create_stock_chart(selected_ticker)
+                    if chart_fig:
+                        st.session_state[chart_key] = chart_fig
+                    else:
+                        st.session_state[chart_key] = None
+
+            # Display the cached chart
+            if st.session_state[chart_key]:
+                st.plotly_chart(st.session_state[chart_key], use_container_width=True)
+            else:
+                st.warning(f"Could not load chart for {selected_ticker}")
 
         with col2:
             st.subheader("📰 Top News")
-            # Display top news for the selected ticker
-            display_top_news(selected_ticker)
+            # Cache the news to prevent rerendering
+            news_key = f"news_{selected_ticker}"
+            if news_key not in st.session_state:
+                st.session_state[news_key] = True  # Mark as loaded
+                display_top_news(selected_ticker)
+            else:
+                # Re-display cached news without reloading
+                display_top_news(selected_ticker)
 
-        # Chat Section in a container
+        # Chat Section
         st.header("💬 Chat with Financial Agent")
 
-        # Create a container for the chat interface
-        with st.container():
-            # Initialize chat history
-            if "messages" not in st.session_state:
-                st.session_state.messages = []
-
-            # Display chat history
-            for message in st.session_state.messages:
-                with st.chat_message(message["role"]):
-                    st.markdown(message["content"])
-
-            # Chat input
-            if prompt := st.chat_input(f"Ask about {selected_ticker}..."):
-                # Add user message to chat history
-                st.session_state.messages.append({"role": "user", "content": prompt})
-
-                # Display user message
-                with st.chat_message("user"):
-                    st.markdown(prompt)
-
-                # Display assistant response
-                with st.chat_message("assistant"):
-                    with st.spinner("🤖 Analyzing..."):
-                        response = asyncio.run(run_agent(prompt, selected_ticker))
-                        st.markdown(response)
-                        st.session_state.messages.append(
-                            {"role": "assistant", "content": response}
-                        )
-
-            # Clear chat button
-            col1, col2 = st.columns([1, 4])
-            with col1:
-                if st.button("🗑️ Clear Chat History"):
-                    st.session_state.messages = []
-                    st.rerun()
-            with col2:
-                st.markdown("*Chat history will be maintained during your session*")
+        # Initialize chat history
+        if "messages" not in st.session_state:
+            st.session_state.messages = []
+
+        # Display existing chat messages using custom styling
+        for message in st.session_state.messages:
+            if message["role"] == "user":
+                st.markdown(
+                    f"""
+                <div style="background-color: #e3f2fd; padding: 10px; border-radius: 10px; margin: 5px 0; border: 1px solid #bbdefb;">
+                    <strong>You:</strong> {message["content"]}
+                </div>
+                """,
+                    unsafe_allow_html=True,
+                )
+            else:
+                st.markdown(
+                    f"""
+                <div style=" padding: 10px; border-radius: 10px; margin: 5px 0;">
+                    <strong>Agent:</strong>
+                </div>
+                """,
+                    unsafe_allow_html=True,
+                )
+                # Render the content as markdown for proper formatting
+                st.markdown(message["content"])
+
+        # Chat input with proper loading state
+        if prompt := st.chat_input(f"Ask about {selected_ticker}...", key="chat_input"):
+            # Track streamlit request
+            if RESOURCE_MONITORING_AVAILABLE:
+                resource_monitor.increment_streamlit_requests()
+
+            # Add user message to chat history
+            st.session_state.messages.append({"role": "user", "content": prompt})
+
+            # Display assistant response with spinner above input
+            with st.spinner("🤖 Analyzing your request..."):
+                response = asyncio.run(run_agent(prompt, selected_ticker))
+                st.session_state.messages.append(
+                    {"role": "assistant", "content": response}
+                )
+
+            # Rerun to display the new message (charts and news are cached)
+            st.rerun()
+
+        # Clear chat button
+        # col1, col2 = st.columns([1, 4])
+        # with col1:
+        #     if st.button("🗑️ Clear Chat History", key="clear_button"):
+        #         st.session_state.messages = []
+        #         st.rerun()
+        # with col2:
+        #     st.markdown("*Chat history will be maintained during your session*")
 
 
 if __name__ == "__main__":

README.md

@@ -1,4 +1,4 @@
-# Financial Agent
+# QueryStockAI
 
 A comprehensive financial analysis tool that provides real-time stock data and news analysis through an AI-powered chat interface.
 

pages/System_Monitor.py

@@ -0,0 +1,123 @@
+import streamlit as st
+import time
+
+# Import resource monitoring
+try:
+    from resource_monitor import (
+        start_resource_monitoring,
+        stop_resource_monitoring,
+        get_resource_stats,
+        create_resource_dashboard,
+        get_resource_summary,
+        export_resource_data,
+        resource_monitor,
+    )
+
+    RESOURCE_MONITORING_AVAILABLE = True
+except ImportError:
+    RESOURCE_MONITORING_AVAILABLE = False
+    st.warning("Resource monitoring not available. Install psutil: pip install psutil")
+
+
+def main():
+    st.set_page_config(page_title="System Monitor", page_icon="📊", layout="wide")
+
+    st.title("📊 System Resource Monitor")
+    st.markdown("Real-time monitoring of system resources and application metrics.")
+
+    # Initialize resource monitoring
+    if RESOURCE_MONITORING_AVAILABLE:
+        if "resource_monitoring_started" not in st.session_state:
+            start_resource_monitoring()
+            st.session_state.resource_monitoring_started = True
+
+        # Current stats with loading state
+        with st.spinner("📊 Loading resource statistics..."):
+            current_stats = get_resource_stats()
+
+        if "error" not in current_stats:
+            # System Metrics
+            st.subheader("🖥️ System Metrics")
+            col1, col2, col3, col4 = st.columns(4)
+
+            with col1:
+                st.metric("CPU Usage", f"{current_stats['cpu_percent']:.1f}%")
+                st.metric("Memory Usage", f"{current_stats['memory_percent']:.1f}%")
+
+            with col2:
+                st.metric("Memory (GB)", f"{current_stats['memory_gb']:.2f} GB")
+                st.metric("Disk Usage", f"{current_stats['disk_usage_percent']:.1f}%")
+
+            with col3:
+                st.metric("Network Sent", f"{current_stats['network_sent_mb']:.1f} MB")
+                st.metric("Network Recv", f"{current_stats['network_recv_mb']:.1f} MB")
+
+            with col4:
+                st.metric("Process Count", current_stats["process_count"])
+                st.metric("Uptime", f"{current_stats['uptime_seconds']/60:.1f} min")
+
+            # Application-specific metrics
+            st.subheader("📈 Application Metrics")
+            col1, col2, col3 = st.columns(3)
+
+            with col1:
+                st.metric("YFinance Calls", current_stats["yfinance_calls"])
+
+            with col2:
+                st.metric(
+                    "Prophet Training Time",
+                    f"{current_stats['prophet_training_time']:.2f}s",
+                )
+
+            with col3:
+                st.metric("Streamlit Requests", current_stats["streamlit_requests"])
+
+            # Summary statistics
+            summary_stats = get_resource_summary()
+            if summary_stats:
+                st.subheader("📋 Summary Statistics")
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    st.write(
+                        f"**Average CPU Usage:** {summary_stats.get('avg_cpu_percent', 0):.1f}%"
+                    )
+                    st.write(
+                        f"**Max CPU Usage:** {summary_stats.get('max_cpu_percent', 0):.1f}%"
+                    )
+                    st.write(
+                        f"**Average Memory Usage:** {summary_stats.get('avg_memory_percent', 0):.1f}%"
+                    )
+                    st.write(
+                        f"**Max Memory Usage:** {summary_stats.get('max_memory_percent', 0):.1f}%"
+                    )
+
+                with col2:
+                    st.write(
+                        f"**Total Network Sent:** {summary_stats.get('total_network_sent_mb', 0):.1f} MB"
+                    )
+                    st.write(
+                        f"**Total Network Recv:** {summary_stats.get('total_network_recv_mb', 0):.1f} MB"
+                    )
+                    st.write(
+                        f"**Total Uptime:** {summary_stats.get('total_uptime_minutes', 0):.1f} minutes"
+                    )
+                    st.write(
+                        f"**Total YFinance Calls:** {summary_stats.get('yfinance_calls', 0)}"
+                    )
+
+            # Export data button
+            if st.button("📥 Export Resource Data"):
+                filename = export_resource_data()
+                st.success(f"Resource data exported to: {filename}")
+
+        else:
+            st.error(f"Error getting resource stats: {current_stats['error']}")
+    else:
+        st.warning(
+            "Resource monitoring is not available. Please install psutil: pip install psutil"
+        )
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -12,6 +12,8 @@ dependencies = [
     "openai>=1.97.1",
     "pandas>=2.3.1",
     "plotly>=5.17.0",
+    "prophet>=1.1.7",
+    "psutil>=7.0.0",
     "python-dotenv>=1.1.1",
     "sentence-transformers>=5.0.0",
     "streamlit>=1.28.0",

requirements.txt

@@ -1,5 +1,9 @@
 beautifulsoup4>=4.13.4
 fastmcp>=2.10.6
+prophet>=1.1.4
+psutil>=5.9.0
+scikit-learn>=1.3.0
+numpy>=1.24.0
 gnews>=0.4.1
 mcp[cli]>=1.12.2
 openai>=1.97.1

resource_monitor.py

@@ -0,0 +1,319 @@
+import psutil
+import time
+import threading
+import streamlit as st
+import pandas as pd
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import os
+import sys
+import asyncio
+import yfinance as yf
+from typing import Dict, List, Optional
+import json
+
+
+class ResourceMonitor:
+    """Monitor system resources for the QueryStockAI."""
+
+    def __init__(self):
+        self.monitoring = False
+        self.monitor_thread = None
+        self.resource_data = {
+            "timestamps": [],
+            "cpu_percent": [],
+            "memory_percent": [],
+            "memory_mb": [],
+            "disk_usage_percent": [],
+            "network_sent_mb": [],
+            "network_recv_mb": [],
+            "process_count": [],
+            "yfinance_calls": 0,
+            "prophet_training_time": 0,
+            "streamlit_requests": 0,
+        }
+        self.start_time = None
+        self.process = psutil.Process()
+
+    def start_monitoring(self):
+        """Start resource monitoring in a separate thread."""
+        if not self.monitoring:
+            self.monitoring = True
+            self.start_time = datetime.now()
+            self.monitor_thread = threading.Thread(
+                target=self._monitor_loop, daemon=True
+            )
+            self.monitor_thread.start()
+            return True
+        return False
+
+    def stop_monitoring(self):
+        """Stop resource monitoring."""
+        self.monitoring = False
+        if self.monitor_thread:
+            self.monitor_thread.join(timeout=1)
+
+    def _monitor_loop(self):
+        """Main monitoring loop."""
+        while self.monitoring:
+            try:
+                # Get current timestamp
+                timestamp = datetime.now()
+
+                # CPU usage
+                cpu_percent = psutil.cpu_percent(interval=1)
+
+                # Memory usage
+                memory = psutil.virtual_memory()
+                memory_percent = memory.percent
+                memory_mb = memory.used / (1024 * 1024)  # Convert to MB
+
+                # Disk usage
+                disk = psutil.disk_usage("/")
+                disk_usage_percent = disk.percent
+
+                # Network usage
+                network = psutil.net_io_counters()
+                network_sent_mb = network.bytes_sent / (1024 * 1024)
+                network_recv_mb = network.bytes_recv / (1024 * 1024)
+
+                # Process count
+                process_count = len(psutil.pids())
+
+                # Store data
+                self.resource_data["timestamps"].append(timestamp)
+                self.resource_data["cpu_percent"].append(cpu_percent)
+                self.resource_data["memory_percent"].append(memory_percent)
+                self.resource_data["memory_mb"].append(memory_mb)
+                self.resource_data["disk_usage_percent"].append(disk_usage_percent)
+                self.resource_data["network_sent_mb"].append(network_sent_mb)
+                self.resource_data["network_recv_mb"].append(network_recv_mb)
+                self.resource_data["process_count"].append(process_count)
+
+                # Keep only last 1000 data points to prevent memory issues
+                max_points = 1000
+                if len(self.resource_data["timestamps"]) > max_points:
+                    for key in self.resource_data:
+                        if isinstance(self.resource_data[key], list):
+                            self.resource_data[key] = self.resource_data[key][
+                                -max_points:
+                            ]
+
+                time.sleep(2)  # Monitor every 2 seconds
+
+            except Exception as e:
+                print(f"Error in monitoring loop: {e}")
+                time.sleep(5)
+
+    def get_current_stats(self) -> Dict:
+        """Get current resource statistics."""
+        try:
+            memory = psutil.virtual_memory()
+            disk = psutil.disk_usage("/")
+            network = psutil.net_io_counters()
+
+            return {
+                "cpu_percent": psutil.cpu_percent(),
+                "memory_percent": memory.percent,
+                "memory_mb": memory.used / (1024 * 1024),
+                "memory_gb": memory.used / (1024 * 1024 * 1024),
+                "disk_usage_percent": disk.percent,
+                "disk_free_gb": disk.free / (1024 * 1024 * 1024),
+                "network_sent_mb": network.bytes_sent / (1024 * 1024),
+                "network_recv_mb": network.bytes_recv / (1024 * 1024),
+                "process_count": len(psutil.pids()),
+                "uptime_seconds": (
+                    (datetime.now() - self.start_time).total_seconds()
+                    if self.start_time
+                    else 0
+                ),
+                "yfinance_calls": self.resource_data["yfinance_calls"],
+                "prophet_training_time": self.resource_data["prophet_training_time"],
+                "streamlit_requests": self.resource_data["streamlit_requests"],
+            }
+        except Exception as e:
+            return {"error": str(e)}
+
+    def increment_yfinance_calls(self):
+        """Increment yfinance API call counter."""
+        self.resource_data["yfinance_calls"] += 1
+
+    def add_prophet_training_time(self, seconds: float):
+        """Add Prophet training time."""
+        self.resource_data["prophet_training_time"] += seconds
+
+    def increment_streamlit_requests(self):
+        """Increment Streamlit request counter."""
+        self.resource_data["streamlit_requests"] += 1
+
+    def create_resource_dashboard(self) -> go.Figure:
+        """Create a comprehensive resource dashboard."""
+        if not self.resource_data["timestamps"]:
+            return None
+
+        # Create subplots
+        fig = go.Figure()
+
+        # CPU Usage
+        fig.add_trace(
+            go.Scatter(
+                x=self.resource_data["timestamps"],
+                y=self.resource_data["cpu_percent"],
+                mode="lines",
+                name="CPU %",
+                line=dict(color="red", width=2),
+            )
+        )
+
+        # Memory Usage
+        fig.add_trace(
+            go.Scatter(
+                x=self.resource_data["timestamps"],
+                y=self.resource_data["memory_percent"],
+                mode="lines",
+                name="Memory %",
+                line=dict(color="blue", width=2),
+                yaxis="y2",
+            )
+        )
+
+        # Memory Usage in MB
+        fig.add_trace(
+            go.Scatter(
+                x=self.resource_data["timestamps"],
+                y=self.resource_data["memory_mb"],
+                mode="lines",
+                name="Memory (MB)",
+                line=dict(color="lightblue", width=2),
+                yaxis="y3",
+            )
+        )
+
+        # Network Usage
+        fig.add_trace(
+            go.Scatter(
+                x=self.resource_data["timestamps"],
+                y=self.resource_data["network_sent_mb"],
+                mode="lines",
+                name="Network Sent (MB)",
+                line=dict(color="green", width=2),
+                yaxis="y4",
+            )
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=self.resource_data["timestamps"],
+                y=self.resource_data["network_recv_mb"],
+                mode="lines",
+                name="Network Recv (MB)",
+                line=dict(color="orange", width=2),
+                yaxis="y4",
+            )
+        )
+
+        # Update layout
+        fig.update_layout(
+            title="System Resource Usage",
+            xaxis_title="Time",
+            height=600,
+            hovermode="x unified",
+            legend=dict(
+                orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1
+            ),
+            yaxis=dict(title="CPU %", side="left"),
+            yaxis2=dict(title="Memory %", side="right", overlaying="y"),
+            yaxis3=dict(title="Memory (MB)", side="right", position=0.95),
+            yaxis4=dict(title="Network (MB)", side="right", position=0.9),
+        )
+
+        return fig
+
+    def get_summary_stats(self) -> Dict:
+        """Get summary statistics."""
+        if not self.resource_data["timestamps"]:
+            return {}
+
+        return {
+            "total_uptime_minutes": (
+                (datetime.now() - self.start_time).total_seconds() / 60
+                if self.start_time
+                else 0
+            ),
+            "avg_cpu_percent": sum(self.resource_data["cpu_percent"])
+            / len(self.resource_data["cpu_percent"]),
+            "max_cpu_percent": max(self.resource_data["cpu_percent"]),
+            "avg_memory_percent": sum(self.resource_data["memory_percent"])
+            / len(self.resource_data["memory_percent"]),
+            "max_memory_percent": max(self.resource_data["memory_percent"]),
+            "avg_memory_mb": sum(self.resource_data["memory_mb"])
+            / len(self.resource_data["memory_mb"]),
+            "max_memory_mb": max(self.resource_data["memory_mb"]),
+            "total_network_sent_mb": sum(self.resource_data["network_sent_mb"]),
+            "total_network_recv_mb": sum(self.resource_data["network_recv_mb"]),
+            "yfinance_calls": self.resource_data["yfinance_calls"],
+            "prophet_training_time": self.resource_data["prophet_training_time"],
+            "streamlit_requests": self.resource_data["streamlit_requests"],
+        }
+
+    def export_data(self, filename: str = None):
+        """Export monitoring data to JSON file."""
+        if filename is None:
+            filename = (
+                f"resource_monitor_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+            )
+
+        export_data = {
+            "summary_stats": self.get_summary_stats(),
+            "monitoring_data": {
+                "timestamps": [
+                    ts.isoformat() for ts in self.resource_data["timestamps"]
+                ],
+                "cpu_percent": self.resource_data["cpu_percent"],
+                "memory_percent": self.resource_data["memory_percent"],
+                "memory_mb": self.resource_data["memory_mb"],
+                "disk_usage_percent": self.resource_data["disk_usage_percent"],
+                "network_sent_mb": self.resource_data["network_sent_mb"],
+                "network_recv_mb": self.resource_data["network_recv_mb"],
+                "process_count": self.resource_data["process_count"],
+            },
+        }
+
+        with open(filename, "w") as f:
+            json.dump(export_data, f, indent=2)
+
+        return filename
+
+
+# Global monitor instance
+resource_monitor = ResourceMonitor()
+
+
+def start_resource_monitoring():
+    """Start resource monitoring."""
+    return resource_monitor.start_monitoring()
+
+
+def stop_resource_monitoring():
+    """Stop resource monitoring."""
+    resource_monitor.stop_monitoring()
+
+
+def get_resource_stats():
+    """Get current resource statistics."""
+    return resource_monitor.get_current_stats()
+
+
+def create_resource_dashboard():
+    """Create resource dashboard."""
+    return resource_monitor.create_resource_dashboard()
+
+
+def get_resource_summary():
+    """Get resource summary."""
+    return resource_monitor.get_summary_stats()
+
+
+def export_resource_data(filename=None):
+    """Export resource data."""
+    return resource_monitor.export_data(filename)

agent_client.py → terminal_client.py

@@ -356,7 +356,7 @@ async def main():
         # Predefined tickers
         available_tickers = {"1": "AAPL", "2": "TSLA", "3": "MSFT", "4": "GOOG"}
 
-        print("=== Financial Agent ===")
+        print("=== QueryStockAI ===")
         print("Select a stock ticker to analyze:")
         print("1. AAPL (Apple)")
         print("2. TSLA (Tesla)")

test_prophet_accuracy.py

@@ -0,0 +1,373 @@
+#!/usr/bin/env python3
+"""
+Prophet Accuracy Test Script
+Trains Prophet model on given ticker data up to June 2025 and tests predictions for July 2025.
+"""
+
+import yfinance as yf
+import pandas as pd
+from prophet import Prophet
+from datetime import datetime, timedelta
+import numpy as np
+from sklearn.metrics import (
+    mean_absolute_error,
+    mean_squared_error,
+    mean_absolute_percentage_error,
+)
+import warnings
+
+warnings.filterwarnings("ignore")
+
+ticker = "AAPL"
+
+
+def get_aapl_data():
+    """Get AAPL historical data."""
+    print("📊 Fetching AAPL historical data...")
+
+    # Get data for the past 2 years to have enough training data
+    raw_data = yf.Ticker("AAPL")
+    data = raw_data.history(period="2y")
+
+    if data.empty:
+        raise ValueError("No data received for AAPL")
+
+    print(f"✅ Retrieved {len(data)} days of AAPL data")
+    print(f"📅 Date range: {data.index.min().date()} to {data.index.max().date()}")
+
+    return data
+
+
+def prepare_prophet_data(data, end_date):
+    """Prepare data for Prophet training (up to end_date)."""
+    print(f"\n🔧 Preparing Prophet data up to {end_date.date()}...")
+
+    # Convert end_date to timezone-aware datetime to match data index
+    if data.index.tz is not None:
+        end_date = pd.Timestamp(end_date).tz_localize(data.index.tz)
+
+    # Filter data up to end_date
+    training_data = data[data.index <= end_date].copy()
+
+    # Remove outliers using IQR method
+    Q1 = training_data["Close"].quantile(0.25)
+    Q3 = training_data["Close"].quantile(0.75)
+    IQR = Q3 - Q1
+    lower_bound = Q1 - 1.5 * IQR
+    upper_bound = Q3 + 1.5 * IQR
+
+    # Filter out outliers
+    training_data = training_data[
+        (training_data["Close"] >= lower_bound)
+        & (training_data["Close"] <= upper_bound)
+    ]
+
+    print(
+        f"📊 Removed outliers: {len(data[data.index <= end_date]) - len(training_data)} points"
+    )
+
+    # Prepare for Prophet (requires 'ds' and 'y' columns)
+    prophet_data = training_data.reset_index()
+    prophet_data["ds"] = prophet_data["Date"].dt.tz_localize(None)  # Remove timezone
+    prophet_data["y"] = prophet_data["Close"]
+
+    # Select only required columns
+    prophet_data = prophet_data[["ds", "y"]]
+
+    print(f"✅ Training data prepared: {len(prophet_data)} days")
+    print(
+        f"📈 Price range: ${prophet_data['y'].min():.2f} - ${prophet_data['y'].max():.2f}"
+    )
+
+    return prophet_data
+
+
+def train_prophet_model(data):
+    """Train Prophet model on the provided data."""
+    print("\n🤖 Training Prophet model...")
+
+    # Configure Prophet model with optimized parameters
+    model = Prophet(
+        yearly_seasonality=True,
+        weekly_seasonality=True,
+        daily_seasonality=False,
+        changepoint_prior_scale=0.01,  # Reduced for smoother trends
+        seasonality_prior_scale=10.0,  # Increased seasonality strength
+        seasonality_mode="multiplicative",
+        interval_width=0.8,  # Tighter confidence intervals
+        mcmc_samples=0,  # Disable MCMC for faster training
+    )
+
+    # Add custom seasonalities for better stock patterns
+    model.add_seasonality(name="monthly", period=30.5, fourier_order=5)
+
+    model.add_seasonality(name="quarterly", period=91.25, fourier_order=8)
+
+    # Train the model
+    model.fit(data)
+
+    print("✅ Prophet model trained successfully")
+    return model
+
+
+def make_predictions(model, start_date, end_date):
+    """Make predictions for the specified date range."""
+    print(f"\n🔮 Making predictions from {start_date.date()} to {end_date.date()}...")
+
+    # Calculate the number of days to predict
+    days_to_predict = (end_date - start_date).days + 1
+
+    # Create future dataframe
+    future = model.make_future_dataframe(periods=days_to_predict)
+    forecast = model.predict(future)
+
+    # Filter predictions for the specified period
+    predictions = forecast[
+        (forecast["ds"] >= start_date) & (forecast["ds"] <= end_date)
+    ].copy()
+
+    print(f"✅ Generated {len(predictions)} predictions for {days_to_predict} days")
+
+    return predictions
+
+
+def get_actual_july_data(data, start_date, end_date):
+    """Get actual AAPL data for July."""
+    print(f"\n📊 Fetching actual July data...")
+
+    # Convert dates to timezone-aware datetime to match data index
+    if data.index.tz is not None:
+        start_date = pd.Timestamp(start_date).tz_localize(data.index.tz)
+        end_date = pd.Timestamp(end_date).tz_localize(data.index.tz)
+
+    # Get actual data for July
+    actual_data = data[(data.index >= start_date) & (data.index <= end_date)].copy()
+
+    print(f"✅ Retrieved {len(actual_data)} days of actual July data")
+
+    return actual_data
+
+
+def calculate_accuracy_metrics(predictions, actual_data):
+    """Calculate accuracy metrics."""
+    print("\n📈 Calculating accuracy metrics...")
+
+    # Prepare actual data with timezone-naive dates for merging
+    actual_data_prepared = actual_data.reset_index().copy()
+    actual_data_prepared["Date"] = actual_data_prepared["Date"].dt.tz_localize(None)
+
+    # Merge predictions with actual data
+    comparison = pd.merge(
+        predictions[["ds", "yhat", "yhat_lower", "yhat_upper"]],
+        actual_data_prepared[["Date", "Close"]],
+        left_on="ds",
+        right_on="Date",
+        how="inner",
+    )
+
+    if comparison.empty:
+        print("❌ No overlapping data found for comparison")
+        return None
+
+    # Calculate metrics
+    mae = mean_absolute_error(comparison["Close"], comparison["yhat"])
+    mse = mean_squared_error(comparison["Close"], comparison["yhat"])
+    rmse = np.sqrt(mse)
+    mape = mean_absolute_percentage_error(comparison["Close"], comparison["yhat"]) * 100
+
+    # Calculate directional accuracy (up/down prediction)
+    actual_direction = comparison["Close"].diff().dropna()
+    predicted_direction = comparison["yhat"].diff().dropna()
+
+    # Align the data
+    min_len = min(len(actual_direction), len(predicted_direction))
+    actual_direction = actual_direction.iloc[-min_len:]
+    predicted_direction = predicted_direction.iloc[-min_len:]
+
+    directional_accuracy = (
+        np.mean((actual_direction > 0) == (predicted_direction > 0)) * 100
+    )
+
+    return {
+        "mae": mae,
+        "mse": mse,
+        "rmse": rmse,
+        "mape": mape,
+        "directional_accuracy": directional_accuracy,
+        "comparison_data": comparison,
+    }
+
+
+def print_results(metrics, predictions, actual_data):
+    """Print detailed results."""
+    print("\n" + "=" * 60)
+    print("📊 PROPHET ACCURACY TEST RESULTS")
+    print("=" * 60)
+
+    if metrics is None:
+        print("❌ No metrics available - insufficient data for comparison")
+        return
+
+    print(f"\n📈 Accuracy Metrics:")
+    print(f"   Mean Absolute Error (MAE): ${metrics['mae']:.2f}")
+    print(f"   Mean Squared Error (MSE): {metrics['mse']:.2f}")
+    print(f"   Root Mean Squared Error (RMSE): ${metrics['rmse']:.2f}")
+    print(f"   Mean Absolute Percentage Error (MAPE): {metrics['mape']:.2f}%")
+    print(f"   Directional Accuracy: {metrics['directional_accuracy']:.1f}%")
+
+    print(f"\n📊 Prediction Summary:")
+    print(f"   Training Period: Up to June 30, 2025")
+    print(f"   Test Period: July 1-25, 2025")
+    print(f"   Test Days: {len(metrics['comparison_data'])}")
+
+    # Show some sample predictions vs actual
+    comparison = metrics["comparison_data"]
+    print(f"\n📋 Sample Predictions vs Actual (first 5 days):")
+    print(f"{'Date':<12} {'Predicted':<12} {'Actual':<12} {'Error':<12}")
+    print("-" * 50)
+
+    for i in range(min(5, len(comparison))):
+        row = comparison.iloc[i]
+        error = row["Close"] - row["yhat"]
+        print(
+            f"{row['ds'].strftime('%Y-%m-%d'):<12} "
+            f"${row['yhat']:<11.2f} "
+            f"${row['Close']:<11.2f} "
+            f"${error:<11.2f}"
+        )
+
+    print("\n" + "=" * 60)
+
+
+def test_multiple_configurations(data, training_end, test_start, test_end):
+    """Test multiple Prophet configurations to find the best one."""
+    print("\n🔬 Testing multiple Prophet configurations...")
+
+    configurations = [
+        {
+            "name": "Default",
+            "params": {
+                "yearly_seasonality": True,
+                "weekly_seasonality": True,
+                "daily_seasonality": False,
+                "changepoint_prior_scale": 0.05,
+                "seasonality_mode": "multiplicative",
+            },
+        },
+        {
+            "name": "Optimized",
+            "params": {
+                "yearly_seasonality": True,
+                "weekly_seasonality": True,
+                "daily_seasonality": False,
+                "changepoint_prior_scale": 0.01,
+                "seasonality_prior_scale": 10.0,
+                "seasonality_mode": "multiplicative",
+                "interval_width": 0.8,
+                "mcmc_samples": 0,
+            },
+        },
+        {
+            "name": "Conservative",
+            "params": {
+                "yearly_seasonality": True,
+                "weekly_seasonality": False,
+                "daily_seasonality": False,
+                "changepoint_prior_scale": 0.001,
+                "seasonality_mode": "additive",
+            },
+        },
+    ]
+
+    best_config = None
+    best_mape = float("inf")
+    results = []
+
+    for config in configurations:
+        print(f"\n🧪 Testing {config['name']} configuration...")
+
+        try:
+            # Prepare training data
+            training_data = prepare_prophet_data(data, training_end)
+
+            # Create and train model
+            model = Prophet(**config["params"])
+
+            # Add custom seasonalities for optimized config
+            if config["name"] == "Optimized":
+                model.add_seasonality(name="monthly", period=30.5, fourier_order=5)
+                model.add_seasonality(name="quarterly", period=91.25, fourier_order=8)
+
+            model.fit(training_data)
+
+            # Make predictions
+            predictions = make_predictions(model, test_start, test_end)
+
+            # Get actual data
+            actual_data = get_actual_july_data(data, test_start, test_end)
+
+            # Calculate metrics
+            metrics = calculate_accuracy_metrics(predictions, actual_data)
+
+            if metrics:
+                results.append({"config": config["name"], "metrics": metrics})
+
+                if metrics["mape"] < best_mape:
+                    best_mape = metrics["mape"]
+                    best_config = config["name"]
+
+                print(
+                    f"✅ {config['name']}: MAPE = {metrics['mape']:.2f}%, Directional = {metrics['directional_accuracy']:.1f}%"
+                )
+            else:
+                print(f"❌ {config['name']}: No valid metrics")
+
+        except Exception as e:
+            print(f"❌ {config['name']}: Error - {e}")
+
+    return best_config, results
+
+
+def main():
+    """Main function to run the Prophet accuracy test."""
+    print("🚀 Starting Prophet Accuracy Test for AAPL")
+    print("=" * 60)
+
+    try:
+        # Define date ranges
+        training_end = datetime(2025, 6, 30)  # End of June 2025
+        test_start = datetime(2025, 7, 1)  # Start of July 2025
+        test_end = datetime(2025, 7, 25)  # End of July 2025 (up to 25th)
+
+        print(f"📅 Training Period: Up to {training_end.date()}")
+        print(f"📅 Test Period: {test_start.date()} to {test_end.date()}")
+
+        # Get data
+        data = get_aapl_data()
+
+        # Test multiple configurations
+        best_config, all_results = test_multiple_configurations(
+            data, training_end, test_start, test_end
+        )
+
+        if best_config:
+            print(f"\n🏆 Best configuration: {best_config}")
+
+            # Use the best configuration for final results
+            best_result = next(r for r in all_results if r["config"] == best_config)
+            metrics = best_result["metrics"]
+
+            # Print final results
+            print_results(metrics, None, None)
+        else:
+            print("\n❌ No valid configurations found")
+
+    except Exception as e:
+        print(f"\n❌ Error during testing: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()