high-priority call to the database (load_messages) to pull the absolute truth

Dockerfile

@@ -1,42 +1,26 @@
-# Use official Python runtime as a parent image
 FROM python:3.12-slim
 
-# Set environment variables
 ENV PYTHONDONTWRITEBYTECODE=1
 ENV PYTHONUNBUFFERED=1
-ENV PORT=8000
 
-# Set working directory
 WORKDIR /app
 
-# Install system dependencies
-# libgl1 and libglib2.0-0 are for OpenCV/Computer Vision
-# curl is for health checks
 RUN apt-get update && apt-get install -y --no-install-recommends \
     build-essential \
     curl \
-    libgl1-mesa-glx \
+    git \
+    libgl1 \
     libglib2.0-0 \
     && rm -rf /var/lib/apt/lists/*
 
-# Install Python dependencies
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Install Playwright browser and its dependencies
-RUN playwright install chromium
-RUN playwright install-deps chromium
-
-# Copy the rest of the application
 COPY . .
 
-# Create a non-root user and switch to it for security
-# Ensure the user has access to playwright browsers
 RUN useradd -m appuser && chown -R appuser /app
 USER appuser
 
-# Expose the port (API usually on 8000)
-EXPOSE 8000
+EXPOSE 8080
 
-# Default command for the API (can be overridden in docker-compose for the worker)
-CMD exec gunicorn --bind :$PORT --workers 1 --worker-class uvicorn.workers.UvicornWorker --timeout 0 app.api.main:app
+CMD exec gunicorn --bind :$PORT --workers 1 --worker-class uvicorn.workers.UvicornWorker --timeout 0 app.api.main:app

app/agents/adk_mathminds.py

@@ -15,7 +15,6 @@ from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_excep
 
 from app.core.settings import settings
 from app.core.llm_guard import check_and_increment
-from app.tools.web_scraper import WebScraper
 from app.tools.symbolic_solver import SymbolicSolver
 from app.tools.similarity_search import SimilarProblemFinder
 from app.tools.python_executor import PythonInterpreter
@@ -43,7 +42,6 @@ class MathMindsADKAgent:
             logger.warning("No Google API Key found. Agent will fail.")
 
         # Tool instances
-        self.web_scraper = WebScraper(headless=True)
         self.symbolic_solver = SymbolicSolver()
         self.normalizer = MathQueryNormalizer()
         self.similar_finder = SimilarProblemFinder()
@@ -51,17 +49,31 @@ class MathMindsADKAgent:
         self.advanced_ocr = AdvancedOCR()
         self.vision_analyzer = VisionAnalyzer()
 
-        # ── Tool definitions ──────────────────────────────────────────────────
+        # Tool definitions
         async def web_search(query: str) -> str:
             """
             Search the internet for current data: prices, news, weather, facts.
             Args:
                 query: The search query.
             """
-            result = await self.web_scraper.scrape(query)
-            if result.get("status") == "success":
-                return result.get("content", "No content found.")
-            return f"Error searching web: {result.get('error')}"
+            from google import genai
+            from google.genai import types
+            
+            # Using a lightweight flash model for the grounded search
+            search_client = genai.Client(api_key=self.api_key)
+            try:
+                response = search_client.models.generate_content(
+                    model="gemini-2.5-flash",
+                    contents=f"Find the latest information for: {query}",
+                    config=types.GenerateContentConfig(
+                        tools=[types.Tool(google_search=types.GoogleSearchRetrieval())],
+                        temperature=0.0
+                    )
+                )
+                return response.text or "No specific information found."
+            except Exception as e:
+                logger.error(f"Native Grounding failed: {e}")
+                return f"Error searching web: {str(e)}"
 
         async def math_solver(problem: str) -> str:
             """
@@ -157,9 +169,14 @@ class MathMindsADKAgent:
                 "It uses specialized object detection (YOLO) for accurate quantification."
                 "\n3. For GRAPHS, PLOTS, COORDINATE GEOMETRY, or LOG DIAGRAMS: DO NOT use specialized tools. "
                 "Rely on your NATIVE MULTIMODAL VISION to interpret coordinates, slopes, and trends directly."
-                "\n4. Once you have machine-readable data from these tools, use `math_solver` or "
-                "`execute_python` to finalize the solution."
-                "\n\nCRITICAL: Always explain your reasoning before and after using tools."
+                "\n\nSOLVING & INTERPRETATION GUIDELINES:"
+                "\n1. Once you have machine-readable data, use `math_solver` or `execute_python` to solve."
+                "\n2. IF `math_solver` FAILS or returns an empty result: Immediately attempt the problem using `execute_python`. "
+                "In Python, you can use specialized libraries like `numpy`, `scipy`, or `sympy` for numerical and symbolic solutions."
+                "\n3. INTERPRET LATEX: Tool outputs (especially from SymPy) are often in raw LaTeX. "
+                "NEVER just display the raw LaTeX to the user. Always explain the steps in clear English. "
+                "Wrap LaTeX in `$ ... $` for inline or `$$ ... $$` for blocks so the UI renders it properly."
+                "\n\nCRITICAL: Always explain your reasoning before and after using tools. If a tool fails, explain WHY and try a different approach."
             )
         )
 

app/api/main.py

@@ -3,7 +3,7 @@ os.environ["DISABLE_MODEL_SOURCE_CHECK"] = "True"
 from typing import Any, Dict, Optional, List
 import sys
 import asyncio
-
+    
 if sys.platform == 'win32':
     asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
 
@@ -72,6 +72,9 @@ app = FastAPI(
     version="1.0.0",
     lifespan=lifespan
 )
+@app.get("/")
+async def root():
+    return {"message": "MathMinds API running"}
 
 # CORS Configuration
 app.add_middleware(
@@ -427,7 +430,8 @@ async def update_profile(
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    port = int(os.environ.get("PORT", 8080))
+    uvicorn.run(app, host="0.0.0.0", port=port)
 # ── Auth Endpoints (DECOMMISSIONED - Use Firebase) ──────────────────────────
 
 @app.post("/auth/signup")

app/core/settings.py

@@ -10,6 +10,11 @@ class Settings(BaseSettings):
     # Core API Keys (Required)
     GOOGLE_API_KEY: str
     GOOGLE_CLOUD_PROJECT: Optional[str] = None
+    
+    # Vertex AI Search (Grounding/Discovery Engine)
+    VERTEX_SEARCH_PROJECT_ID: Optional[str] = None
+    VERTEX_SEARCH_LOCATION: str = "global"
+    VERTEX_SEARCH_DATA_STORE_ID: Optional[str] = None
 
     
     # Environment
@@ -61,6 +66,10 @@ class Settings(BaseSettings):
                 raise ValueError("REDIS_URL must be set in production environment")
             if not self.FIREBASE_CREDENTIALS_PATH:
                 raise ValueError("FIREBASE_CREDENTIALS_PATH must be set in production environment")
+            if not self.VERTEX_SEARCH_DATA_STORE_ID:
+                # We allow it to be empty if the user wants to fallback to scraping, 
+                # but for 100% production readiness we should warn.
+                logger.warning("VERTEX_SEARCH_DATA_STORE_ID is not set. Scraper will use fallback logic.")
 
         # Set Defaults for Development
         else:

app/tools/web_scraper.py

@@ -1,210 +0,0 @@
-import logging
-import asyncio
-import re
-import random
-from typing import Optional, Dict, Any
-from playwright.sync_api import sync_playwright
-from playwright_stealth import Stealth
-from bs4 import BeautifulSoup
-from fake_useragent import UserAgent
-
-logger = logging.getLogger(__name__)
-
-def run_playwright_sync(query: str, headless: bool, extraction_focus: Optional[str] = None) -> Dict[str, Any]:
-    """
-    Refined Scraper with Stealth Mode:
-    1. Stealth Integration: Uses playwright-stealth to bypass bot detection.
-    2. Dynamic Search: Simulates human-like interaction on search engines.
-    3. Table Preservation: Converts HTML tables to structured text.
-    4. Anti-Detection: Enhanced headers, randomized delays, and metadata masking.
-    """
-    ua = UserAgent()
-    user_agent = ua.chrome
-    
-    try:
-        with sync_playwright() as p:
-            # P1: Browser Launch
-            browser = p.chromium.launch(headless=headless)
-            
-            # Create context with realistic window size and headers
-            context = browser.new_context(
-                user_agent=user_agent,
-                viewport={"width": 1920, "height": 1080},
-                device_scale_factor=1,
-                has_touch=False,
-                is_mobile=False,
-                extra_http_headers={
-                    "Accept-Language": "en-US,en;q=0.9",
-                    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
-                    "Sec-Fetch-Site": "none",
-                    "Sec-Fetch-Mode": "navigate",
-                    "Sec-Fetch-Dest": "document",
-                    "Upgrade-Insecure-Requests": "1"
-                }
-            )
-            
-            page = context.new_page()
-            
-            # --- P0: APPLY STEALTH ---
-            Stealth().apply_stealth_sync(page)
-            
-            # --- P1: IMPROVED NAVIGATION LOGIC ---
-            target_url = None
-            if query.startswith("http"):
-                target_url = query
-            else:
-                try:
-                    logger.info("Performing stealth search on DuckDuckGo...")
-                    # Go to home page first to establish cookies/session
-                    page.goto("https://duckduckgo.com/", wait_until="networkidle", timeout=30000)
-                    
-                    # Human-like delay before typing
-                    page.wait_for_timeout(random.randint(500, 1500))
-                    
-                    search_input = 'input[name="q"]'
-                    page.wait_for_selector(search_input, timeout=10000)
-                    
-                    # Simulate realistic typing speed
-                    page.type(search_input, query, delay=random.randint(50, 200))
-                    page.wait_for_timeout(random.randint(300, 700))
-                    page.press(search_input, "Enter")
-                    
-                    # Wait for results
-                    page.wait_for_load_state("networkidle", timeout=20000)
-                    
-                    # Robust search for result links
-                    selectors = [
-                        'a[data-testid="result-title-a"]', 
-                        '#links .result__a', 
-                        'h2 a',
-                        '.result__url' # Backup
-                    ]
-                    
-                    for selector in selectors:
-                        try:
-                            logger.info(f"Trying selector: {selector}")
-                            first_link = page.wait_for_selector(selector, timeout=5000)
-                            if first_link:
-                                target_url = first_link.get_attribute("href")
-                                if target_url: 
-                                    logger.info(f"Found target_url: {target_url} using {selector}")
-                                    break
-                        except Exception:
-                            continue
-                            
-                except Exception as e:
-                    logger.warning(f"Stealth DDG search failed: {e}. Trying secondary fallback.")
-                    # Use a clean direct search URL if interactive fails
-                    target_url = f"https://duckduckgo.com/?q={query}"
-
-            # CRITICAL: Ensure we have a URL to navigate to
-            if not target_url:
-                target_url = f"https://duckduckgo.com/?q={query}"
-                logger.info(f"Final fallback to DDG search page: {target_url}")
-
-            logger.info(f"Navigating to final target: {target_url}")
-
-            # --- P0: PAGE NAVIGATION & CONTENT LOAD ---
-            try:
-                # Some sites need more time to execute JS after networkidle
-                page.goto(target_url, timeout=45000, wait_until="networkidle")
-                page.wait_for_timeout(random.randint(1000, 2000)) 
-            except Exception as e:
-                logger.warning(f"Deep network idle timeout on {target_url}, using DOM snapshot.")
-                # If target_url is None, this will fail. Handled above.
-                try:
-                    page.goto(target_url, wait_until="domcontentloaded", timeout=15000)
-                except Exception:
-                    pass
-
-            # --- P0: STRUCTURED CONTENT EXTRACTION ---
-            html_content = page.content()
-            soup = BeautifulSoup(html_content, "html.parser")
-            
-            # Remove purely visual/scripting elements
-            for element in soup(["script", "style", "nav", "footer", "header", "noscript", "svg", "iframe", "button"]):
-                element.decompose()
-
-            # PRESERVE TABLES (Enhanced)
-            for table in soup.find_all("table"):
-                table_text = []
-                # Handle headers if present
-                thead = table.find("thead")
-                if thead:
-                    headers = [h.get_text(strip=True) for h in thead.find_all(["th", "td"])]
-                    if any(headers):
-                        table_text.append(" | ".join(headers))
-                        table_text.append("-" * len(" | ".join(headers)))
-                
-                # Handle rows
-                for row in table.find_all("tr"):
-                    # Skip rows that are already handled in thead
-                    if thead and row.parent == thead:
-                        continue
-                    cells = [cell.get_text(strip=True) for cell in row.find_all(["td", "th"])]
-                    if any(cells): # Avoid empty rows
-                        table_text.append(" | ".join(cells))
-                
-                if table_text:
-                    table.replace_with("\n[TABLE START]\n" + "\n".join(table_text) + "\n[TABLE END]\n")
-
-            # Get clean, structured text
-            text = soup.get_text(separator="\n", strip=True)
-            
-            # Content Filtering
-            if extraction_focus:
-                lines = text.split("\n")
-                pattern = re.compile(re.escape(extraction_focus), re.IGNORECASE)
-                # Capture context (line before and after)
-                relevant_content = []
-                for i, line in enumerate(lines):
-                    if pattern.search(line):
-                        if i > 0: relevant_content.append(lines[i-1])
-                        relevant_content.append(line)
-                        if i < len(lines) - 1: relevant_content.append(lines[i+1])
-                        relevant_content.append("-" * 10)
-                
-                if relevant_content:
-                    final_content = "\n".join(relevant_content[:60]) # Larger snippet for context
-                else:
-                    final_content = text[:5000] + "\n[Note: Extraction focus term not found]"
-            else:
-                final_content = text[:10000] # Increased for better LLM performance
-
-            browser.close()
-            
-            return {
-                "source": "web_scraper",
-                "url": str(target_url), # Ensure string for JSON safety
-                "content": final_content,
-                "status": "success"
-            }
-
-    except Exception as e:
-        logger.error(f"Stealth scraping failed: {e}")
-        return {"source": "web_scraper", "error": str(e), "status": "error"}
-
-class WebScraper:
-    def __init__(self, headless: bool = True):
-        self.headless = headless
-
-    async def scrape(self, query: str, extraction_focus: Optional[str] = None) -> Dict[str, Any]:
-        """Dispatches the scraping task to the backround worker (Celery)"""
-        logger.info(f"WebScraper: Initializing stealth scrape for: {query}")
-        
-        try:
-            from app.worker.tasks import scrape_task
-            task = scrape_task.delay(query, self.headless, extraction_focus)
-            
-            # Wait for result with a generous timeout (stealth takes longer)
-            max_retries = 90 
-            for _ in range(max_retries):
-                if task.ready():
-                    return task.result
-                await asyncio.sleep(1)
-            
-            return {"source": "web_scraper", "error": "Worker timeout (Page was likely too heavy)", "status": "error"}
-            
-        except Exception as e:
-            logger.warning(f"Worker unavailable, falling back to local thread: {e}")
-            return await asyncio.to_thread(run_playwright_sync, query, self.headless, extraction_focus)

app/worker/tasks.py

@@ -1,22 +1,18 @@
 import logging
 from app.worker.celery_app import celery_app
-from app.tools.web_scraper import run_playwright_sync
 
 logger = logging.getLogger(__name__)
 
 @celery_app.task(name="app.worker.tasks.scrape_task", bind=True)
 def scrape_task(self, query: str, headless: bool = True, extraction_focus: str = None):
     """
-    Celery task for web scraping.
+    Legacy scraper task. Web search has been migrated to Native Gemini Grounding.
+    This task is now a placeholder to maintain backward compatibility with any remaining calls.
     """
-    logger.info(f"Task {self.request.id} started for query: {query}")
-    try:
-        result = run_playwright_sync(query, headless, extraction_focus)
-        return result
-    except Exception as e:
-        logger.error(f"Task failed: {e}")
-        return {
-            "source": "web_scraper",
-            "error": str(e),
-            "status": "error"
-        }
+    logger.info(f"Scrape task {self.request.id} called for: {query} (Legacy/No-Op)")
+    return {
+        "source": "web_scraper_legacy",
+        "content": "Notice: Web search has been migrated to Native Gemini Grounding. Use the web_search tool directly.",
+        "status": "success",
+        "url": "N/A"
+    }

cloudbuild.yaml

@@ -43,10 +43,14 @@ steps:
       - 'run'
       - 'deploy'
       - 'mathminds-worker'
-      - '--image=gcr.io/$PROJECT_ID/mathminds-backend:latest'
-      - '--region=us-central1'
+      - '--set-env-vars=ENV=production,REDIS_URL=$_REDIS_URL,MONGO_URI=$_MONGO_URI'
+      - '--min-instances=1'
       - '--command=celery,-A,app.worker.celery_app,worker,--loglevel=info,--pool=solo'
 
+substitutions:
+  _REDIS_URL: "redis://localhost:6379/0"
+  _MONGO_URI: "mongodb://localhost:27017/mathminds"
+
 images:
   - 'gcr.io/$PROJECT_ID/mathminds-backend:latest'
   - 'gcr.io/$PROJECT_ID/mathminds-frontend:latest'

frontend/app.py

@@ -442,6 +442,12 @@ def chat_interface():
     active_sess = get_active_session()
     st.title(active_sess["title"] if active_sess else "Chat")
 
+    # ✅ SELF-HEALING: Reset processing lock if assistant has already replied
+    if st.session_state.is_processing and st.session_state.messages:
+        if st.session_state.messages[-1]["role"] == "assistant":
+             st.session_state.is_processing = False
+             # No rerun needed here, just continue to render
+
     # ── 1. Render history ─────────────────────────────────────────────────────
     for msg in st.session_state.messages:
         role = msg["role"]
@@ -592,23 +598,16 @@ def chat_interface():
                         
                         status_msg.update(label="Solved!", state="complete", expanded=False)
                         
-                        if full_answer or logic_trace:
-                            add_message(
-                                "assistant", 
-                                full_answer if full_answer else "Processed. Check reasoning steps.", 
-                                reasoning="\n".join(logic_trace),
-                                metadata={"source": "agent"}
-                            )
+                        # Force sync with database to ensure UI has the latest persisted state
+                        if st.session_state.active_session_id:
+                            load_messages(st.session_state.active_session_id)
                         load_sessions() # Refresh titles
                     elif r.status_code == 401:
                         _clear_user_state()
                         st.session_state.user = None
                         st.error("Session expired. Please log in again.")
-                        st.rerun()
                     else:
                         st.error(f"Error: {r.status_code}")
-                        st.session_state.is_processing = False
-                        st.rerun()
 
             except Exception as e:
                 st.error(f"Connection error: {e}")

requirements.txt

@@ -17,14 +17,15 @@ gunicorn
 paddlepaddle
 paddleocr
 Pillow
-playwright
+# Scraping retired (Switched to Native Grounding)
+# playwright
 wolframalpha
 sympy
 ultralytics
 streamlit-drawable-canvas
 pydantic-settings
-beautifulsoup4
-fake-useragent
+# beautifulsoup4
+# fake-useragent
 ollama
 firebase-admin
 supabase
@@ -39,4 +40,5 @@ PyJWT
 
 selenium
 webdriver-manager
+# google-cloud-discoveryengine
 google-adk @ git+https://github.com/google/adk-python.git@main