Initial clean commit on master branch

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,24 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.log
+
+# Virtual Environment
+venv/
+.venv/
+
+
+# IDE-specific files
+.idea/
+.vscode/
+
+# Environment variables
+.env
+
+# Reports and generated files
+reports/
+
+# macOS system files
+.DS_Store

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Yahya Darman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,13 @@
+---
+title: BuffetBot - Agentic Stock Advisor
+emoji: 📈
+colorFrom: purple
+colorTo: green
+sdk: gradio
+app_file: app.py
+short_description: MCP-Modal AI agent for Buffett-inspired stock analysis
+pinned: false
+tags:
+  - agent-demo-track
+  - mcp-server-track
+---

app.py

@@ -0,0 +1,411 @@
+import gradio as gr
+from datetime import datetime
+import os
+from dotenv import load_dotenv
+import requests # Import requests for HTTP calls to Modal backend
+import plotly.io as pio # Import plotly.io to deserialize JSON strings to Plotly figures
+# from gradio.themes.utils import fonts
+
+# from backend.stock_analyzer import StockAnalyzer
+# from backend.config import AppConfig
+
+# Load environment variables
+load_dotenv()
+
+
+# class BuffetBotTheme(gr.themes.Soft):
+#     def __init__(self, **kwargs):
+#         super().__init__(
+#             font=(
+#                 fonts.GoogleFont("Quicksand"),
+#                 "ui-sans-serif",
+#                 "sans-serif",
+#             ),
+#             **kwargs
+#         )
+
+
+class BuffetBotApp:
+    def __init__(self):
+        # self.config = AppConfig()
+        # self.stock_analyzer = StockAnalyzer()
+        self.mcp_server_url = os.getenv("MODAL_MCP_SERVER_URL") # Get Modal MCP server URL from environment variable
+        if not self.mcp_server_url:
+            raise ValueError("MODAL_MCP_SERVER_URL environment variable not set.")
+        
+    def create_ui(self):
+        """Create the Gradio interface."""
+        custom_css = """
+        /* General Body and Font */
+        body {
+            font-family: 'Roboto', 'Helvetica', 'Arial', sans-serif;
+            color: #333;
+            background-color: #f5f5f5;
+        }
+
+        /* Main Container Styling */
+        .gradio-container {
+            max-width: 1000px; /* Slightly wider container */
+            margin: auto;
+            padding: 30px;
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+            border-radius: 12px;
+            background-color: #ffffff;
+            margin-top: 30px;
+            margin-bottom: 30px;
+        }
+
+        /* Headings */
+        h1 {
+            font-size: 2.8em;
+            color: #1a237e; /* Darker blue for prominence */
+            text-align: center;
+            margin-bottom: 25px;
+            font-weight: 700; /* Bold */
+            letter-spacing: -0.5px;
+        }
+
+        h2 {
+            font-size: 2.0em;
+            color: #3f51b5; /* Medium blue for subheadings */
+            border-bottom: 2px solid #e8eaf6; /* Light separator */
+            padding-bottom: 10px;
+            margin-top: 40px;
+            margin-bottom: 20px;
+            font-weight: 600;
+        }
+        
+        h3 {
+            font-size: 1.5em;
+            color: #424242;
+            margin-top: 25px;
+            margin-bottom: 15px;
+        }
+
+        /* Textboxes and Inputs */
+        .gr-textbox textarea, .gr-textbox input {
+            border: 1px solid #bdbdbd;
+            border-radius: 8px;
+            padding: 10px 15px;
+            font-size: 1.1em;
+            box-shadow: inset 0 1px 3px rgba(0, 0, 0, 0.05);
+        }
+        .gr-textbox label {
+            font-weight: 600;
+            color: #555;
+            margin-bottom: 8px;
+        }
+
+        /* Buttons */
+        .gr-button {
+            border-radius: 8px;
+            padding: 12px 25px;
+            font-size: 1.1em;
+            font-weight: 600;
+            transition: all 0.3s ease;
+        }
+        .gr-button.primary {
+            background-color: #4CAF50; /* Green */
+            color: white;
+            border: none;
+        }
+        .gr-button.primary:hover {
+            background-color: #43a047;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+        }
+        .gr-button.secondary {
+            background-color: #e3f2fd; /* Light blue background for secondary button */
+            color: #424242;
+            border: 1px solid #90caf9; /* Light blue border */
+        }
+        .gr-button.secondary:hover {
+            background-color: #bbdefb;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.1);
+        }
+        .gr-button.download {
+            background-color: #2196f3; /* Blue for download */
+            color: white;
+            border: none;
+        }
+        .gr-button.download:hover {
+            background-color: #1976d2;
+            box-shadow: 0 2px 8px rgba(0,0,0,0.2);
+        }
+
+        /* Markdown Output */
+        .gr-markdown {
+            background-color: #f9f9f9;
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 20px;
+            line-height: 1.6;
+            color: #424242;
+            white-space: normal !important; /* Ensure text wraps */
+            word-wrap: break-word !important; /* Ensure long words break */
+        }
+        .gr-markdown p {
+            margin-bottom: 10px;
+        }
+        .gr-markdown ul {
+            list-style-type: disc;
+            margin-left: 20px;
+            padding-left: 0;
+        }
+        .gr-markdown li {
+            margin-bottom: 5px;
+        }
+
+        /* Plots */
+        .gr-plot {
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            padding: 10px;
+            background-color: #ffffff;
+            margin-top: 20px;
+        }
+        
+        /* Specific element adjustments */
+        #connection-status-textbox {
+            font-weight: 500;
+            color: #3f51b5;
+        }
+        #loading-status-textbox {
+            font-style: italic;
+            color: #757575;
+        }
+        #input-button-column {
+            background-color: #ffffff !important;
+        }
+        .investor-note {
+            color: #2e7d32; /* Green color for investor notes */
+            font-style: italic;
+            font-weight: 500;
+            margin-top: 8px;
+            margin-bottom: 8px;
+            padding-left: 8px;
+            border-left: 2px solid #66bb6a; /* Small green bar on the left */
+        }
+        """
+
+        with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as app:
+            gr.Markdown("# 📈 BuffetBot - AI Stock Advisor")
+            
+            # Connection Status
+            with gr.Column():
+                connection_btn = gr.Button("🔗 Test MCP Connection", variant="secondary")
+                connection_status = gr.Textbox(label="MCP Connection Status", interactive=False, elem_id="connection-status-textbox")
+                # New vLLM Connection Test
+                vllm_connection_btn = gr.Button("🧠 Test vLLM Connection", variant="secondary")
+                vllm_connection_status = gr.Textbox(label="vLLM Connection Status", interactive=False, elem_id="vllm-connection-status-textbox")
+
+            with gr.Row():
+                with gr.Column(scale=2, elem_id="input-button-column"):
+                    ticker_input = gr.Textbox(
+                        label="Enter Stock Ticker",
+                        placeholder="e.g., AAPL",
+                        max_lines=1
+                    )
+                    generate_btn = gr.Button("Generate Report", variant="primary")
+                    loading_status = gr.Textbox(label="Status", interactive=False, visible=False, elem_id="loading-status-textbox")
+                
+            # Results display components
+            output = gr.Markdown(label="Analysis", visible=False)
+            revenue_plot = gr.Plot(label="Revenue Growth", visible=False)
+            fcf_plot = gr.Plot(label="Free Cash Flow per Share", visible=False)
+            shares_plot = gr.Plot(label="Shares Outstanding", visible=False)
+
+            # Static Chart Insights Section
+            chart_insights_text = """
+            ## Chart Insights
+            ### Revenue Growth
+            <p class="investor-note">*What to look for: We are looking for companies that consistently grow their revenue year after year, ideally. Consistent growth indicates market acceptance and business expansion.*</p>
+
+            ### Free Cash Flow per Share
+            <p class="investor-note">*What to look for: Look for companies with consistently high and growing free cash flow. High FCF indicates a company has strong financial health and flexibility for reinvestment, debt reduction, or shareholder returns.*</p>
+
+            ### Shares Outstanding
+            <p class="investor-note">*What to look for: Ideally, look for a declining trend in shares outstanding. This suggests the company is buying back its own shares, which can increase shareholder value by reducing the number of shares in circulation.*</p>
+            """
+            chart_insights = gr.Markdown(value=chart_insights_text, visible=False, label="Chart Insights")
+
+            download_button = gr.DownloadButton(
+                label="Download Analysis as TXT",
+                visible=False,
+                variant="secondary"
+            )
+            
+            # Hidden state to store analysis text for download
+            analysis_text_state = gr.State()
+
+            # Event handlers
+            generate_btn.click(
+                fn=self.generate_report,
+                inputs=[ticker_input],
+                outputs=[
+                    output,
+                    revenue_plot,
+                    fcf_plot,
+                    shares_plot,
+                    analysis_text_state,
+                    download_button,
+                    loading_status,
+                    chart_insights
+                ]
+            )
+            
+            ticker_input.submit(
+                fn=self.generate_report,
+                inputs=[ticker_input],
+                outputs=[
+                    output,
+                    revenue_plot,
+                    fcf_plot,
+                    shares_plot,
+                    analysis_text_state,
+                    download_button,
+                    loading_status,
+                    chart_insights
+                ]
+            )
+
+            download_button.click(
+                fn=self._save_and_return_analysis_file,
+                inputs=[analysis_text_state, ticker_input],
+                outputs=[download_button],
+                show_progress="hidden"
+            )
+
+            # Event handler for connection button
+            connection_btn.click(
+                fn=self._test_mcp_connection,
+                inputs=[],
+                outputs=[connection_status]
+            )
+            
+            vllm_connection_btn.click(
+                fn=self._test_vllm_connection,
+                inputs=[],
+                outputs=[vllm_connection_status]
+            )
+        
+        return app
+    
+    def _save_and_return_analysis_file(self, analysis_text: str, ticker: str):
+        """Saves the analysis text to a file and returns the path for download."""
+        if not analysis_text:
+            return None # No file to download if no analysis text
+
+        # Ensure reports directory exists
+        reports_dir = "reports"
+        os.makedirs(reports_dir, exist_ok=True)
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        file_path = os.path.join(reports_dir, f"{ticker}_analysis_{timestamp}.txt")
+        
+        with open(file_path, "w") as f:
+            f.write(analysis_text)
+        
+        return file_path
+
+    def generate_report(self, ticker):
+        """Generate stock analysis report."""
+        if not ticker or not ticker.strip():
+            return (
+                gr.update(value="Error: Please enter a valid stock ticker", visible=True),
+                gr.update(value=None, visible=False),
+                gr.update(value=None, visible=False),
+                gr.update(value=None, visible=False),
+                None,
+                gr.update(visible=False),
+                gr.update(value="❌ Error: Please enter a valid stock ticker", visible=True),
+                gr.update(visible=False)
+            )
+
+        try:
+            # Show loading state
+            yield (
+                gr.update(value="⏳ Generating report... Please wait.", visible=True),
+                gr.update(value=None, visible=False),
+                gr.update(value=None, visible=False),
+                gr.update(value=None, visible=False),
+                None,
+                gr.update(visible=False),
+                gr.update(value="⏳ Analyzing stock data and generating insights...", visible=True),
+                gr.update(visible=False)
+            )
+
+            # Call the Modal MCP server for analysis
+            headers = {'Content-Type': 'application/json'}
+            payload = {"ticker": ticker}
+            response = requests.post(f"{self.mcp_server_url}/analyze", headers=headers, json=payload)
+            response.raise_for_status()
+            analysis_data = response.json()
+
+            # Extract data from the response
+            analysis_results = {
+                "analysis": analysis_data["analysis"],
+                "revenue_chart": pio.from_json(analysis_data["revenue_chart"]) if analysis_data["revenue_chart"] else None,
+                "fcf_chart": pio.from_json(analysis_data["fcf_chart"]) if analysis_data["fcf_chart"] else None,
+                "shares_chart": pio.from_json(analysis_data["shares_chart"]) if analysis_data["shares_chart"] else None
+            }
+
+            # Format the analysis text with a timestamp
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            formatted_analysis = f"## Analysis Report for {ticker.upper()}\n*Generated on {timestamp}*\n\n{analysis_results['analysis']}"
+            
+            yield (
+                gr.update(value=formatted_analysis, visible=True),
+                gr.update(value=analysis_results["revenue_chart"], visible=True),
+                gr.update(value=analysis_results["fcf_chart"], visible=True),
+                gr.update(value=analysis_results["shares_chart"], visible=True),
+                formatted_analysis,
+                gr.update(label=f"Download {ticker.upper()} Report", visible=True),
+                gr.update(value="✅ Analysis complete!", visible=True),
+                gr.update(visible=True)
+            )
+        except requests.exceptions.RequestException as e:
+            error_msg = f"Error analyzing stock: {str(e)}"
+            if "429" in str(e):
+                error_msg = "Rate limit exceeded. Please try again in a few minutes."
+            elif "500" in str(e):
+                error_msg = "Server error. Please try again later."
+            yield (
+                gr.update(value=error_msg, visible=True),
+                gr.update(value=None, visible=False),
+                gr.update(value=None, visible=False),
+                gr.update(value=None, visible=False),
+                None,
+                gr.update(visible=False),
+                gr.update(value=f"❌ {error_msg}", visible=True),
+                gr.update(visible=False)
+            )
+
+    def _test_mcp_connection(self):
+        """Test connection to Modal MCP server health endpoint."""
+        try:
+            response = requests.get(f"{self.mcp_server_url}/health", timeout=10)
+            if response.status_code == 200:
+                return f"✅ Connected to Modal MCP Server: {response.json().get('status', 'OK')}"
+            else:
+                return f"❌ Connection failed (HTTP {response.status_code}): {response.text}"
+        except requests.exceptions.RequestException as e:
+            return f"❌ Connection error: {str(e)}"
+
+    def _test_vllm_connection(self):
+        """Tests the connection to the Modal vLLM service via the MCP server."""
+        try:
+            response = requests.get(f"{self.mcp_server_url}/test_llm_connection")
+            response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
+            status_data = response.json()
+            return f"Status: {status_data.get('status', 'Unknown')}"
+        except requests.exceptions.RequestException as e:
+            return f"Error calling vLLM test endpoint: {e}"
+
+def main():
+    """Main entry point for the application."""
+    app_instance = BuffetBotApp()
+    app = app_instance.create_ui()
+    app.launch(server_name="0.0.0.0", server_port=7860, mcp_server=True)
+
+if __name__ == "__main__":
+    main() 

