Upload folder using huggingface_hub

modal_backend.py

@@ -1,12 +1,15 @@
 """
 Modal Backend for Restaurant Intelligence Agent
-With Multi-Platform Scraper Support (OpenTable + Google Maps)
+With TRUE MCP Server Integration
 
-VERSION 3.0:
-1. Auto-detects URL platform
-2. Routes to appropriate scraper
-3. PDF report generation
-4. TRUE MCP Server Integration
+UPDATED: Now sends slim trend_data instead of full raw_reviews
+- Reduces response size by ~97%
+- Pre-calculates sentiment in backend
+- Fixes HuggingFace timeout issues
+
+Deploys:
+1. Analysis API endpoint
+2. MCP Server endpoint
 """
 
 import modal
@@ -29,36 +32,42 @@ image = (
         "python-dotenv",
         "matplotlib",
         "fastapi[standard]",
-        "fastmcp",
-        "reportlab",  # For PDF generation
+        "httpx",
     )
     .add_local_python_source("src")
 )
 
 
 # ============================================================================
-# URL DETECTION
+# HELPER FUNCTION - Calculate sentiment from text
 # ============================================================================
 
-def detect_platform(url: str) -> str:
-    """Detect which platform the URL is from."""
-    if not url:
-        return "unknown"
-    
-    url_lower = url.lower()
-    
-    if 'opentable' in url_lower:
-        return "opentable"
-    elif any(x in url_lower for x in ['google.com/maps', 'goo.gl/maps', 'maps.google', 'maps.app.goo.gl']):
-        return "google_maps"
-    else:
-        return "unknown"
+def calculate_sentiment(text: str) -> float:
+    """Simple sentiment calculation from review text."""
+    if not text:
+        return 0.0
+    text = str(text).lower()
+    
+    positive = ['amazing', 'excellent', 'fantastic', 'great', 'awesome', 'delicious', 
+                'perfect', 'outstanding', 'loved', 'beautiful', 'fresh', 'friendly', 
+                'best', 'wonderful', 'incredible', 'superb', 'exceptional']
+    negative = ['terrible', 'horrible', 'awful', 'bad', 'worst', 'disappointing', 
+                'poor', 'overpriced', 'slow', 'rude', 'cold', 'bland', 'mediocre',
+                'disgusting', 'inedible', 'undercooked', 'overcooked']
+    
+    pos = sum(1 for w in positive if w in text)
+    neg = sum(1 for w in negative if w in text)
+    
+    if pos + neg == 0:
+        return 0.0
+    return (pos - neg) / max(pos + neg, 1)
 
 
 # ============================================================================
 # MCP SERVER (TRUE MCP INTEGRATION)
 # ============================================================================
 
+# In-memory storage for MCP
 REVIEW_INDEX: Dict[str, List[str]] = {}
 ANALYSIS_CACHE: Dict[str, Dict[str, Any]] = {}
 
@@ -66,7 +75,9 @@ ANALYSIS_CACHE: Dict[str, Dict[str, Any]] = {}
 @app.function(image=image, timeout=300)
 @modal.asgi_app()
 def mcp_server():
-    """TRUE MCP Server - exposes tools via MCP protocol over HTTP."""
+    """
+    TRUE MCP Server - exposes tools via MCP protocol over HTTP.
+    """
     from fastapi import FastAPI, HTTPException
     from pydantic import BaseModel
     from datetime import datetime
@@ -86,6 +97,7 @@ def mcp_server():
         question: str
         top_k: int = 5
     
+    # MCP Tools
     def index_reviews(restaurant_name: str, reviews: List[str]) -> Dict[str, Any]:
         REVIEW_INDEX[restaurant_name] = reviews
         return {
@@ -112,6 +124,11 @@ def mcp_server():
             "review_count": min(top_k, len(reviews))
         }
     