backend/config.py

@@ -0,0 +1,59 @@
+# Configuration settings for BuffetBot.
+
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+
+class AppConfig:
+    """Configuration settings for the BuffetBot application."""
+    
+    def __init__(self):
+        load_dotenv()
+        
+        # API Keys
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        self.serper_api_key = os.getenv("SERPER_API_KEY")
+        
+        # App Settings
+        self.app_name = "BuffetBot"
+        self.app_version = "1.0.0"
+        
+        # Analysis Settings
+        self.default_timeframe = "5y"
+        self.default_interval = "1mo"
+        
+        # PDF Settings
+        self.pdf_output_dir = "reports"
+        self.pdf_template_dir = "templates"
+        
+        # Cache Settings
+        self.cache_dir = ".cache"
+        self.cache_expiry = 3600  # 1 hour
+        
+        # Create necessary directories
+        self._create_directories()
+    
+    def _create_directories(self):
+        """Create necessary directories if they don't exist."""
+        directories = [
+            self.pdf_output_dir,
+            self.pdf_template_dir,
+            self.cache_dir
+        ]
+        
+        for directory in directories:
+            if not os.path.exists(directory):
+                os.makedirs(directory)
+    
+    def get_pdf_path(self, ticker):
+        """Get the path for a PDF report."""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{ticker}_{timestamp}.pdf"
+        return os.path.join(self.pdf_output_dir, filename)
+    
+    def get_cache_path(self, ticker, data_type):
+        """Get the path for cached data."""
+        filename = f"{ticker}_{data_type}.json"
+        return os.path.join(self.cache_dir, filename)
+
+# Adding a comment to trigger a rebuild on Hugging Face Spaces. 

backend/data_collector.py