+    def save_report(restaurant_name: str, report_data: Dict, report_type: str = "analysis") -> Dict[str, Any]:
+        report_id = f"{restaurant_name}_{report_type}_{datetime.now().isoformat()}"
+        ANALYSIS_CACHE[report_id] = {"restaurant": restaurant_name, "type": report_type, "data": report_data}
+        return {"success": True, "report_id": report_id}
+    
     def list_tools() -> Dict[str, Any]:
         return {
             "success": True,
@@ -124,7 +141,7 @@ def mcp_server():
     
     @mcp_api.get("/")
     async def root():
-        return {"name": "Restaurant Intelligence MCP Server", "protocol": "MCP", "version": "3.0"}
+        return {"name": "Restaurant Intelligence MCP Server", "protocol": "MCP", "version": "1.0"}
     
     @mcp_api.get("/health")
     async def health():
@@ -136,9 +153,11 @@ def mcp_server():
     
     @mcp_api.post("/mcp/call")
     async def call_tool(request: ToolRequest):
+        """TRUE MCP interface - agent calls tools via this endpoint."""
         tool_map = {
             "index_reviews": lambda args: index_reviews(args["restaurant_name"], args["reviews"]),
             "query_reviews": lambda args: query_reviews(args["restaurant_name"], args["question"], args.get("top_k", 5)),
+            "save_report": lambda args: save_report(args["restaurant_name"], args["report_data"], args.get("report_type", "analysis")),
             "list_tools": lambda args: list_tools()
         }
         
@@ -151,31 +170,40 @@ def mcp_server():
         except Exception as e:
             raise HTTPException(status_code=500, detail=str(e))
     
+    @mcp_api.post("/tools/index_reviews")
+    async def api_index_reviews(request: IndexReviewsRequest):
+        return index_reviews(request.restaurant_name, request.reviews)
+    
+    @mcp_api.post("/tools/query_reviews")
+    async def api_query_reviews(request: QueryReviewsRequest):
+        return query_reviews(request.restaurant_name, request.question, request.top_k)
+    
     return mcp_api
 
 
 # ============================================================================
-# SCRAPER FUNCTIONS
+# MAIN ANALYSIS FUNCTIONS
 # ============================================================================
 
 @app.function(image=image)
 def hello() -> Dict[str, Any]:
-    return {"status": "Modal is working!", "mcp": "enabled", "version": "3.0", "platforms": ["opentable", "google_maps"]}
+    return {"status": "Modal is working!", "mcp": "enabled"}
 
 
-@app.function(image=image, timeout=900)
+@app.function(image=image, timeout=600)
 def scrape_restaurant_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
-    """Scrape reviews - auto-detects platform."""
-    platform = detect_platform(url)
+    """Scrape reviews from OpenTable or Google Maps."""
     
-    if platform == "opentable":
+    # Detect platform
+    url_lower = url.lower()
+    if 'opentable' in url_lower:
         from src.scrapers.opentable_scraper import scrape_opentable
         result = scrape_opentable(url=url, max_reviews=max_reviews, headless=True)
-    elif platform == "google_maps":
+    elif any(x in url_lower for x in ['google.com/maps', 'goo.gl/maps', 'maps.google', 'maps.app.goo.gl']):
         from src.scrapers.google_maps_scraper import scrape_google_maps
         result = scrape_google_maps(url=url, max_reviews=max_reviews, headless=True)
     else:
-        return {"success": False, "error": f"Unsupported platform. Use OpenTable or Google Maps URL."}
+        return {"success": False, "error": "Unsupported platform. Use OpenTable or Google Maps."}
     
     if not result.get("success"):
         return {"success": False, "error": result.get("error")}
@@ -185,24 +213,21 @@ def scrape_restaurant_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
     df = process_reviews(result)
     reviews = clean_reviews_for_ai(df["review_text"].tolist(), verbose=False)
     
-    # Include raw review data
-    raw_reviews = []
+    # Create SLIM trend_data (pre-calculate sentiment, no text!)
+    trend_data = []
     for _, row in df.iterrows():
-        raw_reviews.append({
+        text = str(row.get("review_text", ""))
+        trend_data.append({
             "date": str(row.get("date", "")),
             "rating": float(row.get("overall_rating", 0) or 0),
-            "food_rating": float(row.get("food_rating", 0) or 0),
-            "service_rating": float(row.get("service_rating", 0) or 0),
-            "ambience_rating": float(row.get("ambience_rating", 0) or 0),
-            "text": str(row.get("review_text", ""))
+            "sentiment": calculate_sentiment(text)  # Pre-calculate!
         })
     
     return {
         "success": True,
-        "source": platform,
         "total_reviews": len(reviews),
         "reviews": reviews,
-        "raw_reviews": raw_reviews,
+        "trend_data": trend_data,  # Slim version, no text!
         "metadata": result.get("metadata", {}),
     }
 
@@ -213,18 +238,27 @@ def scrape_restaurant_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
     timeout=2400,
 )
 def full_analysis_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
-    """Complete end-to-end analysis with multi-platform support."""
-    platform = detect_platform(url)
+    """
+    Complete end-to-end analysis with MCP integration.
+    
+    UPDATED: Returns slim trend_data instead of full raw_reviews.
+    This reduces response size by ~97% and fixes timeout issues.
+    """
+    
+    # Detect platform
+    url_lower = url.lower()
+    platform = "opentable" if 'opentable' in url_lower else "google_maps" if any(x in url_lower for x in ['google.com/maps', 'goo.gl/maps', 'maps.google', 'maps.app.goo.gl']) else "unknown"
+    
+    if platform == "unknown":
+        return {"success": False, "error": "Unsupported platform. Use OpenTable or Google Maps."}
     
-    # Route to appropriate scraper
+    # Import scrapers
     if platform == "opentable":
         from src.scrapers.opentable_scraper import scrape_opentable
         result = scrape_opentable(url=url, max_reviews=max_reviews, headless=True)
-    elif platform == "google_maps":
+    else:
         from src.scrapers.google_maps_scraper import scrape_google_maps
         result = scrape_google_maps(url=url, max_reviews=max_reviews, headless=True)
-    else:
-        return {"success": False, "error": "Unsupported platform. Use OpenTable or Google Maps URL."}
     
     if not result.get("success"):
         return {"success": False, "error": result.get("error")}
@@ -235,16 +269,15 @@ def full_analysis_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
     df = process_reviews(result)
     reviews = clean_reviews_for_ai(df["review_text"].tolist(), verbose=False)
     
-    # Extract raw review data
-    raw_reviews = []
+    # Create SLIM trend_data (pre-calculate sentiment in backend!)
+    # This is ~97% smaller than sending full review text
+    trend_data = []
     for _, row in df.iterrows():
-        raw_reviews.append({
+        text = str(row.get("review_text", ""))
+        trend_data.append({
             "date": str(row.get("date", "")),
             "rating": float(row.get("overall_rating", 0) or 0),
-            "food_rating": float(row.get("food_rating", 0) or 0),
-            "service_rating": float(row.get("service_rating", 0) or 0),
-            "ambience_rating": float(row.get("ambience_rating", 0) or 0),
-            "text": str(row.get("review_text", ""))
+            "sentiment": calculate_sentiment(text)  # Pre-calculated!
         })
     
     # Extract restaurant name from URL
@@ -257,7 +290,7 @@ def full_analysis_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
         else:
             restaurant_name = "Restaurant"
     
-    # Analyze
+    # Run analysis
     agent = RestaurantAnalysisAgent()
     analysis = agent.analyze_restaurant(
         restaurant_url=url,
@@ -265,18 +298,23 @@ def full_analysis_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
         reviews=reviews,
     )
     
-    # Store in MCP cache
+    # Store in MCP cache for Q&A
     REVIEW_INDEX[restaurant_name] = reviews
     
-    # Add metadata
-    analysis['raw_reviews'] = raw_reviews
+    # Add slim trend_data (NOT full raw_reviews!)
+    analysis['trend_data'] = trend_data
     analysis['source'] = platform
     
+    # Log response size for debugging
+    import json
+    response_size = len(json.dumps(analysis))
+    print(f"[MODAL] Response size: {response_size / 1024:.1f} KB")
+    
     return analysis
 
 
 # ============================================================================
-# FASTAPI APP
+# FASTAPI APP (serves both analysis and MCP)
 # ============================================================================
 
 @app.function(
@@ -286,11 +324,11 @@ def full_analysis_modal(url: str, max_reviews: int = 100) -> Dict[str, Any]:
 )
 @modal.asgi_app()
 def fastapi_app():
-    """Main API with multi-platform support and MCP integration."""
+    """Main API with MCP integration."""
     from fastapi import FastAPI, HTTPException
     from pydantic import BaseModel
     
-    web_app = FastAPI(title="Restaurant Intelligence API v3.0")
+    web_app = FastAPI(title="Restaurant Intelligence API with MCP")
     
     class AnalyzeRequest(BaseModel):
         url: str
@@ -306,7 +344,7 @@ def fastapi_app():
             "name": "Restaurant Intelligence API",
             "version": "3.0",
             "mcp": "enabled",
-            "supported_platforms": ["opentable", "google_maps"],
+            "optimizations": ["slim_trend_data", "pre_calculated_sentiment"],
             "endpoints": {
                 "analyze": "/analyze",
                 "mcp_tools": "/mcp/call",
@@ -316,24 +354,17 @@ def fastapi_app():
     
     @web_app.get("/health")
     async def health():
-        return {"status": "healthy", "mcp": "enabled", "version": "3.0"}
+        return {"status": "healthy", "mcp": "enabled"}
     
     @web_app.post("/analyze")
     async def analyze(request: AnalyzeRequest):
         try:
-            # Detect platform first
-            platform = detect_platform(request.url)
-            if platform == "unknown":
-                raise HTTPException(
-                    status_code=400, 
-                    detail="Unsupported URL. Please use OpenTable or Google Maps URL."
-                )
-            
             result = full_analysis_modal.remote(url=request.url, max_reviews=request.max_reviews)
             return result
         except Exception as e:
             raise HTTPException(status_code=500, detail=str(e))
     
+    # MCP Endpoints
     @web_app.get("/mcp/tools")
     async def mcp_list_tools():
         return {
@@ -346,6 +377,8 @@ def fastapi_app():
     
     @web_app.post("/mcp/call")
     async def mcp_call(request: MCPCallRequest):
+        """TRUE MCP interface."""
+        # For now, this delegates to local functions
         if request.tool_name == "index_reviews":
             args = request.arguments
             REVIEW_INDEX[args["restaurant_name"]] = args["reviews"]
@@ -374,20 +407,20 @@ def fastapi_app():
 
 @app.local_entrypoint()
 def main():
-    print("🧪 Testing Modal deployment v3.0...\n")
+    print("🧪 Testing Modal deployment with MCP...\n")
     
     print("1️⃣ Testing connection...")
     result = hello.remote()
     print(f"✅ {result}\n")
     
-    print("2️⃣ Supported platforms:")
-    print("   • OpenTable (opentable.com)")
-    print("   • Google Maps (google.com/maps)")
-    
-    print("\n3️⃣ MCP Server deployed at:")
+    print("2️⃣ MCP Server deployed at:")
     print("   https://tushar-pingle--restaurant-intelligence-mcp-server.modal.run")
     
-    print("\n4️⃣ Analysis API deployed at:")
+    print("\n3️⃣ Analysis API deployed at:")
     print("   https://tushar-pingle--restaurant-intelligence-fastapi-app.modal.run")
     
-    print("\n✅ All endpoints ready!")
+    print("\n✅ Both endpoints ready!")
+    print("\n📊 Optimizations enabled:")
+    print("   - Slim trend_data (no full review text)")
+    print("   - Pre-calculated sentiment in backend")
+    print("   - ~97% smaller response size")

src/ui/gradio_app.py

@@ -128,41 +128,47 @@ def calculate_review_sentiment(text: str) -> float:
     return (pos - neg) / max(pos + neg, 1)
 
 
-def generate_trend_chart(raw_reviews: List[Dict], restaurant_name: str) -> Optional[str]:
-    """Generate Rating vs Sentiment trend chart."""
+def generate_trend_chart(trend_data: List[Dict], restaurant_name: str) -> Optional[str]:
+    """
+    Generate Rating vs Sentiment trend chart.
+    
+    UPDATED: Now uses pre-calculated trend_data from backend.
+    Format: [{"date": "2 days ago", "rating": 4.5, "sentiment": 0.6}, ...]
+    """
     import matplotlib
     matplotlib.use('Agg')
     import matplotlib.pyplot as plt
     import matplotlib.dates as mdates
     
-    if not raw_reviews or len(raw_reviews) < 3:
+    if not trend_data or len(trend_data) < 3:
         return None
     
     dated_reviews = []
-    for r in raw_reviews:
+    for r in trend_data:
         if not isinstance(r, dict):
             continue
         date = parse_opentable_date(r.get('date', ''))
         if date:
-            rating = float(r.get('rating', 0) or r.get('overall_rating', 0) or 0)
-            text = r.get('text', '') or r.get('review_text', '')
+            rating = float(r.get('rating', 0) or 0)
+            sentiment = float(r.get('sentiment', 0) or 0)  # Already calculated!
             dated_reviews.append({
                 'date': date,
                 'rating': rating if rating > 0 else 3.5,
-                'sentiment': calculate_review_sentiment(text)
+                'sentiment': sentiment
             })
     
-    if len(dated_reviews) < 3 and len(raw_reviews) >= 3:
+    # Fallback: if no dates parsed, use sequential ordering
+    if len(dated_reviews) < 3 and len(trend_data) >= 3:
         dated_reviews = []
-        for i, r in enumerate(raw_reviews):
+        for i, r in enumerate(trend_data):
             if not isinstance(r, dict):
                 continue
-            rating = float(r.get('rating', 0) or r.get('overall_rating', 0) or 3.5)
-            text = r.get('text', '') or r.get('review_text', '')
+            rating = float(r.get('rating', 0) or 3.5)
+            sentiment = float(r.get('sentiment', 0) or 0)
             dated_reviews.append({
                 'date': datetime.now() - timedelta(days=i),
                 'rating': rating if rating > 0 else 3.5,
-                'sentiment': calculate_review_sentiment(text)
+                'sentiment': sentiment
             })
     
     if len(dated_reviews) < 3:
@@ -246,26 +252,36 @@ def generate_trend_chart(raw_reviews: List[Dict], restaurant_name: str) -> Optio
         return None
 
 
-def generate_trend_insight(raw_reviews: List[Dict], restaurant_name: str) -> str:
-    """Generate text insight from trend data."""
-    if not raw_reviews or len(raw_reviews) < 3:
+def generate_trend_insight(trend_data: List[Dict], restaurant_name: str) -> str:
+    """
+    Generate text insight from trend data.
+    
+    UPDATED: Now uses pre-calculated trend_data from backend.
+    Format: [{"date": "...", "rating": 4.5, "sentiment": 0.6}, ...]
+    """
+    if not trend_data or len(trend_data) < 3:
         return "Not enough data to analyze trends (need 3+ reviews)."
     
     ratings = []
     sentiments = []
-    for r in raw_reviews:
+    for r in trend_data:
         if isinstance(r, dict):
             rating = float(r.get('rating', 0) or r.get('overall_rating', 0) or 0)
             if rating > 0:
                 ratings.append(rating)
-            text = r.get('text', '') or r.get('review_text', '')
-            sentiments.append(calculate_review_sentiment(text))
+            # Use pre-calculated sentiment if available, otherwise calculate
+            sentiment = r.get('sentiment')
+            if sentiment is not None:
+                sentiments.append(float(sentiment))
+            else:
+                text = r.get('text', '') or r.get('review_text', '')
+                sentiments.append(calculate_review_sentiment(text))
     
     if not ratings:
         return "No rating data available."
     
     avg_rating = sum(ratings) / len(ratings)
-    avg_sentiment = sum(sentiments) / len(sentiments)
+    avg_sentiment = sum(sentiments) / len(sentiments) if sentiments else 0
     
     insight = f"**{restaurant_name}** has an average rating of **{avg_rating:.1f} stars** "
     
@@ -659,7 +675,8 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         menu = state.get('menu_analysis', {})
         aspects = state.get('aspect_analysis', {})
         insights = state.get('insights', {})
-        raw_reviews = state.get('raw_reviews', [])
+        # Use trend_data (slim) or fall back to raw_reviews for backward compatibility
+        trend_data = state.get('trend_data', state.get('raw_reviews', []))
         
         food_items = menu.get('food_items', [])
         drinks = menu.get('drinks', [])
@@ -684,7 +701,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         
         styles = getSampleStyleSheet()
         
-        # Custom styles
+        # Custom styles - use 'Custom' prefix to avoid conflicts with default styles
         styles.add(ParagraphStyle('CoverTitle', parent=styles['Heading1'],
                                  fontSize=32, textColor=PRIMARY, alignment=TA_CENTER,
                                  spaceAfter=10, fontName='Helvetica-Bold'))
@@ -705,7 +722,8 @@ def generate_pdf_report(state: dict) -> Optional[str]:
                                  fontSize=14, textColor=TEXT_DARK, spaceBefore=15,
                                  spaceAfter=8, fontName='Helvetica-Bold'))
         
-        styles.add(ParagraphStyle('BodyText', parent=styles['Normal'],
+        # Use 'CustomBody' instead of 'BodyText' (which already exists)
+        styles.add(ParagraphStyle('CustomBody', parent=styles['Normal'],
                                  fontSize=10, textColor=TEXT_DARK, spaceAfter=8,
                                  leading=14, fontName='Helvetica'))
         
@@ -717,7 +735,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
                                  fontSize=10, textColor=TEXT_LIGHT, leftIndent=20,
                                  rightIndent=20, spaceAfter=10, fontName='Helvetica-Oblique'))
         
-        styles.add(ParagraphStyle('Footer', parent=styles['Normal'],
+        styles.add(ParagraphStyle('CustomFooter', parent=styles['Normal'],
                                  fontSize=8, textColor=TEXT_LIGHT, alignment=TA_CENTER))
         
         styles.add(ParagraphStyle('PriorityHigh', parent=styles['Normal'],
@@ -744,12 +762,12 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         elements.append(Spacer(1, 0.5*inch))
         elements.append(Paragraph(restaurant_name, styles['CoverRestaurant']))
         elements.append(Spacer(1, 0.3*inch))
-        elements.append(Paragraph(f"Data Source: {source}", styles['Footer']))
+        elements.append(Paragraph(f"Data Source: {source}", styles['CustomFooter']))
         elements.append(Spacer(1, 0.5*inch))
         
         # Stats boxes
         stats_data = [[
-            str(len(raw_reviews)), str(len(all_menu)), str(len(aspect_list))
+            str(len(trend_data)), str(len(all_menu)), str(len(aspect_list))
         ], [
             "Reviews", "Menu Items", "Aspects"
         ]]
@@ -768,8 +786,8 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         ]))
         elements.append(stats_table)
         elements.append(Spacer(1, 1*inch))
-        elements.append(Paragraph(f"Generated: {datetime.now().strftime('%B %d, %Y at %I:%M %p')}", styles['Footer']))
-        elements.append(Paragraph("Powered by Claude AI • Restaurant Intelligence Agent", styles['Footer']))
+        elements.append(Paragraph(f"Generated: {datetime.now().strftime('%B %d, %Y at %I:%M %p')}", styles['CustomFooter']))
+        elements.append(Paragraph("Powered by Claude AI • Restaurant Intelligence Agent", styles['CustomFooter']))
         elements.append(PageBreak())
         
         # ==================== EXECUTIVE SUMMARY ====================
@@ -804,14 +822,14 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         elements.append(Paragraph("Key Highlights", styles['SubHeader']))
         top_items = sorted(all_menu, key=lambda x: x.get('sentiment', 0), reverse=True)[:3]
         if top_items:
-            elements.append(Paragraph("✅ <b>Top Performing Items:</b>", styles['BodyText']))
+            elements.append(Paragraph("✅ <b>Top Performing Items:</b>", styles['CustomBody']))
             for item in top_items:
                 elements.append(Paragraph(f"    • {item.get('name', '?').title()} (sentiment: {item.get('sentiment', 0):+.2f})", styles['Bullet']))
         
         concern_items = [i for i in all_menu if i.get('sentiment', 0) < -0.2]
         if concern_items:
             elements.append(Spacer(1, 10))
-            elements.append(Paragraph("⚠️ <b>Items Needing Attention:</b>", styles['BodyText']))
+            elements.append(Paragraph("⚠️ <b>Items Needing Attention:</b>", styles['CustomBody']))
             for item in sorted(concern_items, key=lambda x: x.get('sentiment', 0))[:3]:
                 elements.append(Paragraph(f"    • {item.get('name', '?').title()} (sentiment: {item.get('sentiment', 0):+.2f})", styles['Bullet']))
         
@@ -825,7 +843,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         
         summary_data = [
             ['Metric', 'Value', 'Details'],
-            ['Reviews Analyzed', str(len(raw_reviews)), f'From {source}'],
+            ['Reviews Analyzed', str(len(trend_data)), f'From {source}'],
             ['Menu Items', str(len(all_menu)), f'{len(food_items)} food, {len(drinks)} drinks'],
             ['Customer Favorites', str(stars), 'Sentiment > 0.5'],
             ['Performing Well', str(good), 'Sentiment 0.2 - 0.5'],
@@ -853,8 +871,8 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         
         if all_menu:
             elements.append(Paragraph(
-                f"Analysis of <b>{len(all_menu)}</b> menu items ({len(food_items)} food, {len(drinks)} drinks) based on {len(raw_reviews)} customer reviews.",
-                styles['BodyText']
+                f"Analysis of <b>{len(all_menu)}</b> menu items ({len(food_items)} food, {len(drinks)} drinks) based on {len(trend_data)} customer reviews.",
+                styles['CustomBody']
             ))
             elements.append(Spacer(1, 10))
             
@@ -917,7 +935,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         if chef_data:
             if chef_data.get('summary'):
                 elements.append(Paragraph("Summary", styles['SubHeader']))
-                elements.append(Paragraph(str(chef_data['summary']), styles['BodyText']))
+                elements.append(Paragraph(str(chef_data['summary']), styles['CustomBody']))
             
             if chef_data.get('strengths'):
                 elements.append(Paragraph("✅ Strengths", styles['SubHeader']))
@@ -948,7 +966,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
                         else:
                             elements.append(Paragraph(f"• {r}", styles['Bullet']))
         else:
-            elements.append(Paragraph("Chef insights will be available after full analysis.", styles['BodyText']))
+            elements.append(Paragraph("Chef insights will be available after full analysis.", styles['CustomBody']))
         
         elements.append(Spacer(1, 20))
         
@@ -960,7 +978,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         if manager_data:
             if manager_data.get('summary'):
                 elements.append(Paragraph("Summary", styles['SubHeader']))
-                elements.append(Paragraph(str(manager_data['summary']), styles['BodyText']))
+                elements.append(Paragraph(str(manager_data['summary']), styles['CustomBody']))
             
             if manager_data.get('strengths'):
                 elements.append(Paragraph("✅ Operational Strengths", styles['SubHeader']))
@@ -991,7 +1009,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
                         else:
                             elements.append(Paragraph(f"• {r}", styles['Bullet']))
         else:
-            elements.append(Paragraph("Manager insights will be available after full analysis.", styles['BodyText']))
+            elements.append(Paragraph("Manager insights will be available after full analysis.", styles['CustomBody']))
         
         elements.append(PageBreak())
         
@@ -1002,25 +1020,37 @@ def generate_pdf_report(state: dict) -> Optional[str]:
         positive_reviews = []
         negative_reviews = []
         
-        for review in raw_reviews[:50]:
-            if isinstance(review, dict):
-                text = review.get('text', '') or review.get('review_text', '')
-            else:
-                text = str(review)
-            
-            if not text or len(text) < 30:
-                continue
-            
-            text_lower = text.lower()
-            pos_words = ['amazing', 'excellent', 'fantastic', 'great', 'awesome', 'delicious', 'perfect', 'loved', 'best']
-            neg_words = ['terrible', 'horrible', 'awful', 'bad', 'worst', 'disappointing', 'poor', 'rude']
-            
-            pos_count = sum(1 for w in pos_words if w in text_lower)
-            neg_count = sum(1 for w in neg_words if w in text_lower)
-            
-            if pos_count > neg_count and len(positive_reviews) < 3:
+        # Extract sample reviews from menu items and aspects (they have related_reviews with text)
+        all_related_reviews = []
+        
+        # Get reviews from menu items
+        for item in all_menu:
+            for r in item.get('related_reviews', [])[:2]:
+                if isinstance(r, dict):
+                    text = r.get('review_text', r.get('text', ''))
+                else:
+                    text = str(r)
+                if text and len(text) > 30:
+                    sentiment = item.get('sentiment', 0)
+                    all_related_reviews.append({'text': text, 'sentiment': sentiment})
+        
+        # Get reviews from aspects
+        for aspect in aspect_list:
+            for r in aspect.get('related_reviews', [])[:2]:
+                if isinstance(r, dict):
+                    text = r.get('review_text', r.get('text', ''))
+                else:
+                    text = str(r)
+                if text and len(text) > 30:
+                    sentiment = aspect.get('sentiment', 0)
+                    all_related_reviews.append({'text': text, 'sentiment': sentiment})
+        
+        # Sort by sentiment to get best positive and worst negative
+        for review in sorted(all_related_reviews, key=lambda x: x['sentiment'], reverse=True):
+            text = review['text']
+            if review['sentiment'] > 0.2 and len(positive_reviews) < 3:
                 positive_reviews.append(text[:180])
-            elif neg_count > pos_count and len(negative_reviews) < 3:
+            elif review['sentiment'] < -0.2 and len(negative_reviews) < 3:
                 negative_reviews.append(text[:180])
         
         elements.append(Paragraph("✅ Positive Feedback", styles['SubHeader']))
@@ -1028,7 +1058,7 @@ def generate_pdf_report(state: dict) -> Optional[str]:
             for review in positive_reviews:
                 elements.append(Paragraph(f'"{review}..."', styles['Quote']))
         else:
-            elements.append(Paragraph("Detailed positive feedback samples not available.", styles['BodyText']))
+            elements.append(Paragraph("Detailed positive feedback samples not available.", styles['CustomBody']))
         
         elements.append(Spacer(1, 15))
         
@@ -1037,15 +1067,15 @@ def generate_pdf_report(state: dict) -> Optional[str]:
             for review in negative_reviews:
                 elements.append(Paragraph(f'"{review}..."', styles['Quote']))
         else:
-            elements.append(Paragraph("No significant negative feedback identified. Great job!", styles['BodyText']))
+            elements.append(Paragraph("No significant negative feedback identified. Great job!", styles['CustomBody']))
         
         # ==================== FOOTER ====================
         elements.append(Spacer(1, 30))
         elements.append(HRFlowable(width="100%", thickness=1, color=BORDER, spaceBefore=10, spaceAfter=10))
-        elements.append(Paragraph(f"Report generated for {restaurant_name}", styles['Footer']))
-        elements.append(Paragraph(f"Generated on {datetime.now().strftime('%B %d, %Y at %I:%M %p')}", styles['Footer']))
-        elements.append(Paragraph("Restaurant Intelligence Agent • Powered by Claude AI", styles['Footer']))
-        elements.append(Paragraph("© 2025 - Built for Anthropic MCP Hackathon", styles['Footer']))
+        elements.append(Paragraph(f"Report generated for {restaurant_name}", styles['CustomFooter']))
+        elements.append(Paragraph(f"Generated on {datetime.now().strftime('%B %d, %Y at %I:%M %p')}", styles['CustomFooter']))
+        elements.append(Paragraph("Restaurant Intelligence Agent • Powered by Claude AI", styles['CustomFooter']))
+        elements.append(Paragraph("© 2025 - Built for Anthropic MCP Hackathon", styles['CustomFooter']))
         
         # Build PDF
         doc.build(elements)
@@ -1144,7 +1174,7 @@ AMBIANCE_WORDS = {'ambiance', 'atmosphere', 'vibe', 'decor', 'noise', 'loud', 'q
 
 
 def find_relevant_reviews(question: str, state: dict, top_k: int = 8) -> List[str]:
-    """Find relevant reviews for the question."""
+    """Find relevant reviews for the question using menu/aspect related_reviews."""
     if not state:
         return []
     
@@ -1153,7 +1183,6 @@ def find_relevant_reviews(question: str, state: dict, top_k: int = 8) -> List[st
     
     menu = state.get('menu_analysis', {})
     aspects = state.get('aspect_analysis', {})
-    raw_reviews = state.get('raw_reviews', [])
     
     all_items = menu.get('food_items', []) + menu.get('drinks', [])
     all_aspects = aspects.get('aspects', [])
@@ -1195,26 +1224,22 @@ def find_relevant_reviews(question: str, state: dict, top_k: int = 8) -> List[st
                 if text not in relevant_reviews:
                     relevant_reviews.append(text)
     
-    # Fallback: use raw reviews
-    if not relevant_reviews and raw_reviews:
-        for r in raw_reviews[:10]:
-            if isinstance(r, dict):
-                text = r.get('text', '') or r.get('review_text', '')
-            else:
-                text = str(r)
-            if text and len(text) > 20:
-                # Check if any question word appears in review
-                if any(w in text.lower() for w in q_words):
+    # Fallback: if still no reviews, gather from all items/aspects
+    if not relevant_reviews:
+        # Collect from top items by mentions
+        sorted_items = sorted(all_items, key=lambda x: x.get('mention_count', 0), reverse=True)
+        for item in sorted_items[:5]:
+            for r in item.get('related_reviews', [])[:2]:
+                text = r.get('review_text', str(r)) if isinstance(r, dict) else str(r)
+                if text and len(text) > 20 and text not in relevant_reviews:
                     relevant_reviews.append(text)
         
-        # If still nothing, just use first few reviews
-        if not relevant_reviews:
-            for r in raw_reviews[:5]:
-                if isinstance(r, dict):
-                    text = r.get('text', '') or r.get('review_text', '')
-                else:
-                    text = str(r)
-                if text and len(text) > 20:
+        # Also from top aspects
+        sorted_aspects = sorted(all_aspects, key=lambda x: x.get('mention_count', 0), reverse=True)
+        for aspect in sorted_aspects[:5]:
+            for r in aspect.get('related_reviews', [])[:2]:
+                text = r.get('review_text', str(r)) if isinstance(r, dict) else str(r)
+                if text and len(text) > 20 and text not in relevant_reviews:
                     relevant_reviews.append(text)
     
     return relevant_reviews[:top_k]
@@ -1342,7 +1367,7 @@ EXAMPLE_QUESTIONS = [
 # ============================================================================
 
 def analyze_restaurant(url: str, review_count: int):
-    """Main analysis function - calls Modal API."""
+    """Main analysis function - calls Modal API with robust error handling."""
     
     empty = {}
     default_summary = "Run analysis to see performance overview."
@@ -1376,23 +1401,56 @@ def analyze_restaurant(url: str, review_count: int):
     
     try:
         print(f"[ANALYZE] {platform_emoji} Analyzing {restaurant_name} from {platform}...")
+        print(f"[ANALYZE] Calling Modal API: {MODAL_API_URL}/analyze")
+        
+        # Use a session with retry logic
+        import requests
+        from requests.adapters import HTTPAdapter
+        from urllib3.util.retry import Retry
+        
+        session = requests.Session()
+        retries = Retry(
+            total=2,
+            backoff_factor=1,
+            status_forcelist=[502, 503, 504],
+            allowed_methods=["POST"]
+        )
+        session.mount("https://", HTTPAdapter(max_retries=retries))
         
-        response = requests.post(
+        # Make request with streaming disabled for stability
+        response = session.post(
             f"{MODAL_API_URL}/analyze",
             json={"url": url, "max_reviews": review_count},
-            timeout=1800
+            timeout=(30, 600),  # 30s connect, 600s read (10 min)
+            headers={"Connection": "keep-alive"}
         )
         
+        print(f"[ANALYZE] Response status: {response.status_code}")
+        
         if response.status_code != 200:
+            error_text = response.text[:500] if response.text else "No error details"
+            print(f"[ANALYZE] Error response: {error_text}")
             return (
-                f"❌ **API Error ({response.status_code}):** {response.text[:200]}",
+                f"❌ **API Error ({response.status_code}):** {error_text[:200]}",
                 None, "No trend data available.",
                 default_summary, None, default_insight, empty_dropdown, default_detail,
                 default_summary, None, default_insight, empty_dropdown, default_detail,
                 empty
             )
         
-        data = response.json()
+        # Parse response
+        try:
+            data = response.json()
+            print(f"[ANALYZE] Response received, success={data.get('success')}")
+        except Exception as json_err:
+            print(f"[ANALYZE] JSON parse error: {json_err}")
+            return (
+                f"❌ **Parse Error:** Could not parse API response. Try again.",
+                None, "No trend data available.",
+                default_summary, None, default_insight, empty_dropdown, default_detail,
+                default_summary, None, default_insight, empty_dropdown, default_detail,
+                empty
+            )
         
         if not data.get("success"):
             return (
@@ -1406,24 +1464,29 @@ def analyze_restaurant(url: str, review_count: int):
         menu = data.get('menu_analysis', {})
         aspects = data.get('aspect_analysis', {})
         insights = data.get('insights', {})
-        raw_reviews = data.get('raw_reviews', [])
+        
+        # Use slim trend_data (pre-calculated sentiment, no text)
+        # Falls back to raw_reviews for backward compatibility
+        trend_data = data.get('trend_data', data.get('raw_reviews', []))
         
         food_items = menu.get('food_items', [])
         drinks = menu.get('drinks', [])
         aspect_list = aspects.get('aspects', [])
         all_menu = food_items + drinks
         
+        print(f"[ANALYZE] Data extracted: {len(all_menu)} menu items, {len(aspect_list)} aspects, {len(trend_data)} trend points")
+        
         state = {
             "menu_analysis": menu,
             "aspect_analysis": aspects,
             "insights": insights,
             "restaurant_name": restaurant_name,
-            "raw_reviews": raw_reviews,
+            "trend_data": trend_data,  # Store for PDF if needed
             "source": platform
         }
         
-        trend_chart = generate_trend_chart(raw_reviews, restaurant_name)
-        trend_insight = generate_trend_insight(raw_reviews, restaurant_name)
+        trend_chart = generate_trend_chart(trend_data, restaurant_name)
+        trend_insight = generate_trend_insight(trend_data, restaurant_name)
         
         # Use improved detailed summaries
         menu_summary = translate_menu_performance(menu, restaurant_name)
@@ -1448,13 +1511,15 @@ def analyze_restaurant(url: str, review_count: int):
 
 **📊 Summary:**
 • Source: **{platform.replace('_', ' ').title()}**
-• Reviews analyzed: **{review_count}**
+• Reviews analyzed: **{len(trend_data)}**
 • Menu items found: **{len(all_menu)}** ({len(food_items)} food, {len(drinks)} drinks)
 • Aspects discovered: **{len(aspect_list)}**
 
 👇 **Explore the tabs below for detailed insights!**
 """
         
+        print(f"[ANALYZE] ✅ Analysis complete for {restaurant_name}")
+        
         return (
             status,
             trend_chart, trend_insight,
@@ -1464,6 +1529,7 @@ def analyze_restaurant(url: str, review_count: int):
         )
         
     except requests.exceptions.Timeout:
+        print("[ANALYZE] ❌ Timeout error")
         return (
             "❌ **Timeout:** Request took too long. Try with fewer reviews (50-100).",
             None, "No trend data available.",
@@ -1471,11 +1537,21 @@ def analyze_restaurant(url: str, review_count: int):
             default_summary, None, default_insight, empty_dropdown, default_detail,
             empty
         )
+    except requests.exceptions.ConnectionError as ce:
+        print(f"[ANALYZE] ❌ Connection error: {ce}")
+        return (
+            "❌ **Connection Error:** Could not reach analysis server. Please try again in a moment.",
+            None, "No trend data available.",
+            default_summary, None, default_insight, empty_dropdown, default_detail,
+            default_summary, None, default_insight, empty_dropdown, default_detail,
+            empty
+        )
     except Exception as e:
         import traceback
         traceback.print_exc()
+        print(f"[ANALYZE] ❌ Exception: {e}")
         return (
-            f"❌ **Error:** {str(e)}",
+            f"❌ **Error:** {str(e)[:200]}",
             None, "No trend data available.",
             default_summary, None, default_insight, empty_dropdown, default_detail,
             default_summary, None, default_insight, empty_dropdown, default_detail,