@@ -0,0 +1,278 @@
+import yfinance as yf
+import pandas as pd
+import requests
+from bs4 import BeautifulSoup
+import json
+import os
+from datetime import datetime, timedelta
+import time
+import logging
+from typing import List, Dict, Any
+
+from .config import AppConfig
+
+class YFinanceRateLimitError(Exception):
+    """Custom exception for yfinance rate limit errors."""
+    pass
+
+class StockDataCollector:
+    """Collects and caches stock data from various sources."""
+    
+    def __init__(self):
+        self.config = AppConfig()
+        self._setup_logging()
+        self.serper_api_key = os.getenv("SERPER_API_KEY")
+        self.serper_base_url = "https://google.serper.dev/search"
+    
+    def _setup_logging(self):
+        """Setup logging configuration."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        self.logger = logging.getLogger(__name__)
+    
+    def _perform_serper_search(self, query: str, num_results: int = 5) -> List[Dict[str, Any]]:
+        """Performs a web search using the Serper API and returns a list of search results."""
+        if not self.serper_api_key:
+            self.logger.warning("Serper API key not found. Skipping web search.")
+            return []
+
+        headers = {
+            'X-API-KEY': self.serper_api_key,
+            'Content-Type': 'application/json'
+        }
+        payload = {
+            "q": query,
+            "num": num_results
+        }
+
+        try:
+            self.logger.info(f"Performing Serper search for query: {query}")
+            response = requests.post(self.serper_base_url, headers=headers, data=json.dumps(payload))
+            response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
+            search_results = response.json()
+            
+            # Extract relevant snippets and URLs
+            snippets = []
+            if "organic" in search_results:
+                for result in search_results["organic"]:
+                    snippets.append({
+                        "title": result.get("title"),
+                        "snippet": result.get("snippet"),
+                        "link": result.get("link")
+                    })
+            return snippets
+
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Error performing Serper search for '{query}': {e}")
+            return []
+        except json.JSONDecodeError as e:
+            self.logger.error(f"JSON decoding error from Serper API for '{query}': {e}. Response: {response.text[:500]}...")
+            return []
+        except Exception as e:
+            self.logger.error(f"An unexpected error occurred during Serper search for '{query}': {e}")
+            return []
+    
+    def get_revenue_history(self, ticker):
+        """Get historical revenue data."""
+        cache_path = self.config.get_cache_path(ticker, "revenue")
+        
+        # Try to get from cache first
+        if os.path.exists(cache_path):
+            cache_age = time.time() - os.path.getmtime(cache_path)
+            if cache_age < self.config.cache_expiry:
+                try:
+                    with open(cache_path, 'r') as f:
+                        data_dict = json.load(f)
+                    df = pd.DataFrame.from_dict(data_dict, orient='index')
+                    df.index = pd.to_datetime(df.index)
+                    return df
+                except Exception as e:
+                    self.logger.warning(f"Error reading revenue cache: {e}")
+        
+        try:
+            self.logger.debug(f"Attempting to fetch revenue data from yfinance for {ticker}.")
+            # Try yfinance first
+            stock = yf.Ticker(ticker)
+            financials = stock.financials
+            
+            if not financials.empty:
+                self.logger.debug(f"Successfully fetched revenue data from yfinance for {ticker}.")
+                revenue_data = financials.loc['Total Revenue'].to_frame('Revenue')
+                revenue_data.index = pd.to_datetime(revenue_data.index)
+                
+                # Cache the data
+                self._cache_data(revenue_data, cache_path)
+                return revenue_data
+            else:
+                self.logger.info(f"No revenue data from yfinance for {ticker}.")
+                return None
+            
+        except requests.exceptions.RequestException as req_e:
+            if isinstance(req_e, requests.exceptions.HTTPError) and req_e.response.status_code == 429:
+                self.logger.error(f"Yfinance rate limit hit for {ticker}: {req_e}")
+                raise YFinanceRateLimitError(f"Yfinance rate limit hit for {ticker}. Please try again in an hour.")
+            else:
+                self.logger.error(f"Network or API error fetching revenue data from yfinance for {ticker}: {req_e}")
+                return None
+        except json.JSONDecodeError as json_e:
+            self.logger.error(f"JSON decoding error for revenue data from yfinance for {ticker}: {json_e}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Unexpected error fetching revenue data from yfinance: {e}")
+            return None
+    
+    def get_fcf_history(self, ticker):
+        """Get historical free cash flow data."""
+        cache_path = self.config.get_cache_path(ticker, "fcf")
+        
+        # Try to get from cache first
+        if os.path.exists(cache_path):
+            cache_age = time.time() - os.path.getmtime(cache_path)
+            if cache_age < self.config.cache_expiry:
+                try:
+                    with open(cache_path, 'r') as f:
+                        data_dict = json.load(f)
+                    df = pd.DataFrame.from_dict(data_dict, orient='index')
+                    df.index = pd.to_datetime(df.index)
+                    return df
+                except Exception as e:
+                    self.logger.warning(f"Error reading FCF cache: {e}")
+        
+        try:
+            self.logger.debug(f"Attempting to fetch FCF data from yfinance for {ticker}.")
+            stock = yf.Ticker(ticker)
+            cash_flow = stock.cashflow
+            
+            if not cash_flow.empty:
+                self.logger.debug(f"Successfully fetched FCF data from yfinance for {ticker}.")
+                fcf_data = cash_flow.loc['Free Cash Flow'].to_frame('FCF')
+                fcf_data.index = pd.to_datetime(fcf_data.index)
+                
+                # Cache the data
+                self._cache_data(fcf_data, cache_path)
+                return fcf_data
+            else:
+                self.logger.info(f"No FCF data from yfinance for {ticker}.")
+                return None
+            
+        except requests.exceptions.RequestException as req_e:
+            if isinstance(req_e, requests.exceptions.HTTPError) and req_e.response.status_code == 429:
+                self.logger.error(f"Yfinance rate limit hit for {ticker}: {req_e}")
+                raise YFinanceRateLimitError(f"Yfinance rate limit hit for {ticker}. Please try again in an hour.")
+            else:
+                self.logger.error(f"Network or API error fetching FCF data from yfinance for {ticker}: {req_e}")
+                return None
+        except json.JSONDecodeError as json_e:
+            self.logger.error(f"JSON decoding error for FCF data from yfinance for {ticker}: {json_e}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Unexpected error fetching FCF data from yfinance: {e}")
+            return None
+    
+    def get_shares_history(self, ticker):
+        """Get historical shares outstanding data."""
+        cache_path = self.config.get_cache_path(ticker, "shares")
+        
+        # Try to get from cache first
+        if os.path.exists(cache_path):
+            cache_age = time.time() - os.path.getmtime(cache_path)
+            if cache_age < self.config.cache_expiry:
+                try:
+                    with open(cache_path, 'r') as f:
+                        data_dict = json.load(f)
+                    df = pd.DataFrame.from_dict(data_dict, orient='index')
+                    df.index = pd.to_datetime(df.index)
+                    return df
+                except Exception as e:
+                    self.logger.warning(f"Error reading shares cache: {e}")
+        
+        try:
+            self.logger.debug(f"Attempting to fetch shares data from yfinance for {ticker}.")
+            stock = yf.Ticker(ticker)
+            balance_sheet = stock.balance_sheet
+            
+            if not balance_sheet.empty:
+                self.logger.debug(f"Successfully fetched shares data from yfinance for {ticker}.")
+                shares_data = balance_sheet.loc['Common Stock'].to_frame('Shares')
+                shares_data.index = pd.to_datetime(shares_data.index)
+                
+                # Cache the data
+                self._cache_data(shares_data, cache_path)
+                return shares_data
+            else:
+                self.logger.info(f"No shares data from yfinance for {ticker}.")
+                return None
+            
+        except requests.exceptions.RequestException as req_e:
+            if isinstance(req_e, requests.exceptions.HTTPError) and req_e.response.status_code == 429:
+                self.logger.error(f"Yfinance rate limit hit for {ticker}: {req_e}")
+                raise YFinanceRateLimitError(f"Yfinance rate limit hit for {ticker}. Please try again in an hour.")
+            else:
+                self.logger.error(f"Network or API error fetching shares data from yfinance for {ticker}: {req_e}")
+                return None
+        except json.JSONDecodeError as json_e:
+            self.logger.error(f"JSON decoding error for shares data from yfinance for {ticker}: {json_e}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Unexpected error fetching shares data from yfinance: {e}")
+            return None
+    
+    def _scrape_revenue_data(self, ticker):
+        """Scrape revenue data from alternative sources."""
+        self.logger.info(f"Attempting to scrape revenue data from Macrotrends for {ticker}.")
+        try:
+            # Example: Scrape from Macrotrends
+            url = f"https://www.macrotrends.net/stocks/charts/{ticker}/revenue"
+            response = requests.get(url)
+            response.raise_for_status() # Raise an HTTPError for bad responses
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Extract revenue data from the page
+            # Note: This is a placeholder. You'll need to implement the actual scraping logic
+            # based on the website's structure
+            self.logger.warning(f"Macrotrends scraping for {ticker} is a placeholder and not fully implemented.")
+            return None
+            
+        except requests.exceptions.RequestException as req_e:
+            self.logger.error(f"Network or HTTP error scraping revenue data from Macrotrends for {ticker}: {req_e}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error scraping revenue data from Macrotrends for {ticker}: {e}")
+            return None
+    
+    def _cache_data(self, data, cache_path):
+        """Cache data to file."""
+        try:
+            os.makedirs(os.path.dirname(cache_path), exist_ok=True)
+            # Convert Timestamp index to string before saving to JSON
+            data_to_save = data.copy()
+            data_to_save.index = data_to_save.index.astype(str)
+            with open(cache_path, 'w') as f:
+                json.dump(data_to_save.to_dict(orient='index'), f)
+        except Exception as e:
+            self.logger.warning(f"Error caching data: {e}")
+    
+    def clear_cache(self, ticker=None):
+        """Clear cached data for a ticker or all tickers."""
+        try:
+            if ticker:
+                patterns = [
+                    self.config.get_cache_path(ticker, "revenue"),
+                    self.config.get_cache_path(ticker, "fcf"),
+                    self.config.get_cache_path(ticker, "shares")
+                ]
+            else:
+                patterns = [self.config.cache_dir]
+            
+            for pattern in patterns:
+                if os.path.exists(pattern):
+                    if os.path.isfile(pattern):
+                        os.remove(pattern)
+                    else:
+                        for file in os.listdir(pattern):
+                            os.remove(os.path.join(pattern, file))
+            
+        except Exception as e:
+            self.logger.error(f"Error clearing cache: {e}") 

backend/llm_service.py

@@ -0,0 +1,143 @@
+import modal
+import os
+import json
+import urllib.request
+import traceback
+
+# Define a Modal App
+# You can give it a more specific name if you like, e.g., "buffetbot-llm-service"
+app = modal.App("buffetbot-llm")
+
+@app.function(
+    secrets=[modal.Secret.from_name("buffetbot-vllm-config")],
+    gpu="H100:1",  # Add GPU specification
+    timeout=1500  # Increased timeout to 25 minutes
+)
+def generate_llm_response(prompt: str, system_message: str) -> str:
+    """Generates a response using our deployed vLLM service."""
+    print(f"Received prompt for LLM: {prompt[:200]}...") # Log the prompt for debugging
+
+    # Get the URL of our deployed vLLM service
+    vllm_url = os.environ.get("VLLM_SERVICE_URL")
+    if not vllm_url:
+        raise ValueError("VLLM_SERVICE_URL environment variable not set")
+
+    # Prepare the request with system message for better context
+    messages = [
+        {
+            "role": "system",
+            "content": "You are BuffetBot, a concise stock analyst. Provide clear recommendations based on key metrics and economic moat. Use 'BuffetBot recommends'."
+        },
+        {"role": "user", "content": prompt}
+    ]
+    
+    headers = {
+        "Authorization": f"Bearer {os.environ['API_KEY']}",
+        "Content-Type": "application/json",
+    }
+    payload = json.dumps({
+        "messages": messages,
+        "model": "neuralmagic/Meta-Llama-3.1-8B-Instruct-quantized.w4a16",
+        "temperature": 0.3,  # Lower temperature for more focused responses
+        "max_tokens": 500,   # Reduce max tokens for faster responses
+        "top_p": 0.9,        # Add top_p for better quality/speed balance
+        "frequency_penalty": 0.0,  # Add frequency penalty to reduce repetition
+        "presence_penalty": 0.0    # Add presence penalty to encourage diversity
+    })
+
+    # Make the request to our vLLM service
+    req = urllib.request.Request(
+        f"{vllm_url}/v1/chat/completions",
+        data=payload.encode("utf-8"),
+        headers=headers,
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=1200) as response:  # Increased timeout to 20 minutes
+            result = json.loads(response.read().decode())
+            return result["choices"][0]["message"]["content"]
+    except Exception as e:
+        traceback.print_exc()
+        print(f"Error calling vLLM service: {str(e)}")
+        # Fallback to a simple response if the LLM service fails
+        return "I apologize, but I'm having trouble accessing the LLM service at the moment. Please try again later."
+
+@app.local_entrypoint()
+def main():
+    # Test with a prompt similar to what stock_analyzer.py sends
+    test_prompt = """
+As an AI-powered stock analyst, provide a comprehensive investment insight for AAPL. Focus on explaining what the key numbers mean, how the financial health and growth metrics contribute to the overall picture, and the significance of its economic moat.
+
+Company Name: Apple Inc.
+Sector: Technology
+Industry: Consumer Electronics
+Full-time Employees: 161000
+
+## Current Market Status
+- Current Price: $170.00
+- 52 Week High: $180.00
+- 52 Week Low: $120.00
+- Market Cap: $2,600,000,000,000.00
+
+## Key Valuation Metrics
+- P/E Ratio: 28.0
+- Forward P/E: 26.0
+- PEG Ratio: 2.1
+- Dividend Yield: 0.5%
+
+## Growth and Profitability
+- Revenue Growth (YoY): 0.05
+- Profit Margins: 0.25
+- Operating Margins: 0.30
+
+## Financial Health Indicators
+- Current Ratio: 1.2
+- Debt to Equity: 1.5
+- Return on Equity: 1.5
+- Debt to Asset Ratio: 0.45
+
+#### Recent Financials (Latest Available)
+- Latest Revenue: $90,000,000,000.00
+- Latest Free Cash Flow: $25,000,000,000.00
+- Latest Shares Outstanding: 15,500,000,000.00
+
+#### Key Balance Sheet Items
+- Total Assets: $350,000,000,000.00
+- Total Liabilities: $250,000,000,000.00
+- Total Debt: $100,000,000,000.00
+- Total Cash: $50,000,000,000.00
+- Total Equity: $100,000,000,000.00
+- Debt to Equity: 1.0
+
+#### Key Income Statement Items
+- Gross Profits: $40,000,000,000.00
+- Operating Income: $30,000,000,000.00
+- Net Income: $20,000,000,000.00
+- Earnings Growth (YoY): 0.08
+
+## Economic Moat Analysis
+Moat Rating: Wide Moat
+
+Based on the detailed financial data and moat analysis provided above, give a comprehensive, easy-to-understand summary of the investment potential of AAPL. Explain the significance of key numbers and their implications. Conclude with a clear overall sentiment regarding investment potential.
+"""
+    print(f"Testing LLM with prompt: {test_prompt[:100]}...")
+    response = generate_llm_response.remote(test_prompt, "You are a professional stock analyst providing clear, concise, and accurate investment analysis. Focus on explaining the numbers and their implications. Avoid any garbled or unclear text.")
+    print(f"LLM Response: {response}")
+
+    # Test with a simple prompt that includes the stock data
+    simple_prompt = """
+Based on the following data for Apple Inc. (AAPL), summarize the key investment considerations:
+
+Company: Apple Inc. (AAPL)
+Current Price: $170.00
+P/E Ratio: 28.0
+Revenue Growth: 5%
+Profit Margin: 25%
+Moat Rating: Wide Moat
+
+Please provide a concise summary of the investment considerations.
+"""
+    print(f"Testing LLM with simple prompt: {simple_prompt[:100]}...")
+    response_simple = generate_llm_response.remote(simple_prompt, "You are a professional stock analyst providing clear, concise, and accurate investment analysis. Focus on explaining the numbers and their implications. Avoid any garbled or unclear text.")
+    print(f"LLM Response (simple): {response_simple}") 

backend/mcp_server.py

@@ -0,0 +1,103 @@
+from typing import Dict, Any, Optional
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import uvicorn
+import traceback
+import logging
+import modal # Import modal
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+from .stock_analyzer import StockAnalyzer
+from .data_collector import StockDataCollector
+
+class StockAnalysisRequest(BaseModel):
+    """Request model for stock analysis."""
+    ticker: str
+
+class StockAnalysisResponse(BaseModel):
+    """Response model for stock analysis."""
+    analysis: str
+    revenue_chart: Optional[str] = None
+    fcf_chart: Optional[str] = None
+    shares_chart: Optional[str] = None
+
+class MCPStockServer:
+    """MCP server implementation for stock analysis tools."""
+    
+    def __init__(self):
+        self.app = FastAPI(title="BuffetBot MCP Server")
+        self.stock_analyzer = StockAnalyzer()
+        self.data_collector = StockDataCollector()
+        
+        # Register routes
+        self.app.post("/analyze", response_model=StockAnalysisResponse)(self.analyze_stock)
+        self.app.get("/health")(self.health_check)
+        self.app.get("/test_llm_connection")(self.test_llm_connection)
+    
+    async def analyze_stock(self, request: StockAnalysisRequest) -> StockAnalysisResponse:
+        """
+        Analyze a stock and return the results.
+        
+        Args:
+            request: StockAnalysisRequest containing the ticker
+            
+        Returns:
+            StockAnalysisResponse containing the analysis results
+        """
+        logger.info(f"Received analysis request for ticker: {request.ticker}")
+        try:
+            # Get analysis
+            analysis_result = self.stock_analyzer.analyze(request.ticker)
+            
+            logger.info(f"Analysis result for {request.ticker}: {analysis_result}")
+
+            return StockAnalysisResponse(
+                analysis=analysis_result["analysis"],
+                revenue_chart=analysis_result["revenue_chart"],
+                fcf_chart=analysis_result["fcf_chart"],
+                shares_chart=analysis_result["shares_chart"]
+            )
+            
+        except Exception as e:
+            traceback.print_exc()
+            raise HTTPException(status_code=500, detail=f"Internal Server Error during analysis: {str(e)}")
+    
+    async def health_check(self) -> Dict[str, str]:
+        """Health check endpoint."""
+        return {"status": "healthy"}
+
+    async def test_llm_connection(self) -> Dict[str, str]:
+        """Test connection to the Modal LLM service."""
+        logger.info("Testing LLM connection...")
+        try:
+            generate_llm_response_modal = modal.Function.from_name("buffetbot-llm", "generate_llm_response")
+            # Attempt to call the LLM service with a minimal prompt
+            test_prompt = "Hello"
+            test_system_message = "You are a helpful assistant."
+            response = await generate_llm_response_modal.remote.aio(
+                system_message=test_system_message,
+                prompt=test_prompt
+            )
+            if response:
+                logger.info(f"LLM test response (first 50 chars): {response[:50]}...")
+                return {"status": "LLM connected successfully!", "response_snippet": response[:100]}
+            else:
+                return {"status": "LLM connection failed: Empty response.", "response_snippet": ""}
+        except Exception as e:
+            logger.error(f"Error testing LLM connection: {e}", exc_info=True)
+            raise HTTPException(status_code=500, detail=f"Error testing LLM connection: {str(e)}")
+    
+    def run(self, host: str = "0.0.0.0", port: int = 8000):
+        """Run the MCP server."""
+        uvicorn.run(self.app, host=host, port=port)
+
+# def main():
+#     """Main entry point for the MCP server."""
+#     server = MCPStockServer()
+#     server.run()
+
+# if __name__ == "__main__":
+#     main() 

backend/moat_analyzer.py

@@ -0,0 +1,200 @@
+"""
+Moat Analysis Module for BuffetBot
+
+This module implements Warren Buffett's concept of economic moats to analyze
+a company's competitive advantages and long-term sustainability.
+"""
+
+import yfinance as yf
+import pandas as pd
+from typing import Dict, Any, List, Tuple
+
+class MoatAnalyzer:
+    """Analyzes a company's economic moat using various financial metrics."""
+    
+    def __init__(self):
+        self.moat_indicators = {
+            'brand_power': ['enterpriseValue'],
+            'network_effects': ['totalRevenue', 'totalAssets', 'totalCash'],
+            'cost_advantages': ['grossProfits', 'operatingMargins'],
+            'switching_costs': ['currentRatio', 'totalCurrentAssets', 'totalCurrentLiabilities'],
+            'intangible_assets': ['goodWill', 'intangibleAssets', 'totalAssets', 'totalCash']
+        }
+    
+    # Helper function to format numbers or return 'N/A'
+    def _format_num(self, value):
+        return f'{value:,.2f}' if isinstance(value, (int, float)) else str(value)
+    
+    def analyze_moat(self, ticker: str) -> Dict[str, Any]:
+        """
+        Analyze a company's economic moat.
+        
+        Args:
+            ticker: Stock ticker symbol
+            
+        Returns:
+            A dictionary containing the markdown summary and the moat rating (Wide, Narrow, Medium).
+        """
+        try:
+            stock = yf.Ticker(ticker)
+            info = stock.info
+            
+            # Get financial metrics
+            metrics = self._get_financial_metrics(info)
+            
+            # Analyze each moat component
+            moat_analysis = self._analyze_moat_components(metrics)
+            
+            # Generate summary and get moat rating
+            summary, moat_rating = self._generate_summary(ticker, moat_analysis)
+            
+            return {"summary": summary, "rating": moat_rating}
+            
+        except Exception as e:
+            return {"summary": f"Error analyzing moat: {str(e)}", "rating": "N/A"}
+    
+    def _get_financial_metrics(self, info: Dict[str, Any]) -> Dict[str, float]:
+        """Extract relevant financial metrics from stock info, ensuring all expected keys are present."""
+        metrics = {}
+        all_indicators = set()
+        for indicators_list in self.moat_indicators.values():
+            all_indicators.update(indicators_list)
+
+        for indicator in all_indicators:
+            metrics[indicator] = info.get(indicator, 0) # Ensure key is present, default to 0
+
+        return metrics
+    
+    def _analyze_moat_components(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze each component of the economic moat."""
+        analysis = {
+            'brand_power': self._analyze_brand_power(metrics),
+            'network_effects': self._analyze_network_effects(metrics),
+            'cost_advantages': self._analyze_cost_advantages(metrics),
+            'switching_costs': self._analyze_switching_costs(metrics),
+            'intangible_assets': self._analyze_intangible_assets(metrics)
+        }
+        
+        return analysis
+    
+    def _analyze_brand_power(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze brand power and market position."""
+        enterprise_value = metrics.get('enterpriseValue', 0)
+        
+        if enterprise_value > 100_000_000_000: # Example threshold for large company
+            score = 7
+            description = "Large enterprise value, indicating significant market presence."
+        elif enterprise_value > 10_000_000_000:
+            score = 4
+            description = "Moderate enterprise value, suggesting established presence."
+        else:
+            score = 1
+            description = "Smaller enterprise value, brand power may be limited or hard to quantify."
+            
+        return {
+            'score': score,
+            'description': description
+        }
+    
+    def _analyze_network_effects(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze network effects and scale advantages."""
+        assets = metrics.get('totalAssets', metrics.get('totalCash', 0)) # Use totalCash as fallback
+        revenue = metrics.get('totalRevenue', 0)
+        
+        asset_turnover = revenue / assets if assets else 0
+        
+        return {
+            'score': min(asset_turnover * 5, 10),
+            'description': f"Asset turnover ratio (using assets or cash as proxy): {self._format_num(asset_turnover)}"
+        }
+    
+    def _analyze_cost_advantages(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze cost advantages and operational efficiency."""
+        gross_profits = metrics.get('grossProfits', 0)
+        operating_margins = metrics.get('operatingMargins', 0)
+        
+        score = min(operating_margins * 10, 10)
+        
+        return {
+            'score': score,
+            'description': f"Operating profit margin: {self._format_num(operating_margins)}%"
+        }
+    
+    def _analyze_switching_costs(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze customer switching costs."""
+        current_assets = metrics.get('totalCurrentAssets', 0)
+        current_liabilities = metrics.get('totalCurrentLiabilities', 0)
+        current_ratio = metrics.get('currentRatio', 0)
+
+        # Prefer using current ratio if available, otherwise calculate from assets/liabilities
+        if current_ratio > 0:
+            working_capital_ratio_description = f"Current Ratio: {self._format_num(current_ratio)}"
+            score = min(current_ratio * 3, 10) # Scale current ratio to a score
+        else:
+            working_capital = current_assets - current_liabilities
+            working_capital_ratio = working_capital / current_assets if current_assets else 0
+            working_capital_ratio_description = f"Working capital ratio: {self._format_num(working_capital_ratio)}"
+            score = min(working_capital_ratio * 10, 10)
+        
+        return {
+            'score': score,
+            'description': working_capital_ratio_description
+        }
+    
+    def _analyze_intangible_assets(self, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze intangible assets and intellectual property."""
+        goodwill = metrics.get('goodWill', 0)
+        intangibles = metrics.get('intangibleAssets', 0)
+        total_assets = metrics.get('totalAssets', metrics.get('totalCash', 1)) # Fallback to totalCash
+        
+        # If no direct intangible assets, assign a baseline score
+        if goodwill == 0 and intangibles == 0:
+            score = 1 # Minimal score if no direct intangible assets are reported
+            description = "Direct intangible assets data not available, minimal score assigned."
+        else:
+            intangible_ratio = (goodwill + intangibles) / total_assets
+            score = min(intangible_ratio * 10, 10)
+            description = f"Intangible assets ratio: {self._format_num(intangible_ratio)}%"
+        
+        return {
+            'score': score,
+            'description': description
+        }
+    
+    def _generate_summary(self, ticker: str, moat_analysis: Dict[str, Any]) -> Tuple[str, str]:
+        """Generate a summary of the moat analysis."""
+        total_score = sum(component['score'] for component in moat_analysis.values()) / len(self.moat_indicators)
+        
+        # Determine moat rating based on total_score
+        moat_rating = "Developing"
+        if total_score >= 7.5: # Adjusted threshold for 'wide'
+            moat_rating = "Wide"
+        elif total_score >= 4.5: # Adjusted threshold for 'narrow'
+            moat_rating = "Narrow"
+        else:
+            moat_rating = "Medium"
+            
+        summary = f"""
+### Key Moat Components:
+
+1. **Brand Power**
+   - {moat_analysis['brand_power']['description']}
+
+2. **Network Effects**
+   - {moat_analysis['network_effects']['description']}
+
+3. **Cost Advantages**
+   - {moat_analysis['cost_advantages']['description']}
+
+4. **Switching Costs**
+   - {moat_analysis['switching_costs']['description']}
+
+5. **Intangible Assets**
+   - {moat_analysis['intangible_assets']['description']}
+
+### What this means:
+This analysis helps understand the company's competitive advantages. A wider moat generally suggests a more durable business and potential for long-term success. Consider these points in your overall investment research.
+
+*Note: This analysis is based on available financial data and should be used as one of many factors in investment decisions.*
+"""
+        return summary, moat_rating 

backend/stock_analyzer.py

@@ -0,0 +1,387 @@
+import yfinance as yf
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.io as pio
+from datetime import datetime, timedelta
+import json
+import os
+import modal
+import logging
+import requests
+from typing import Dict, Any
+
+# DEBUG: Print modal module path and version
+print(f"DEBUG: modal module loaded from: {modal.__file__}")
+print(f"DEBUG: modal version: {modal.__version__}")
+
+from .data_collector import StockDataCollector, YFinanceRateLimitError
+from .moat_analyzer import MoatAnalyzer
+from .config import AppConfig
+
+class StockAnalyzer:
+    """Handles stock analysis and visualization."""
+    
+    def __init__(self):
+        self.config = AppConfig()
+        self.data_collector = StockDataCollector()
+        self.moat_analyzer = MoatAnalyzer()
+        self._setup_logging()
+    
+    # Helper function to format numbers or return 'N/A'
+    def _format_num(self, value):
+        """Helper to format numbers, handling N/A gracefully."""
+        if isinstance(value, (int, float)):
+            return f"{value:,.2f}"
+        return "N/A"
+    
+    def _setup_logging(self):
+        """Setup logging configuration."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        self.logger = logging.getLogger(__name__)
+    
+    def analyze(self, ticker):
+        """Analyze a stock and return the analysis results."""
+        try:
+            stock = yf.Ticker(ticker)
+            info = stock.info
+            if not info or not info.get('regularMarketPrice'): # Check for essential info
+                return {"analysis": f"Could not retrieve comprehensive stock information for {ticker}. Please check the ticker symbol and try again.", "revenue_chart": None, "fcf_chart": None, "shares_chart": None}
+
+            # Initialize variables to None or default empty values
+            latest_revenue = 'N/A'
+            latest_fcf = 'N/A'
+            latest_shares = 'N/A'
+            latest_bs_data = {}
+            latest_is_data = {}
+            moat_summary_text = 'N/A'
+            moat_rating = 'N/A'
+            llm_insights = "AI insights temporarily unavailable."
+            serper_results_str = ""
+            revenue_chart_json = None
+            fcf_chart_json = None
+            shares_chart_json = None
+
+            # Collect data for charts and LLM
+            revenue_data = self.data_collector.get_revenue_history(ticker)
+            fcf_data = self.data_collector.get_fcf_history(ticker)
+            shares_data = self.data_collector.get_shares_history(ticker)
+
+            # Generate charts
+            revenue_chart = self._create_revenue_chart(revenue_data)
+            fcf_chart = self._create_fcf_chart(fcf_data)
+            shares_chart = self._create_shares_chart(shares_data)
+            
+            # Convert Plotly figures to JSON strings
+            revenue_chart_json = pio.to_json(revenue_chart) if revenue_chart else None
+            fcf_chart_json = pio.to_json(fcf_chart) if fcf_chart else None
+            shares_chart_json = pio.to_json(shares_chart) if shares_chart else None
+
+            # Safely get latest values with proper error handling
+            if revenue_data is not None and not revenue_data.empty:
+                latest_revenue = revenue_data.iloc[-1]['Revenue']
+            if fcf_data is not None and not fcf_data.empty:
+                latest_fcf = fcf_data.iloc[-1]['FCF']
+            if shares_data is not None and not shares_data.empty:
+                latest_shares = shares_data.iloc[-1]['Shares']
+
+            # Attempt to get full balance sheet and income statement data
+            balance_sheet = stock.balance_sheet
+            income_statement = stock.financials
+
+            # Extract relevant recent quarterly/annual data (handle potential empty dataframes)
+            if balance_sheet is not None and not balance_sheet.empty:
+                latest_bs_data = balance_sheet.iloc[:, 0].to_dict()
+            if income_statement is not None and not income_statement.empty:
+                latest_is_data = income_statement.iloc[:, 0].to_dict()
+
+            # Get moat analysis
+            moat_analyzer = MoatAnalyzer()
+            moat_analysis_results = moat_analyzer.analyze_moat(ticker)
+            moat_summary_text = moat_analysis_results["summary"]
+            moat_rating = moat_analysis_results["rating"]
+            
+            try:
+                # Look up the deployed Modal LLM app and get the remote function here
+                generate_llm_response_modal = modal.Function.from_name("buffetbot-llm", "generate_llm_response")
+
+                # Perform Serper search for moat articles
+                data_collector = StockDataCollector()
+                moat_search_results = data_collector._perform_serper_search(f"{ticker} economic moat analysis articles")
+                
+                # Format Serper search results
+                serper_results_str = ""
+                if moat_search_results:
+                    serper_results_str = "\n\n#### External Moat Analysis (Web Search)\n" + "\n".join([
+                        f"- **{r['title']}** (Source: {r['link']})\n  Snippet: {r['snippet']}"
+                        for r in moat_search_results
+                    ])
+                
+                # Get additional comprehensive data for LLM prompt
+                revenue_data = data_collector.get_revenue_history(ticker)
+                fcf_data = data_collector.get_fcf_history(ticker)
+                shares_data = data_collector.get_shares_history(ticker)
+
+                # Generate charts
+                revenue_chart = self._create_revenue_chart(revenue_data)
+                fcf_chart = self._create_fcf_chart(fcf_data)
+                shares_chart = self._create_shares_chart(shares_data)
+                
+                # Convert Plotly figures to JSON strings
+                revenue_chart_json = pio.to_json(revenue_chart) if revenue_chart else None
+                fcf_chart_json = pio.to_json(fcf_chart) if fcf_chart else None
+                shares_chart_json = pio.to_json(shares_chart) if shares_chart else None
+
+                # Safely get latest values with proper error handling
+                if revenue_data is not None and not revenue_data.empty:
+                    latest_revenue = revenue_data.iloc[-1]['Revenue']
+                if fcf_data is not None and not fcf_data.empty:
+                    latest_fcf = fcf_data.iloc[-1]['FCF']
+                if shares_data is not None and not shares_data.empty:
+                    latest_shares = shares_data.iloc[-1]['Shares']
+
+                # Attempt to get full balance sheet and income statement data
+                balance_sheet = stock.balance_sheet
+                income_statement = stock.financials
+
+                # Extract relevant recent quarterly/annual data (handle potential empty dataframes)
+                if balance_sheet is not None and not balance_sheet.empty:
+                    latest_bs_data = balance_sheet.iloc[:, 0].to_dict()
+                if income_statement is not None and not income_statement.empty:
+                    latest_is_data = income_statement.iloc[:, 0].to_dict()
+
+                # Format detailed financial data for the LLM prompt
+                financial_data_str = f"""
+#### Recent Financials (Latest Available)
+- Latest Revenue: {self._format_num(latest_revenue)}
+- Latest Free Cash Flow: {self._format_num(latest_fcf)}
+- Latest Shares Outstanding: {self._format_num(latest_shares)}
+
+#### Key Balance Sheet Items
+- Total Assets: {self._format_num(latest_bs_data.get('Total Assets', 'N/A'))}
+- Total Liabilities: {self._format_num(latest_bs_data.get('Total Liabilities', 'N/A'))}
+- Total Debt: {self._format_num(info.get('totalDebt', 'N/A'))}
+- Total Cash: {self._format_num(info.get('totalCash', 'N/A'))}
+- Total Equity: {self._format_num(latest_bs_data.get('Total Equity', 'N/A'))}
+- Debt to Equity: {self._format_num(info.get('debtToEquity', 'N/A'))}
+
+#### Key Income Statement Items
+- Gross Profits: {self._format_num(latest_is_data.get('Gross Profit', 'N/A'))}
+- Operating Income: {self._format_num(latest_is_data.get('Operating Income', 'N/A'))}
+- Net Income: {self._format_num(latest_is_data.get('Net Income', 'N/A'))}
+- Earnings Growth (YoY): {self._format_num(info.get('earningsQuarterlyGrowth', 'N/A'))}%
+"""
+
+                # Ensure the LLM knows to use BuffetBot's persona and clearly mark AI insights
+                system_message = """
+As an AI-powered stock analyst named BuffetBot, your goal is to provide concise, clear, and actionable investment insights. When giving recommendations, state "BuffetBot recommends" instead of "I recommend". Clearly mark your analysis as "AI Insights:" at the beginning of your comprehensive insight. Focus on explaining key numbers, financial health, growth metrics, economic moat significance, and overall investment potential. Do not include "What to look for" sections for charts or specific metrics, as these will be provided separately. Avoid garbled text or incomplete sentences.
+"""
+
+                llm_prompt = self._generate_llm_prompt(ticker, {
+                    'info': info,
+                    'moat_summary': moat_summary_text,
+                    'serper_results': serper_results_str,
+                    'financial_data_str': financial_data_str
+                })
+
+                llm_insights = generate_llm_response_modal.remote(
+                    system_message=system_message,
+                    prompt=llm_prompt
+                )
+            except Exception as llm_e:
+                self.logger.warning(f"Could not get LLM insights for {ticker}: {llm_e}")
+                llm_insights = "AI insights temporarily unavailable. Please ensure Modal LLM service is deployed and accessible and Modal API keys are set as Hugging Face Space secrets."
+
+            # Generate analysis text
+            analysis = self._generate_analysis(ticker, info, moat_summary_text, moat_rating, llm_insights, latest_bs_data, latest_is_data, latest_revenue, latest_fcf, latest_shares)
+            
+            return {
+                "analysis": analysis,
+                "revenue_chart": revenue_chart_json,
+                "fcf_chart": fcf_chart_json,
+                "shares_chart": shares_chart_json
+            }
+            
+        except YFinanceRateLimitError as e:
+            self.logger.error(f"Yfinance rate limit hit for {ticker}: {e}")
+            return {"analysis": f"Error analyzing stock: {e}. Charts may be unavailable.", "revenue_chart": None, "fcf_chart": None, "shares_chart": None}
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 429:
+                # This case should now be handled by YFinanceRateLimitError
+                self.logger.error(f"Unexpected 429 HTTP Error for {ticker}: {e}")
+                return {"analysis": f"Error analyzing stock: You have been rate-limited by Yahoo Finance. Please wait a few minutes and try again. Charts may be unavailable.", "revenue_chart": None, "fcf_chart": None, "shares_chart": None}
+            else:
+                self.logger.error(f"HTTP error fetching data for {ticker}: {e}")
+                return {"analysis": f"Error analyzing stock: An HTTP error occurred: {e}. Charts may be unavailable.", "revenue_chart": None, "fcf_chart": None, "shares_chart": None}
+        except Exception as e:
+            self.logger.error(f"Error analyzing stock {ticker}: {e}", exc_info=True) # Log full traceback
+            return {"analysis": f"An unexpected error occurred while analyzing {ticker}: {str(e)}. Charts may be unavailable.", "revenue_chart": None, "fcf_chart": None, "shares_chart": None}
+    
+    def _create_revenue_chart(self, revenue_data):
+        """Create revenue growth chart."""
+        if revenue_data is None or revenue_data.empty:
+            return None
+            
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=revenue_data.index,
+            y=revenue_data['Revenue'],
+            mode='lines+markers',
+            name='Revenue'
+        ))
+        
+        fig.update_layout(
+            title='Revenue Growth',
+            xaxis_title='Year',
+            yaxis_title='Revenue (USD)',
+            template='plotly_white'
+        )
+        
+        return fig
+    
+    def _create_fcf_chart(self, fcf_data):
+        """Create free cash flow chart."""
+        if fcf_data is None or fcf_data.empty:
+            return None
+            
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=fcf_data.index,
+            y=fcf_data['FCF'],
+            mode='lines+markers',
+            name='Free Cash Flow'
+        ))
+        
+        fig.update_layout(
+            title='Free Cash Flow',
+            xaxis_title='Year',
+            yaxis_title='Free Cash Flow (USD)',
+            template='plotly_white'
+        )
+        
+        return fig
+    
+    def _create_shares_chart(self, shares_data):
+        """Create shares outstanding chart."""
+        if shares_data is None or shares_data.empty:
+            return None
+            
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=shares_data.index,
+            y=shares_data['Shares'],
+            mode='lines+markers',
+            name='Shares Outstanding'
+        ))
+        
+        fig.update_layout(
+            title='Shares Outstanding',
+            xaxis_title='Year',
+            yaxis_title='Shares (millions)',
+            template='plotly_white'
+        )
+        
+        return fig
+    
+    def _generate_analysis(self, ticker, info, moat_summary, moat_rating, llm_insights, latest_bs_data, latest_is_data, latest_revenue, latest_fcf, latest_shares):
+        """Generate analysis text."""
+        data_as_of_timestamp = info.get('regularMarketTime')
+        data_as_of_date = datetime.fromtimestamp(data_as_of_timestamp).strftime('%Y-%m-%d %H:%M:%S') if data_as_of_timestamp else 'N/A'
+
+        # Initialize serper_results_str
+        serper_results_str = ""
+
+        analysis = f"""
+# {info.get('longName', ticker)} ({ticker}) Analysis
+
+*Data as of: {data_as_of_date}*
+
+## Company Overview
+- Sector: {info.get('sector', 'N/A')}
+- Industry: {info.get('industry', 'N/A')}
+- Full-time Employees: {self._format_num(info.get('fullTimeEmployees', 'N/A'))}
+
+## Current Status
+- Current Price: {self._format_num(info.get('currentPrice', 'N/A'))}
+- 52 Week High: {self._format_num(info.get('fiftyTwoWeekHigh', 'N/A'))}
+- 52 Week Low: {self._format_num(info.get('fiftyTwoWeekLow', 'N/A'))}
+- Market Cap: {self._format_num(info.get('marketCap', 'N/A'))}
+
+## Key Valuation Metrics
+- P/E Ratio: {self._format_num(info.get('trailingPE', 'N/A'))}
+- Forward P/E: {self._format_num(info.get('forwardPE', 'N/A'))}
+- PEG Ratio: {self._format_num(info.get('pegRatio', 'N/A'))}
+- Dividend Yield: {self._format_num(info.get('dividendYield', 'N/A'))}%
+
+## Growth and Profitability
+- Revenue Growth (YoY): {self._format_num(info.get('revenueGrowth', 'N/A'))}%
+- Profit Margins: {self._format_num(info.get('profitMargins', 'N/A'))}%
+- Operating Margins: {self._format_num(info.get('operatingMargins', 'N/A'))}%
+
+## Financial Health Indicators
+- Current Ratio: {self._format_num(info.get('currentRatio', 'N/A'))}
+- Debt to Equity: {self._format_num(info.get('debtToEquity', 'N/A'))}
+- Return on Equity: {self._format_num(info.get('returnOnEquity', 'N/A'))}%
+- Debt to Asset Ratio: {self._format_num(info.get('totalDebt', 0) / info.get('totalAssets', 1) if info.get('totalAssets') else 'N/A')}
+
+#### Recent Financials (Latest Available)
+- Latest Revenue: {self._format_num(latest_revenue)}
+- Latest Free Cash Flow: {self._format_num(latest_fcf)}
+- Latest Shares Outstanding: {self._format_num(latest_shares)}
+
+#### Key Balance Sheet Items
+- Total Assets: {self._format_num(latest_bs_data.get('Total Assets', 'N/A'))}
+- Total Liabilities: {self._format_num(latest_bs_data.get('Total Liabilities', 'N/A'))}
+- Total Debt: {self._format_num(info.get('totalDebt', 'N/A'))}
+- Total Cash: {self._format_num(info.get('totalCash', 'N/A'))}
+- Total Equity: {self._format_num(latest_bs_data.get('Total Equity', 'N/A'))}
+- Debt to Equity: {self._format_num(info.get('debtToEquity', 'N/A'))}
+
+#### Key Income Statement Items
+- Gross Profits: {self._format_num(latest_is_data.get('Gross Profit', 'N/A'))}
+- Operating Income: {self._format_num(latest_is_data.get('Operating Income', 'N/A'))}
+- Net Income: {self._format_num(latest_is_data.get('Net Income', 'N/A'))}
+- Earnings Growth (YoY): {self._format_num(info.get('earningsQuarterlyGrowth', 'N/A'))}%
+
+## Economic Moat Analysis
+{moat_summary}
+{serper_results_str}
+
+## AI Insights
+{llm_insights}
+"""
+        
+        return analysis 
+
+    def _generate_llm_prompt(self, ticker: str, data: Dict[str, Any]) -> str:
+        """Generate a focused prompt for the LLM."""
+        info = data.get('info', {})
+        moat_summary_text = data.get('moat_summary', 'N/A')
+        serper_results_str = data.get('serper_results', 'N/A')
+        financial_data_str = data.get('financial_data_str', 'N/A')
+
+        llm_prompt = f"""
+Analyze {ticker} ({info.get('longName', ticker)}) as an investment opportunity.
+
+Key Metrics:
+- Price: ${self._format_num(info.get('currentPrice', 'N/A'))}
+- P/E: {self._format_num(info.get('trailingPE', 'N/A'))}
+- Revenue Growth: {self._format_num(info.get('revenueGrowth', 'N/A'))}%
+- Profit Margin: {self._format_num(info.get('profitMargins', 'N/A'))}%
+- Debt/Equity: {self._format_num(info.get('debtToEquity', 'N/A'))}
+- ROE: {self._format_num(info.get('returnOnEquity', 'N/A'))}%
+
+Moat Analysis:
+{moat_summary_text}
+{serper_results_str}
+
+Provide a concise analysis focusing on:
+1. Key strengths and risks
+2. Economic moat significance
+3. Clear investment recommendation
+
+Keep your response under 200 words.
+"""
+        return llm_prompt 

modal_llm_service.py

@@ -0,0 +1,107 @@
+import modal
+
+# Define the container image with vLLM
+vllm_image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "vllm==0.7.2",
+        "huggingface_hub[hf_transfer]==0.26.2",
+        "flashinfer-python==0.2.0.post2",
+        extra_index_url="https://flashinfer.ai/whl/cu124/torch2.5",
+    )
+    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
+)
+
+# Enable vLLM V1 engine for better performance
+vllm_image = vllm_image.env({"VLLM_USE_V1": "1"})
+
+# Model configuration
+MODELS_DIR = "/llamas"
+MODEL_NAME = "neuralmagic/Meta-Llama-3.1-8B-Instruct-quantized.w4a16"
+MODEL_REVISION = "a7c09948d9a632c2c840722f519672cd94af885d"
+
+# Set up caching volumes
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+# Create Modal app
+app = modal.App("buffetbot-llm-service")
+
+# Configuration
+N_GPU = 1  # Number of GPUs to use
+API_KEY = "buffetbot-llm-key"  # We'll replace this with a Modal Secret
+MINUTES = 60
+VLLM_PORT = 8000
+
+@app.function(
+    image=vllm_image,
+    gpu=f"H100:{N_GPU}",
+    scaledown_window=15 * MINUTES,
+    timeout=10 * MINUTES,
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },
+    secrets=[modal.Secret.from_name("buffetbot-vllm-config")]
+)
+@modal.concurrent(max_inputs=100)
+@modal.web_server(port=VLLM_PORT, startup_timeout=5 * MINUTES)
+def serve():
+    import subprocess
+    import os
+
+    cmd = [
+        "vllm",
+        "serve",
+        "--uvicorn-log-level=info",
+        MODEL_NAME,
+        "--revision",
+        MODEL_REVISION,
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+        "--api-key",
+        os.environ["API_KEY"],
+    ]
+
+    subprocess.Popen(" ".join(cmd), shell=True)
+
+@app.local_entrypoint()
+def test(test_timeout=10 * MINUTES):
+    import json
+    import time
+    import urllib.request
+
+    print(f"Running health check for server at {serve.get_web_url()}")
+    up, start, delay = False, time.time(), 10
+    while not up:
+        try:
+            with urllib.request.urlopen(serve.get_web_url() + "/health") as response:
+                if response.getcode() == 200:
+                    up = True
+        except Exception:
+            if time.time() - start > test_timeout:
+                break
+            time.sleep(delay)
+
+    assert up, f"Failed health check for server at {serve.get_web_url()}"
+    print(f"Successful health check for server at {serve.get_web_url()}")
+
+    # Test with a sample prompt
+    messages = [{"role": "user", "content": "What is the economic moat of Apple Inc.?"}]
+    print(f"Sending a sample message to {serve.get_web_url()}", *messages, sep="\n")
+
+    headers = {
+        "Authorization": f"Bearer {API_KEY}",
+        "Content-Type": "application/json",
+    }
+    payload = json.dumps({"messages": messages, "model": MODEL_NAME})
+    req = urllib.request.Request(
+        serve.get_web_url() + "/v1/chat/completions",
+        data=payload.encode("utf-8"),
+        headers=headers,
+        method="POST",
+    )
+    with urllib.request.urlopen(req) as response:
+        print(json.loads(response.read().decode())) 

modal_mcp_server.py

@@ -0,0 +1,35 @@
+import modal
+import os
+from dotenv import load_dotenv
+
+# Ensure environment variables are loaded for local testing and deployment to Modal
+load_dotenv()
+
+# Define a Modal App
+# You can give it a more specific name if you like, e.g., "buffetbot-mcp-server"
+app = modal.App("buffetbot-mcp-server")
+
+# Define the Modal Image
+# This image will include all the necessary backend files and Python packages.
+# The 'backend' directory and its contents are added to the image.
+# We also install all packages from requirements.txt.
+buffetbot_image = modal.Image.debian_slim(python_version="3.10").pip_install_from_requirements("requirements.txt").add_local_dir(
+    local_path="backend",
+    remote_path="/root/backend"
+)
+
+# Import the FastAPI app from backend.mcp_server
+# This import needs to happen within the Modal image context,
+# so we import it after defining the image and copying the files.
+with buffetbot_image.imports():
+    from backend.mcp_server import MCPStockServer
+
+@app.function(image=buffetbot_image, secrets=[
+    modal.Secret.from_name("buffetbot-mcp-server-secrets"),
+    modal.Secret.from_name("buffetbot-serper-config")
+])
+@modal.asgi_app()
+def fastapi_app():
+    # Instantiate the MCPStockServer, which contains the FastAPI app
+    server = MCPStockServer()
+    return server.app 

requirements.txt

@@ -0,0 +1,13 @@
+gradio
+yfinance
+pandas
+plotly
+requests
+beautifulsoup4
+python-dotenv
+jinja2
+modal
+fastapi
+uvicorn
+pydantic
+kaleido