Update app.py

app.py

@@ -1,266 +1,244 @@
-# app.py — GeoMate V2 (single-file)
-# Author: generated for user
-# Notes:
-# - Requires Streamlit. See requirements.txt below.
-# - Secrets expected in environment or HF Secrets: GROQ_API_KEY, SERVICE_ACCOUNT
-# - Earth Engine JSON file expected as file-like content or environment variable name EARTH_ENGINE_KEY
-# - This file uses placeholder behavior for heavy integrations (Groq, Earth Engine, FAISS). See comments.
-
-import os
-import io
-import re
-import json
-import math
-import base64
-import tempfile
-from datetime import datetime
-from typing import Any, Dict, Tuple, List, Optional
+# app.py — GeoMate V2 (single file)
+# ======================================================
+# Copy-paste this whole file into your HuggingFace Space
+# Then set secrets: GROQ_API_KEY, SERVICE_ACCOUNT (or EARTH_ENGINE_KEY)
+# Optional secrets: FAISS_DB_ZIP (or upload via UI)
+# ======================================================
 
+# 0. Page config — MUST be first Streamlit call
 import streamlit as st
+st.set_page_config(page_title="GeoMate V2", page_icon="🌍", layout="wide", initial_sidebar_state="expanded")
 
-# Basic data science and plotting
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-
-# PDF generation (ReportLab preferred)
-from reportlab.lib import colors
-from reportlab.lib.pagesizes import A4, landscape
-from reportlab.lib.units import mm
-from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image as RLImage, PageBreak
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-
-# Lightweight PDF export for quick classification report
-from fpdf import FPDF
+# 1. Standard imports
+import os, json, io, zipfile, math, traceback
+from datetime import datetime
+from typing import Dict, Any, Tuple, List, Optional
 
-# Optional dependencies (guarded)
+# 2. Optional heavy imports guarded
 try:
-    import pytesseract
-    HAVE_OCR = True
+    import faiss
 except Exception:
-    HAVE_OCR = False
+    faiss = None
 
 try:
-    import geemap  # for Earth Engine mapping in Streamlit
-    HAVE_GEEMAP = True
+    from groq import Groq
 except Exception:
-    HAVE_GEEMAP = False
+    Groq = None
 
 try:
     import ee
-    HAVE_EE = True
+    import geemap
 except Exception:
-    HAVE_EE = False
+    ee = None
+    geemap = None
 
-# Groq client (placeholder)
 try:
-    from groq import Groq
-    HAVE_GROQ = True
+    from reportlab.lib import colors
+    from reportlab.lib.pagesizes import A4
+    from reportlab.lib.units import mm
+    from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
+    from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
 except Exception:
-    HAVE_GROQ = False
-
-# FAISS and sentence-transformers for embedding search (placeholder)
-try:
-    import faiss
-    from sentence_transformers import SentenceTransformer
-    HAVE_FAISS = True
-except Exception:
-    HAVE_FAISS = False
-
-# ---------------------------
-# App-level configuration
-# ---------------------------
-st.set_page_config(page_title="GeoMate V2", page_icon="🌍", layout="wide")
+    # we'll fallback to fpdf if reportlab is missing
+    try:
+        from fpdf import FPDF
+    except Exception:
+        FPDF = None
 
-# Session alias
-ss = st.session_state
+# 3. Basic CSS (rounded bubbles, orange active style)
+st.markdown(
+    """
+    <style>
+    .bubble-bot {
+        background: linear-gradient(180deg,#111111,#1a1a1a);
+        color: #fff;
+        padding:10px 14px;
+        border-radius:12px;
+        border-left:4px solid #FF8C00;
+        margin:6px 0;
+    }
+    .bubble-user {
+        background: linear-gradient(180deg,#0f2b3a,#05202a);
+        color: #e6f7ff;
+        padding:10px 14px;
+        border-radius:12px;
+        margin:6px 0;
+        text-align:right;
+    }
+    .sidebar .stButton>button { border-radius:8px; }
+    .active-bubble { box-shadow: 0 0 0 3px rgba(255,122,0,0.12); }
+    </style>
+    """,
+    unsafe_allow_html=True,
+)
 
-# ---------------------------
-# Secrets check (required)
-# ---------------------------
-REQUIRED_SECRETS = ["GROQ_API_KEY", "SERVICE_ACCOUNT"]
-missing = [k for k in REQUIRED_SECRETS if not (os.environ.get(k) or (st.secrets and st.secrets.get(k)))]
-# EARTH_ENGINE_KEY expected as a file path or environment variable containing JSON; handle in locator page.
+# 4. REQUIRED secrets check (per your instructions)
+REQUIRE_EE = True  # change to False if you want to allow running without EE
+REQUIRED_SECRETS = ["GROQ_API_KEY"]
+if REQUIRE_EE:
+    REQUIRED_SECRETS.append("SERVICE_ACCOUNT")  # or EARTH_ENGINE_KEY
 
+missing = [s for s in REQUIRED_SECRETS if not os.getenv(s)]
 if missing:
-    st.title("GeoMate V2 — Missing required secrets")
-    st.error(f"Missing required environment secrets: {', '.join(missing)}.\n"
-             "Please add them to your Hugging Face Space secrets (Settings → Secrets) or environment.\n"
-             "Required: GROQ_API_KEY, SERVICE_ACCOUNT. EARTH_ENGINE_KEY (JSON) required for Earth Engine features.")
+    st.error(f"Missing required secrets/environment variables: {missing}. Set them in HuggingFace Space Secrets or environment.")
     st.stop()
 
-# Grab Groq key (if present)
-GROQ_API_KEY = os.environ.get("GROQ_API_KEY") or (st.secrets.get("GROQ_API_KEY") if st.secrets else None)
-SERVICE_ACCOUNT = os.environ.get("SERVICE_ACCOUNT") or (st.secrets.get("SERVICE_ACCOUNT") if st.secrets else None)
-EARTH_ENGINE_KEY = os.environ.get("EARTH_ENGINE_KEY") or (st.secrets.get("EARTH_ENGINE_KEY") if st.secrets else None)
+# 5. Load secrets into a dict for convenience
+SECRETS = {k: os.getenv(k) for k in os.environ.keys() if k in REQUIRED_SECRETS + ["EARTH_ENGINE_KEY"]}
+# Also optionally access other secrets by name directly via os.getenv
 
-# ---------------------------
-# Initialize session-state
-# ---------------------------
+# 6. Session state alias and initialization
+ss = st.session_state
 if "sites" not in ss:
-    # default single site
-    ss["sites"] = [
-        {
-            "Site Name": "Home",
-            "Site Coordinates": "",
-            "lat": None,
-            "lon": None,
-            "Load Bearing Capacity": None,
-            "Skin Shear Strength": None,
-            "Relative Compaction": None,
-            "Rate of Consolidation": None,
-            "Nature of Construction": None,
-            "Soil Profile": None,
-            "Flood Data": None,
-            "Seismic Data": None,
-            "Topography": None,
-            "Environmental Data": None,
-            "GSD": None,
-            "USCS": None,
-            "AASHTO": None,
-            "GI": None,
-            "classifier_inputs": {},
-            "classifier_decision_path": "",
-            "chat_history": [],  # list of {role,msg,ts}
-            "report_convo_state": 0,
-            "map_snapshot": None,  # store bytes of PNG
-            "ocr_text": None,
-            "lab_results": [],  # list of lab dicts
-            "cbr_results": [],  # list of cbr dicts
-        }
-    ]
-
-if "active_site" not in ss:
-    ss["active_site"] = 0
-
-if "model_name" not in ss:
-    # default model (you asked to support multiple LLMs; Groq model is set when calling)
-    ss["model_name"] = "meta-llama/llama-4-maverick-17b-128e-instruct"
+    # Initialize with one default site
+    ss["sites"] = [ {
+        "Site Name": "Home",
+        "Site Coordinates": "",
+        "lat": None, "lon": None,
+        "Load Bearing Capacity": None,
+        "Skin Shear Strength": None,
+        "Relative Compaction": None,
+        "Rate of Consolidation": None,
+        "Nature of Construction": None,
+        "Soil Profile": None,
+        "Flood Data": None,
+        "Seismic Data": None,
+        "Topography": None,
+        "GSD": None,
+        "USCS": None,
+        "AASHTO": None,
+        "GI": None,
+        "classifier_inputs": {},
+        "classifier_decision_path": "",
+        "chat_history": [],
+        "report_convo_state": 0,
+        "map_snapshot": None,
+        "classifier_chat": [],
+    } ]
+if "active_site_index" not in ss:
+    ss["active_site_index"] = 0
+if "llm_model" not in ss:
+    ss["llm_model"] = "meta-llama/llama-4-maverick-17b-128e-instruct"
+if "faiss_loaded" not in ss:
+    ss["faiss_loaded"] = False
+if "ee_inited" not in ss:
+    ss["ee_inited"] = False
 
-# helper to get active site dict
-def active_site() -> Dict[str, Any]:
-    idx = ss.get("active_site", 0)
-    idx = max(0, min(idx, len(ss["sites"]) - 1))
-    ss["active_site"] = idx
-    return ss["sites"][idx]
+# 7. Utility helpers
+def now_str():
+    return datetime.utcnow().strftime("%Y-%m-%d_%H%M%S")
 
-# ---------------------------
-# Utility functions
-# ---------------------------
-def human_now() -> str:
-    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+def get_active_site() -> Dict[str,Any]:
+    return ss["sites"][ss["active_site_index"]]
 
-def save_chat_message(site_idx: int, role: str, text: str):
-    ss["sites"][site_idx]["chat_history"].append({"role": role, "text": text, "ts": human_now()})
+def save_site_field(site_idx:int, key:str, value):
+    ss["sites"][site_idx][key] = value
 
-def ensure_float(x, default=0.0):
-    try:
-        return float(x)
-    except Exception:
-        return default
-
-def ensure_int(x, default=0):
-    try:
-        return int(x)
-    except Exception:
-        return default
-
-# ---------------------------
-# USCS & AASHTO verbatim logic (as requested)
-# ---------------------------
-from math import floor
+def map_pretty_sites():
+    return [s.get("Site Name","Site") for s in ss["sites"]]
 
+# 8. Engineering characteristics table (full detailed set -> expanded)
 ENGINEERING_CHARACTERISTICS = {
     "Gravel": {
-        "Settlement": "None",
-        "Quicksand": "Impossible",
+        "Settlement": "Negligible",
+        "Quicksand": "No",
         "Frost-heaving": "None",
-        "Groundwater_lowering": "Possible",
-        "Cement_grouting": "Possible",
-        "Silicate_bitumen_injections": "Unsuitable",
-        "Compressed_air": "Possible (see notes)"
+        "Drainage": "Excellent",
+        "Cement grouting": "Possible",
+        "Notes": "Good bearing; suitable for foundations with minimal treatment."
     },
     "Coarse sand": {
-        "Settlement": "None",
-        "Quicksand": "Impossible",
+        "Settlement": "Negligible",
+        "Quicksand": "No",
         "Frost-heaving": "None",
-        "Groundwater_lowering": "Possible",
-        "Cement_grouting": "Possible only if very coarse",
-        "Silicate_bitumen_injections": "Suitable",
-        "Compressed_air": "Suitable"
+        "Drainage": "Excellent",
+        "Cement grouting": "Possible if coarse",
+        "Notes": "Good compaction properties; typical for pavement subgrade if dense."
     },
     "Medium sand": {
-        "Settlement": "None",
+        "Settlement": "Low",
         "Quicksand": "Unlikely",
         "Frost-heaving": "None",
-        "Groundwater_lowering": "Suitable",
-        "Cement_grouting": "Impossible",
-        "Silicate_bitumen_injections": "Suitable",
-        "Compressed_air": "Suitable"
+        "Drainage": "Good",
+        "Notes": "Moderate bearing; check gradation."
     },
     "Fine sand": {
-        "Settlement": "None",
-        "Quicksand": "Liable",
-        "Frost-heaving": "None",
-        "Groundwater_lowering": "Suitable",
-        "Cement_grouting": "Impossible",
-        "Silicate_bitumen_injections": "Not possible in very fine sands",
-        "Compressed_air": "Suitable"
+        "Settlement": "Potentially small",
+        "Quicksand": "Possible in presence of groundwater",
+        "Frost-heaving": "Depends on fines",
+        "Drainage": "Fair",
+        "Notes": "Uniform fine sands may be susceptible to piping under flow."
     },
     "Silt": {
-        "Settlement": "Occurs",
-        "Quicksand": "Liable (very coarse silts may behave differently)",
-        "Frost-heaving": "Occurs",
-        "Groundwater_lowering": "Generally not suitable (electro-osmosis possible)",
-        "Cement_grouting": "Impossible",
-        "Silicate_bitumen_injections": "Impossible",
-        "Compressed_air": "Suitable"
+        "Settlement": "Moderate to high",
+        "Quicksand": "Possible (liquefaction risk under seismic)",
+        "Frost-heaving": "Likely",
+        "Drainage": "Poor",
+        "Notes": "Silty soils often need stabilization for foundations."
     },
     "Clay": {
-        "Settlement": "Occurs",
-        "Quicksand": "Impossible",
-        "Frost-heaving": "None",
-        "Groundwater_lowering": "Impossible (generally)",
-        "Cement_grouting": "Only in stiff fissured clay",
-        "Silicate_bitumen_injections": "Impossible",
-        "Compressed_air": "Used for support only in special cases"
+        "Settlement": "High (consolidation possible)",
+        "Quicksand": "No",
+        "Frost-heaving": "Less than silt",
+        "Drainage": "Poor",
+        "Notes": "Clayey soils require careful foundation design; may be expansive."
     }
 }
 
-def uscs_aashto_verbatim(inputs: Dict[str, Any]) -> Tuple[str,str,str,int,Dict[str,str]]:
+# 9. Verbatim USCS & AASHTO classifier (preserve logic)
+from math import floor
+def uscs_aashto_verbatim(inputs: Dict[str,Any]) -> Tuple[str, str, str, int, Dict[str,str]]:
     """
-    Returns (result_text, uscs_sym, aashto_sym, GI, char_summary)
-    Uses your original logic, adapted for numeric inputs.
+    Inputs expected keys:
+      opt ('y'/'n'), P2, P4, D60, D30, D10, LL, PL, nDS, nDIL, nTG
+    Returns:
+      result_text (detailed natural text),
+      uscs_code, aashto_code, GI (int), char_summary (dict)
     """
+    # Read inputs (provide defaults)
     opt = str(inputs.get("opt","n")).lower()
-    if opt == 'y':
+    if opt == "y":
         uscs = "Pt"
         uscs_expl = "Peat / organic soil — compressible, high organic content; poor engineering properties for load-bearing without special treatment."
         aashto = "Organic (special handling)"
-        characteristics = {"summary":"Highly organic peat — large settlement, low strength, not suitable for foundations without improvement."}
-        result_text = f"According to USCS, the soil is {uscs} — {uscs_expl}\nAccording to AASHTO, the soil is {aashto}."
-        return result_text, uscs, aashto, 0, characteristics
-
-    P2 = ensure_float(inputs.get("P2", 0.0))
-    P4 = ensure_float(inputs.get("P4", 0.0))
-    D60 = ensure_float(inputs.get("D60", 0.0))
-    D30 = ensure_float(inputs.get("D30", 0.0))
-    D10 = ensure_float(inputs.get("D10", 0.0))
-    LL = ensure_float(inputs.get("LL", 0.0))
-    PL = ensure_float(inputs.get("PL", 0.0))
+        GI = 0
+        char_summary = {"Notes":"Highly organic peat — large settlement potential; unsuitable without improvement."}
+        res = f"According to USCS, the soil is {uscs} — {uscs_expl}\nAccording to AASHTO, it is {aashto}."
+        return res, uscs, aashto, GI, char_summary
+
+    # numeric inputs
+    try:
+        P2 = float(inputs.get("P2",0.0))
+    except:
+        P2 = 0.0
+    try:
+        P4 = float(inputs.get("P4",0.0))
+    except:
+        P4 = 0.0
+    try:
+        D60 = float(inputs.get("D60",0.0))
+        D30 = float(inputs.get("D30",0.0))
+        D10 = float(inputs.get("D10",0.0))
+    except:
+        D60=D30=D10=0.0
+    try:
+        LL = float(inputs.get("LL",0.0))
+        PL = float(inputs.get("PL",0.0))
+    except:
+        LL=0.0; PL=0.0
     PI = LL - PL
 
-    Cu = (D60 / D10) if (D10 > 0 and D60 > 0) else 0.0
-    Cc = ((D30 ** 2) / (D10 * D60)) if (D10 > 0 and D30 > 0 and D60 > 0) else 0.0
+    Cu = (D60 / D10) if (D10>0 and D60>0) else 0.0
+    Cc = ((D30**2) / (D10*D60)) if (D10>0 and D30>0 and D60>0) else 0.0
 
     uscs = "Unknown"
     uscs_expl = ""
-    # logic as in your provided script
+    # USCS logic (verbatim from your script)
     if P2 <= 50:
         # Coarse-Grained Soils
         if P4 <= 50:
             # Gravels
-            if Cu and Cc:
+            if Cu!=0 and Cc!=0:
                 if Cu >= 4 and 1 <= Cc <= 3:
                     uscs = "GW"; uscs_expl = "Well-graded gravel (good engineering properties, high strength, good drainage)."
                 else:
@@ -274,7 +252,7 @@ def uscs_aashto_verbatim(inputs: Dict[str, Any]) -> Tuple[str,str,str,int,Dict[s
                     uscs = "GM-GC"; uscs_expl = "Gravel with mixed silt/clay fines."
         else:
             # Sands
-            if Cu and Cc:
+            if Cu!=0 and Cc!=0:
                 if Cu >= 6 and 1 <= Cc <= 3:
                     uscs = "SW"; uscs_expl = "Well-graded sand (good compaction and drainage)."
                 else:
@@ -288,9 +266,9 @@ def uscs_aashto_verbatim(inputs: Dict[str, Any]) -> Tuple[str,str,str,int,Dict[s
                     uscs = "SM-SC"; uscs_expl = "Transition between silty sand and clayey sand."
     else:
         # Fine-Grained Soils
-        nDS = int(inputs.get("nDS", 5))
-        nDIL = int(inputs.get("nDIL", 6))
-        nTG = int(inputs.get("nTG", 6))
+        nDS = int(inputs.get("nDS",5))
+        nDIL = int(inputs.get("nDIL",6))
+        nTG = int(inputs.get("nTG",6))
 
         if LL < 50:
             if 20 <= LL < 50 and PI <= 0.73 * (LL - 20):
@@ -302,11 +280,11 @@ def uscs_aashto_verbatim(inputs: Dict[str, Any]) -> Tuple[str,str,str,int,Dict[s
                     uscs = "ML-OL"; uscs_expl = "Mixed silt/organic silt."
             elif 10 <= LL <= 30 and 4 <= PI <= 7 and PI > 0.72 * (LL - 20):
                 if nDS == 1 or nDIL == 1 or nTG == 1:
-                    uscs = "ML"; uscs_expl = "Silt"
+                    uscs = "ML"; uscs_expl = "Silt."
                 elif nDS == 2 or nDIL == 2 or nTG == 2:
                     uscs = "CL"; uscs_expl = "Clay (low plasticity)."
                 else:
-                    uscs = "ML-CL"; uscs_expl = "Mixed silt/clay"
+                    uscs = "ML-CL"; uscs_expl = "Mixed silt/clay."
             else:
                 uscs = "CL"; uscs_expl = "Clay (low plasticity)."
         else:
@@ -320,7 +298,7 @@ def uscs_aashto_verbatim(inputs: Dict[str, Any]) -> Tuple[str,str,str,int,Dict[s
             else:
                 uscs = "CH"; uscs_expl = "Clay (high plasticity)"
 
-    # AASHTO logic
+    # AASHTO logic (verbatim)
     if P2 <= 35:
         if P2 <= 15 and P4 <= 30 and PI <= 6:
             aashto = "A-1-a"
@@ -347,172 +325,706 @@ def uscs_aashto_verbatim(inputs: Dict[str, Any]) -> Tuple[str,str,str,int,Dict[s
         elif LL <= 40 and PI >= 11:
             aashto = "A-6"
         else:
-            if PI <= (LL - 30):
-                aashto = "A-7-5"
-            else:
-                aashto = "A-7-6"
-
-    # Group Index
-    a = P2 - 35
-    a = 0 if a < 0 else (40 if a > 40 else a)
-    b = P2 - 15
-    b = 0 if b < 0 else (40 if b > 40 else b)
-    c = LL - 40
-    c = 0 if c < 0 else (20 if c > 20 else c)
-    d = PI - 10
-    d = 0 if d < 0 else (20 if d > 20 else d)
-    GI = floor(0.2 * a + 0.005 * a * c + 0.01 * b * d)
+            aashto = "A-7-5" if PI <= (LL - 30) else "A-7-6"
+
+    # Group Index (GI)
+    a = P2 - 35; a = 0 if a < 0 else (40 if a > 40 else a)
+    b = P2 - 15; b = 0 if b < 0 else (40 if b > 40 else b)
+    c = LL - 40; c = 0 if c < 0 else (20 if c > 20 else c)
+    d = PI - 10; d = 0 if d < 0 else (20 if d > 20 else d)
+    GI = floor(0.2*a + 0.005*a*c + 0.01*b*d)
 
     aashto_expl = f"{aashto} (Group Index = {GI})"
 
-    # engineering characteristics mapping best-effort
+    # Characteristics summary selection
     char_summary = {}
-    if uscs.startswith(("G", "P")):
-        char_summary = ENGINEERING_CHARACTERISTICS.get("Gravel", {})
-    elif uscs.startswith("S"):
-        char_summary = ENGINEERING_CHARACTERISTICS.get("Coarse sand", {})
-    elif uscs.startswith(("M", "C", "O", "H")):
-        char_summary = ENGINEERING_CHARACTERISTICS.get("Silt", {})
-
-    result_text = f"According to USCS, the soil is {uscs} — {uscs_expl}\nAccording to AASHTO, the soil is {aashto_expl}"
-    return result_text, uscs, aashto, GI, char_summary
-
-# ---------------------------
-# GSD utilities
-# ---------------------------
-def compute_gsd(diameters: List[float], passing: List[float]) -> Dict[str, Any]:
-    """
-    diameters: list descending (mm)
-    passing: percent passing corresponding to diameters
-    Returns D10,D30,D60,Cu,Cc and matplotlib figure
-    """
-    # ensure arrays sorted descending diameter
-    arr = sorted(zip(diameters, passing), key=lambda x: -x[0])
-    d_sorted = np.array([a for a,b in arr])
-    p_sorted = np.array([b for a,b in arr])
-
-    # interpolation function: percent -> diameter (we need diameter at percent passing)
-    def diameter_at(pct):
-        if pct <= p_sorted.min():
-            return d_sorted[p_sorted.argmin()]
-        if pct >= p_sorted.max():
-            return d_sorted[p_sorted.argmax()]
-        return float(np.interp(pct, p_sorted[::-1], d_sorted[::-1]))
-
-    D10 = diameter_at(10)
-    D30 = diameter_at(30)
-    D60 = diameter_at(60)
-    Cu = (D60 / D10) if (D10 > 0) else 0.0
-    Cc = (D30**2) / (D10 * D60) if (D10 > 0 and D60 > 0) else 0.0
-
-    # produce plot
-    fig, ax = plt.subplots(figsize=(6, 3.5))
-    ax.semilogx(d_sorted, p_sorted, marker='o', linestyle='-')
-    ax.set_xlabel("Grain size (mm)")
-    ax.set_ylabel("% Passing")
-    ax.set_title("Grain Size Distribution")
-    ax.grid(True, which="both", ls="--", lw=0.5)
+    if uscs.startswith("G") or uscs.startswith("S"):
+        char_summary = ENGINEERING_CHARACTERISTICS.get("Coarse sand") or ENGINEERING_CHARACTERISTICS.get("Gravel")
+    elif uscs.startswith(("M","C","O","H")):
+        char_summary = ENGINEERING_CHARACTERISTICS.get("Silt")
+    else:
+        char_summary = {"Notes":"Engineering properties need site-specific testing."}
+
+    # Compose natural text
+    result_lines = []
+    result_lines.append(f"According to USCS, the soil is **{uscs}** — {uscs_expl}")
+    result_lines.append(f"According to AASHTO, the soil is **{aashto_expl}**.")
+    result_lines.append("Engineering characteristics summary:")
+    for k,v in char_summary.items():
+        result_lines.append(f"- {k}: {v}")
+
+    return "\n".join(result_lines), uscs, aashto, GI, char_summary
+
+# 10. GSD compute & plot
+import matplotlib.pyplot as plt
+def compute_and_plot_gsd(diams: List[float], passing: List[float]) -> Dict[str,Any]:
+    """diams in mm descending, passing in %"""
+    import numpy as np
+    d = sorted(diams, reverse=True)
+    p = [max(0,min(100,float(x))) for x in passing]
+    # interpolation for D10 D30 D60
+    def interp_D(percent):
+        # percent is passing percent; we want diameter where percent passes
+        if percent <= p[-1]:
+            return d[-1]
+        if percent >= p[0]:
+            return d[0]
+        for i in range(len(p)-1):
+            if p[i] >= percent >= p[i+1]:
+                x0,x1 = p[i],p[i+1]
+                y0,y1 = d[i],d[i+1]
+                # linear interpolation in log space for better accuracy
+                if y0>0 and y1>0:
+                    import math
+                    logy0, logy1 = math.log(y0), math.log(y1)
+                    t = (percent - x0)/(x1-x0) if x1!=x0 else 0
+                    logy = logy0 + t*(logy1 - logy0)
+                    return math.exp(logy)
+                else:
+                    t = (percent-x0)/(x1-x0) if x1!=x0 else 0
+                    return y0 + t*(y1-y0)
+        return d[-1]
+
+    D10 = interp_D(10)
+    D30 = interp_D(30)
+    D60 = interp_D(60)
+    Cu = (D60/D10) if D10>0 else None
+    Cc = ((D30**2)/(D10*D60)) if (D10>0 and D60>0) else None
+
+    fig = plt.figure(figsize=(6,3))
+    plt.semilogx(d, p, marker='o')
     plt.gca().invert_xaxis()
+    plt.xlabel("Particle diameter (mm) [log scale]")
+    plt.ylabel("% Passing")
+    plt.title("GSD Curve")
+    plt.grid(True, which="both", ls="--", alpha=0.4)
+    plt.tight_layout()
 
-    return {"D10": D10, "D30": D30, "D60": D60, "Cu": Cu, "Cc": Cc, "fig": fig}
+    return {"D10":D10, "D30":D30, "D60":D60, "Cu":Cu, "Cc":Cc, "fig":fig}
 
-# ---------------------------
-# Small LLM caller wrapper (Groq) — placeholder
-# ---------------------------
-def call_groq_system(prompt: str, model: Optional[str] = None) -> str:
-    """
-    Call Groq if available; otherwise return a simple deterministic response.
-    This is a thin wrapper: production usage requires proper auth and client.
-    """
-    model_to_use = model or ss.get("model_name") or "meta-llama/llama-4-maverick-17b-128e-instruct"
-    if HAVE_GROQ and GROQ_API_KEY:
+# 11. OCR helper (pytesseract) — optional
+def ocr_extract_image(img_file) -> Dict[str,Any]:
+    try:
+        from PIL import Image
+        import pytesseract
+    except Exception:
+        return {"error":"pytesseract or PIL not installed."}
+    try:
+        img = Image.open(img_file)
+        text = pytesseract.image_to_string(img)
+        # attempt to find numbers for LL, PL, sieve percentages using simple regex
+        import re
+        nums = re.findall(r"[-+]?\d*\.\d+|\d+", text)
+        return {"text":text, "numbers": nums}
+    except Exception as e:
+        return {"error":str(e)}
+
+# 12. Sidebar UI (model selection, site management)
+def sidebar_ui():
+    st.sidebar.markdown("### GeoMate V2")
+    st.sidebar.markdown("AI copilot for geotechnical engineering")
+
+    # LLM model selection
+    models = [
+        "meta-llama/llama-4-maverick-17b-128e-instruct",
+        "llama3-8b-8192",
+        "gemma-7b-it",
+        "mixtral-8x7b-32768"
+    ]
+    sel = st.sidebar.selectbox("Select LLM model", options=models, index=models.index(ss["llm_model"]) if ss["llm_model"] in models else 0)
+    ss["llm_model"] = sel
+
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("#### Project Sites (max 4)")
+    # site list and management
+    site_names = map_pretty_sites()
+    st.sidebar.write("Active site:")
+    active = st.sidebar.radio("", options=site_names, index=ss["active_site_index"])
+    ss["active_site_index"] = site_names.index(active)
+
+    # Add site
+    if len(ss["sites"]) < 4:
+        new_name = st.sidebar.text_input("New site name", key="new_site_name_input")
+        if st.sidebar.button("➕ Add site") and new_name:
+            ss["sites"].append({
+                "Site Name": new_name,
+                "Site Coordinates": "",
+                "lat": None, "lon": None
+            })
+            ss["active_site_index"] = len(ss["sites"])-1
+            st.experimental_rerun()
+
+    # Show active site JSON
+    with st.sidebar.expander("Show active site JSON"):
+        st.json(get_active_site())
+
+    st.sidebar.markdown("---")
+    if st.sidebar.button("🔄 Reset Session (clear sites)"):
+        ss.clear()
+        st.experimental_rerun()
+
+# 13. Landing page
+def landing_ui():
+    st.markdown("<div style='display:flex;align-items:center;gap:16px'>"
+                "<div style='background:linear-gradient(135deg,#ff7a00,#ff3a3a); width:72px;height:72px;border-radius:16px;display:flex;align-items:center;justify-content:center'>"
+                "<span style='font-size:32px'>🛰️</span></div>"
+                "<div><h1 style='margin:0;color:#FF8C00'>GeoMate V2</h1>"
+                "<div style='color:#bfc9d9'>AI geotechnical copilot — Soil recognizer, classifier, locator, RAG, reports</div></div></div>",
+                unsafe_allow_html=True)
+    st.markdown("---")
+    st.markdown("""
+    **Quick actions**
+    """)
+    c1,c2,c3 = st.columns(3)
+    if c1.button("🧪 Classifier"):
+        ss["active_page"]="Soil Classifier"; st.rerun()
+    if c2.button("📊 GSD Curve"):
+        ss["active_page"]="GSD Curve"; st.rerun()
+    if c3.button("🌍 Locator"):
+        ss["active_page"]="Locator"; st.rerun()
+    st.markdown("---")
+    st.markdown("**Project summary**")
+    st.write(f"Sites configured: **{len(ss['sites'])}**")
+    st.write("Active site:")
+    st.write(get_active_site()["Site Name"])
+
+# 14. Soil Recognizer (placeholder — image model integration)
+def soil_recognizer_ui():
+    st.header("🖼️ Soil Recognizer (Image → Soil type)")
+    st.info("Upload an image of soil (photo or microscope). If you have a trained PyTorch model, upload `soil_best_model.pth` to the workspace and set model path below.")
+    img = st.file_uploader("Upload soil image", type=["png","jpg","jpeg"])
+    if img:
+        st.image(img, use_column_width=True)
+        st.success("Image received. (Model inference stub).")
+        # placeholder: run a stub classifier
+        st.markdown("**Predicted soil class (stub):** Silty clay (SC) — confidence: 0.72")
+
+# 15. Soil Classifier — conversational wizard (chat style)
+def soil_classifier_ui():
+    st.header("📋 Soil Classifier (Chat style)")
+
+    site_idx = ss["active_site_index"]
+    site = get_active_site()
+    if "classifier_step" not in site:
+        site["classifier_step"] = 0
+        site["classifier_inputs"] = {"opt":"n","P2":0.0,"P4":0.0,"D60":0.0,"D30":0.0,"D10":0.0,"LL":0.0,"PL":0.0,"nDS":5,"nDIL":6,"nTG":6}
+
+    step = site["classifier_step"]
+    ci = site["classifier_inputs"]
+
+    def bot(text):
+        st.markdown(f"<div class='bubble-bot'>{text}</div>", unsafe_allow_html=True)
+
+    def user(text):
+        st.markdown(f"<div class='bubble-user'>{text}</div>", unsafe_allow_html=True)
+
+    # Conversation steps (one at a time)
+    if step == 0:
+        bot("Hello — I am the GeoMate Soil Classifier. Ready to start? (This chat saves your answers automatically.)")
+        if st.button("Start classification"):
+            site["classifier_step"] = 1
+            st.rerun()
+        return
+
+    if step == 1:
+        bot("Is the soil organic (contains high organic matter, spongy, or odour)?")
+        col1,col2 = st.columns(2)
+        if col1.button("No"):
+            ci["opt"] = "n"
+            site["classifier_step"] = 2
+            st.rerun()
+        if col2.button("Yes"):
+            ci["opt"] = "y"
+            # If organic, we can classify as Pt and stop early
+            site["USCS"]="Pt"
+            site["AASHTO"]="Organic (special handling)"
+            site["classifier_decision_path"]="Organic branch (Pt)"
+            st.success("Soil marked as organic (Pt). Classification saved.")
+            return
+
+    if step == 2:
+        bot("Please enter the percentage passing the #200 sieve (0.075 mm). Example: 12")
+        val = st.number_input("Percentage passing #200", min_value=0.0, max_value=100.0, value=float(ci.get("P2",0.0)), step=1.0, format="%.2f", key=f"p2_{site_idx}")
+        if st.button("Confirm P2"):
+            ci["P2"]=float(val)
+            site["classifier_step"]=3
+            st.rerun()
+        return
+
+    if step == 3:
+        bot("What is the percentage passing sieve no. 4 (4.75 mm)?")
+        val = st.number_input("Percentage passing #4 (4.75 mm)", min_value=0.0, max_value=100.0, value=float(ci.get("P4",0.0)), step=1.0, format="%.2f", key=f"p4_{site_idx}")
+        if st.button("Confirm P4"):
+            ci["P4"]=float(val)
+            # decide branch: coarse or fine
+            if ci["P2"] <= 50:
+                site["classifier_step"]=4  # coarse branch asks D-values optionally
+            else:
+                site["classifier_step"]=6  # fine branch asks LL/PL
+            st.rerun()
+        return
+
+    if step == 4:
+        bot("Do you know D60, D30, and D10 (particle diameters in mm)?")
+        col1,col2 = st.columns(2)
+        if col1.button("Yes — I'll enter them"):
+            site["classifier_step"]=5
+            st.rerun()
+        if col2.button("No — I'll provide GSD later"):
+            # keep zeros
+            site["classifier_step"]=6
+            st.rerun()
+        return
+
+    if step == 5:
+        bot("Enter D60 (diameter in mm corresponding to 60% passing).")
+        D60 = st.number_input("D60 (mm)", min_value=0.0, value=float(ci.get("D60",0.0)), format="%.4f", key=f"d60_{site_idx}")
+        D30 = st.number_input("D30 (mm)", min_value=0.0, value=float(ci.get("D30",0.0)), format="%.4f", key=f"d30_{site_idx}")
+        D10 = st.number_input("D10 (mm)", min_value=0.0, value=float(ci.get("D10",0.0)), format="%.4f", key=f"d10_{site_idx}")
+        if st.button("Confirm D-values"):
+            ci["D60"]=float(D60); ci["D30"]=float(D30); ci["D10"]=float(D10)
+            site["classifier_step"]=6
+            st.rerun()
+        return
+
+    if step == 6:
+        bot("What is the Liquid Limit (LL)?")
+        LL = st.number_input("Liquid limit (LL)", min_value=0.0, max_value=200.0, value=float(ci.get("LL",0.0)), format="%.2f", key=f"ll_{site_idx}")
+        if st.button("Confirm LL"):
+            ci["LL"]=float(LL); site["classifier_step"]=7; st.rerun()
+        return
+
+    if step == 7:
+        bot("What is the Plastic Limit (PL)?")
+        PL = st.number_input("Plastic limit (PL)", min_value=0.0, max_value=200.0, value=float(ci.get("PL",0.0)), format="%.2f", key=f"pl_{site_idx}")
+        if st.button("Confirm PL"):
+            ci["PL"]=float(PL); site["classifier_step"]=8; st.rerun()
+        return
+
+    if step == 8:
+        bot("Select observed Dry Strength (text options).")
+        dry_options = ["None - slight","Medium - high","Slight - Medium","High - Very high","Null?"]
+        sel = st.selectbox("Dry strength", options=dry_options, index=dry_options.index("Slight - Medium") if ci.get("nDS") else 2, key=f"ds_{site_idx}")
+        # mapping to numbers consistent with logic: map to 1..5
+        dry_map = {"None - slight":1, "Medium - high":2, "Slight - Medium":3, "High - Very high":4, "Null?":5}
+        if st.button("Confirm dry strength"):
+            ci["nDS"]=dry_map[sel]; site["classifier_step"]=9; st.rerun()
+        return
+
+    if step == 9:
+        bot("Select observed Dilatancy (text options).")
+        dil_options = ["Quick to slow","None to very slow","Slow","Slow to none","None","Null?"]
+        sel = st.selectbox("Dilatancy", options=dil_options, index=0, key=f"dil_{site_idx}")
+        dil_map = {"Quick to slow":1,"None to very slow":2,"Slow":3,"Slow to none":4,"None":5,"Null?":6}
+        if st.button("Confirm dilatancy"):
+            ci["nDIL"]=dil_map[sel]; site["classifier_step"]=10; st.rerun()
+        return
+
+    if step == 10:
+        bot("Select observed Toughness (text options).")
+        tough_options = ["None","Medium","Slight?","Slight-Medium?","High","Null?"]
+        sel = st.selectbox("Toughness", options=tough_options, index=0, key=f"tg_{site_idx}")
+        tough_map = {"None":1,"Medium":2,"Slight?":3,"Slight-Medium?":4,"High":5,"Null?":6}
+        if st.button("Confirm toughness"):
+            ci["nTG"]=tough_map[sel]
+            # Now classify
+            res_text, uscs, aashto, GI, chars = uscs_aashto_verbatim(ci)
+            site["USCS"]=uscs; site["AASHTO"]=aashto; site["GI"]=GI
+            site["classifier_decision_path"]=res_text
+            site["classifier_step"]=11
+            st.success("Classification complete and saved.")
+            st.rerun()
+        return
+
+    if step == 11:
+        st.success("Classification finished.")
+        st.markdown("### Results")
+        st.markdown(site.get("classifier_decision_path","No decision path recorded"))
+        if st.button("Export classification PDF"):
+            fn = export_classification_pdf(site)
+            with open(fn,"rb") as f:
+                st.download_button("Download classification PDF", f, file_name=fn, mime="application/pdf")
+        # allow restart
+        if st.button("🔁 Start new classification"):
+            site["classifier_step"]=1
+            site["classifier_inputs"] = {"opt":"n","P2":0.0,"P4":0.0,"D60":0.0,"D30":0.0,"D10":0.0,"LL":0.0,"PL":0.0,"nDS":5,"nDIL":6,"nTG":6}
+            st.rerun()
+        return
+
+# 16. GSD UI
+def gsd_curve_ui():
+    st.header("📈 Grain Size Distribution (GSD) Curve")
+    site = get_active_site()
+    st.markdown("Enter diameters (mm) and % passing. Diameters should be in descending order (largest -> smallest).")
+    diam_input = st.text_area("Diameters (mm) comma-separated", value="75,50,37.5,25,19,12.5,9.5,4.75,2,0.85,0.425,0.25,0.18,0.15,0.075")
+    pass_input = st.text_area("% Passing (comma-separated)", value="100,98,96,90,85,78,72,65,55,45,35,25,18,14,8")
+    if st.button("Compute GSD"):
         try:
-            client = Groq(api_key=GROQ_API_KEY)
-            completion = client.chat.completions.create(
-                model=model_to_use,
-                messages=[{"role": "user", "content": prompt}],
-                temperature=0.2
-            )
-            return completion.choices[0].message.content
+            diams = [float(x.strip()) for x in diam_input.split(",") if x.strip()]
+            passing = [float(x.strip()) for x in pass_input.split(",") if x.strip()]
+            out = compute_and_plot_gsd(diams, passing)
+            fig = out["fig"]
+            st.pyplot(fig)
+            # store values
+            site["GSD"] = {"diameters":diams, "passing":passing, "D10":out["D10"], "D30":out["D30"], "D60":out["D60"], "Cu":out["Cu"], "Cc":out["Cc"]}
+            st.success(f"Saved GSD: D10={out['D10']:.4g}, D30={out['D30']:.4g}, D60={out['D60']:.4g}")
         except Exception as e:
-            return f"(Groq call failed: {e})"
-    # fallback: echo summary-like response
-    return f"(LLM unavailable) I received your prompt. Summary: {prompt[:400]}..."
-
-# ---------------------------
-# Simple extractor to pull numeric parameters from free text
-# ---------------------------
-NUM_RE = re.compile(r"(-?\d+\.?\d*)\s*(k?pa|psf|%|mm|m)?", re.IGNORECASE)
-def extract_parameters_from_text(text: str) -> Dict[str, Any]:
-    """
-    Primitive entity extraction: searches for tokens like 'bearing 200 kPa', 'CBR 8', etc.
-    This is heuristic — expand for production.
-    """
-    out = {}
-    txt = text.lower()
-    # patterns of interest
-    patterns = {
-        "Load Bearing Capacity": r"(bearing capacity|bearing)\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)\s*(kpa|psf)?",
-        "Relative Compaction": r"(compaction|relative compaction)\s*(?:is|:)?\s*([0-9]{1,3})\s*%",
-        "Skin Shear Strength": r"(skin shear|skin strength)\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)\s*(kpa)?",
-        "CBR": r"cbr\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)",
-        "Liquid Limit": r"(liquid limit|ll)\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)",
-        "Plastic Limit": r"(plastic limit|pl)\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)",
-        "D10": r"d10\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)",
-        "D30": r"d30\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)",
-        "D60": r"d60\s*(?:is|:)?\s*([0-9]+\.?[0-9]*)",
-    }
-    for key, pat in patterns.items():
-        m = re.search(pat, text, re.IGNORECASE)
-        if m:
-            val = float(m.group(2))
-            out[key] = val
-    # fallback: capture any numbers
-    nums = [float(m.group(1)) for m in NUM_RE.finditer(text)][:6]
-    if nums and not out:
-        out["misc_numbers"] = nums
-    return out
-
-# ---------------------------
-# PDF Builders (ReportLab for full report)
-# ---------------------------
-def build_full_geotech_pdf(site: Dict[str, Any], filename: str, external_refs: List[str] = []):
-    """
-    Build a professional PDF of the full geotechnical report using ReportLab.
-    """
-    buffer = io.BytesIO()
-    doc = SimpleDocTemplate(buffer, pagesize=A4, leftMargin=20*mm, rightMargin=20*mm, topMargin=25*mm, bottomMargin=20*mm)
-    styles = getSampleStyleSheet()
-    title_style = ParagraphStyle("Title", parent=styles["Title"], fontSize=20, alignment=1, textColor=colors.HexColor("#FF7A00"))
-    h1 = ParagraphStyle("H1", parent=styles["Heading1"], fontSize=14, textColor=colors.HexColor("#1F4E79"))
-    body = ParagraphStyle("Body", parent=styles["BodyText"], fontSize=10.5, leading=13)
-
-    elems = []
-
-    # Cover
-    elems.append(Paragraph(f"GEOTECHNICAL INVESTIGATION REPORT", title_style))
-    elems.append(Spacer(1,6))
-    elems.append(Paragraph(f"<b>Project:</b> {site.get('Site Name','-')}", body))
-    elems.append(Paragraph(f"<b>Date:</b> {datetime.today().strftime('%Y-%m-%d')}", body))
-    elems.append(Spacer(1,12))
-
-    # Sections following your template
-    elems.append(Paragraph("1.0 INTRODUCTION", h1))
-    intro_text = f"This report presents the results of the geotechnical investigation for {site.get('Site Name','the site')}."
-    elems.append(Paragraph(intro_text, body))
-    elems.append(Spacer(1,6))
-
-    elems.append(Paragraph("2.0 SITE DESCRIPTION AND GEOLOGY", h1))
-    site_desc = f"Coordinates: {site.get('lat','-')}, {site.get('lon','-')} - Topography: {site.get('Topography','-')}. Current land use: {site.get('Environmental Data','-')}."
-    elems.append(Paragraph(site_desc, body))
-    elems.append(Spacer(1,6))
-
-    elems.append(Paragraph("3.0 FIELD INVESTIGATION AND LABORATORY TESTING", h1))
-    field_txt = "Field program included test pits / boreholes and sample collection. See tables for lab results and CBR/compaction."
-    elems.append(Paragraph(field_txt, body))
-
-    # Lab table (if any)
-    lab_rows = site.get("lab_results", [])
-    if lab_rows:
-        elems.append(Spacer(1,6))
-        
+            st.error(f"GSD error: {e}\n{traceback.format_exc()}")
+
+# 17. Locator UI (EE + geemap) — robust with fallbacks
+def locator_ui():
+    st.header("🌍 Locator — Draw AOI & fetch environmental datasets")
+    site = get_active_site()
+    # Try to initialize EE only if credentials available
+    EE_AVAILABLE = False
+    try:
+        if ee is not None and (os.getenv("SERVICE_ACCOUNT") or os.getenv("EARTH_ENGINE_KEY")):
+            # Initialize
+            if not ss["ee_inited"]:
+                try:
+                    # if SERVICE_ACCOUNT holds json key or email
+                    if os.getenv("EARTH_ENGINE_KEY"):
+                        key_json = json.loads(os.getenv("EARTH_ENGINE_KEY"))
+                        creds = ee.ServiceAccountCredentials(key_json.get("client_email"), key_json)
+                        ee.Initialize(creds)
+                    else:
+                        sa = os.getenv("SERVICE_ACCOUNT")
+                        sa_dict = json.loads(sa)
+                        creds = ee.ServiceAccountCredentials(sa_dict.get("client_email"), sa_dict)
+                        ee.Initialize(creds)
+                    ss["ee_inited"] = True
+                except Exception as e:
+                    st.error(f"Earth Engine init error: {e}")
+            EE_AVAILABLE = ss["ee_inited"]
+    except Exception as e:
+        st.warning(f"EE init attempt failed: {e}")
+
+    if EE_AVAILABLE and geemap is not None:
+        # interactive geemap
+        try:
+            m = geemap.Map(center=[0,0], zoom=2)
+            m.add_basemap("SATELLITE")
+            m.add_draw_control()
+            m.to_streamlit(height=500)
+            st.markdown("Use drawing tools to mark AOI then press Extract Data.")
+            if st.button("Extract Data from Earth Engine"):
+                # Here we provide STUBS and indicate where to replace with real queries
+                # Example: sample elevation from SRTM, fetch CHIRPS rainfall, seismic catalogs, flood layers...
+                try:
+                    # STUB: Do some EE queries here to populate site dict.
+                    site["Soil Profile"] = "Colluvial soils over weathered dolomite (EE sample)"
+                    site["Flood Data"] = "No 20-year flood flagged (EE CHIRPS proxy)"
+                    site["Seismic Data"] = "Historic PGA moderate (EE seismic catalog proxy)"
+                    site["Topography"] = "Gentle slope; elevation approx. 250m (SRTM)"
+                    st.success("Data extracted (stub). Replace STUB with real EE queries.")
+                except Exception as e:
+                    st.error(f"Extraction failed: {e}")
+        except Exception as e:
+            st.error(f"Map rendering failed: {e}")
+    else:
+        st.warning("Earth Engine or geemap not available. You can still input coordinates manually.")
+        lat = st.number_input("Latitude", value=site.get("lat") or 0.0)
+        lon = st.number_input("Longitude", value=site.get("lon") or 0.0)
+        if st.button("Save coordinates"):
+            site["lat"]=lat; site["lon"]=lon
+            st.success("Coordinates saved.")
+
+# 18. RAG Ask UI
+def rag_ui():
+    st.header("🤖 GeoMate Ask (RAG + Groq)")
+    site = get_active_site()
+    st.markdown("This chat uses FAISS DB + Groq LLM. Upload a FAISS index folder (zipped) if not yet loaded.")
+    if not ss["faiss_loaded"]:
+        uploaded = st.file_uploader("Upload faiss_books_db.zip (index.faiss + meta.pkl)", type=["zip"])
+        if uploaded:
+            try:
+                with zipfile.ZipFile(uploaded, "r") as z:
+                    z.extractall("faiss_db")
+                ss["faiss_loaded"] = True
+                st.success("FAISS DB extracted to ./faiss_db")
+            except Exception as e:
+                st.error(f"FAISS extraction error: {e}")
+                return
+    # show chat history
+    hist = site.get("chat_history",[])
+    for m in hist:
+        role = m.get("role"); text = m.get("text")
+        if role=="user":
+            st.markdown(f"<div class='bubble-user'>{text}</div>", unsafe_allow_html=True)
+        else:
+            st.markdown(f"<div class='bubble-bot'>{text}</div>", unsafe_allow_html=True)
+    # query input
+    q = st.text_input("Ask GeoMate (RAG):", key=f"rag_input_{site['Site Name']}")
+    if st.button("Send"):
+        if not q.strip():
+            st.warning("Type a question.")
+        else:
+            # append user
+            site.setdefault("chat_history", []).append({"role":"user","text":q})
+            # placeholder retrieval & LLM call
+            # 1) retrieval from FAISS (if available) -> gather top docs
+            retrieved = " (retrieved docs stub) "
+            # 2) call Groq (if available)
+            if Groq is None:
+                ans = "(Groq SDK missing) Answer stub: " + q + retrieved
+            else:
+                try:
+                    client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+                    system = "You are GeoMate, technical geotechnical assistant. Use retrieved documents for deep answers. Use professional tone."
+                    messages = [{"role":"system","content":system}, {"role":"user","content":q + "\n\nRetrieved docs:\n" + retrieved}]
+                    resp = client.chat.completions.create(model=ss["llm_model"], messages=messages, temperature=0.2, max_tokens=1000)
+                    ans = resp.choices[0].message.content
+                except Exception as e:
+                    ans = f"(LLM call failed: {e})"
+            # append assistant
+            site.setdefault("chat_history", []).append({"role":"assistant","text":ans})
+            # attempt to auto-extract numeric/parameter info and save to site (simple heuristics)
+            lowq = q.lower()
+            try:
+                if "bearing" in lowq and any(ch.isdigit() for ch in q):
+                    # crude parse last number
+                    import re
+                    nums = re.findall(r"[-+]?\d*\.\d+|\d+", q)
+                    if nums:
+                        site["Load Bearing Capacity"] = nums[-1]
+                if "compaction" in lowq and any(ch.isdigit() for ch in q):
+                    import re
+                    nums = re.findall(r"[-+]?\d*\.\d+|\d+", q)
+                    if nums:
+                        site["Relative Compaction"] = nums[-1]
+            except Exception:
+                pass
+            st.experimental_rerun()
+
+# 19. Reports page — conversational gather + PDF exports (detailed)
+def reports_ui():
+    st.header("📑 Reports — Classification & Full Geotechnical Report")
+    site = get_active_site()
+    st.markdown("Generate classification-only report or a full geotechnical investigation report.")
+    col1,col2 = st.columns(2)
+    with col1:
+        st.subheader("Classification-only Report")
+        if not site.get("classifier_decision_path"):
+            st.info("No classification saved. Use Soil Classifier page.")
+        else:
+            st.markdown("Classification result:")
+            st.write(site.get("classifier_decision_path"))
+            if st.button("Export Classification PDF"):
+                fn = export_classification_pdf(site)
+                with open(fn,"rb") as f:
+                    st.download_button("Download Classification PDF", f, file_name=fn, mime="application/pdf")
+
+    with col2:
+        st.subheader("Full Geotechnical Report")
+        # show checklist of parameters we want
+        desired = [
+            "Load Bearing Capacity","Skin Shear Strength","Relative Compaction","Rate of Consolidation",
+            "Nature of Construction","Soil Profile","Flood Data","Seismic Data","Topography","GSD","USCS","AASHTO","GI"
+        ]
+        missing = [p for p in desired if not site.get(p)]
+        st.markdown(f"Missing parameters: **{len(missing)}**")
+        if st.button("Start conversational data collection"):
+            # set a convo state
+            site["report_convo_state"] = 0
+            st.experimental_rerun()
+
+        # conversational collector
+        if site.get("report_convo_state", None) is not None:
+            idx = site["report_convo_state"]
+            if idx < len(desired):
+                param = desired[idx]
+                st.markdown(f"**GeoMate:** Please provide **{param}** (or type 'skip'):")
+                entry = st.text_input(f"Enter {param}", key=f"rep_entry_{site['Site Name']}_{param}")
+                if st.button("Submit value", key=f"rep_submit_{param}"):
+                    if entry.strip().lower() != "skip" and entry.strip() != "":
+                        site[param] = entry.strip()
+                    site["report_convo_state"] = idx + 1
+                    st.experimental_rerun()
+            else:
+                st.success("Data collection complete.")
+                if st.button("Generate Full PDF Report"):
+                    fn = export_full_geotech_pdf(site)
+                    with open(fn,"rb") as f:
+                        st.download_button("Download Full Geotechnical Report", f, file_name=fn, mime="application/pdf")
+                if st.button("Generate Dummy Full Report"):
+                    fn = export_dummy_report(site)
+                    with open(fn,"rb") as f:
+                        st.download_button("Download Dummy Report", f, file_name=fn, mime="application/pdf")
+
+# 20. PDF export helpers (classification & full geotech using ReportLab if available, fallback to FPDF)
+def export_classification_pdf(site: Dict[str,Any]) -> str:
+    fn = f"{site.get('Site Name','site')}_classification_{now_str()}.pdf"
+    # Try ReportLab for nicer style
+    if 'reportlab' in globals() and reportlab_available := True:
+        try:
+            buf = io.BytesIO()
+            doc = SimpleDocTemplate(buf, pagesize=A4, leftMargin=18*mm, rightMargin=18*mm, topMargin=18*mm, bottomMargin=18*mm)
+            styles = getSampleStyleSheet()
+            elems = []
+            title_style = ParagraphStyle("title", parent=styles["Title"], fontSize=20, textColor=colors.HexColor("#FF7A00"))
+            elems.append(Paragraph("GeoMate Soil Classification Report", title_style))
+            elems.append(Spacer(1,6))
+            meta = f"Site: {site.get('Site Name','-')} • Date: {datetime.utcnow().strftime('%Y-%m-%d')}"
+            elems.append(Paragraph(meta, styles["Normal"]))
+            elems.append(Spacer(1,12))
+            elems.append(Paragraph("Classification result", styles["Heading2"]))
+            elems.append(Paragraph(site.get("classifier_decision_path","Not available"), styles["BodyText"]))
+            elems.append(Spacer(1,12))
+            elems.append(Paragraph("Inputs", styles["Heading3"]))
+            inputs = site.get("classifier_inputs",{})
+            data = [["Parameter","Value"]]
+            for k,v in inputs.items():
+                data.append([k,str(v)])
+            t = Table(data, colWidths=[80*mm,80*mm])
+            t.setStyle(TableStyle([("GRID",(0,0),(-1,-1),0.5,colors.grey),("BACKGROUND",(0,0),(-1,0),colors.HexColor("#1F4E79")),("TEXTCOLOR",(0,0),(-1,0),colors.white)]))
+            elems.append(t)
+            doc.build(elems)
+            with open(fn,"wb") as f:
+                f.write(buf.getvalue())
+            return fn
+        except Exception:
+            pass
+    # fallback to FPDF
+    if 'FPDF' in globals() and FPDF is not None:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Arial","B",16)
+        pdf.cell(0,10,"GeoMate Soil Classification Report",ln=True,align='C')
+        pdf.set_font("Arial","",12)
+        pdf.ln(6)
+        pdf.multi_cell(0,8, f"Site: {site.get('Site Name')}\nDate: {datetime.utcnow().strftime('%Y-%m-%d')}")
+        pdf.ln(4)
+        pdf.multi_cell(0,8, "Classification Result:")
+        pdf.multi_cell(0,8, site.get("classifier_decision_path","Not available"))
+        # inputs
+        pdf.ln(4)
+        pdf.multi_cell(0,8,"Inputs:")
+        for k,v in site.get("classifier_inputs",{}).items():
+            pdf.cell(0,6,f"- {k}: {v}", ln=True)
+        pdf.output(fn)
+        return fn
+    # last fallback: write text file
+    with open(fn.replace(".pdf",".txt"), "w") as f:
+        f.write(site.get("classifier_decision_path","Not available"))
+    return fn
+
+def export_full_geotech_pdf(site: Dict[str,Any]) -> str:
+    fn = f"{site.get('Site Name','site')}_FullGeotech_{now_str()}.pdf"
+    # Build a detailed PDF using ReportLab if possible
+    if 'reportlab' in globals():
+        try:
+            buf = io.BytesIO()
+            doc = SimpleDocTemplate(buf, pagesize=A4, leftMargin=18*mm, rightMargin=18*mm, topMargin=18*mm, bottomMargin=18*mm)
+            styles = getSampleStyleSheet()
+            elems=[]
+            title_style = ParagraphStyle("title", parent=styles["Title"], fontSize=18, textColor=colors.HexColor("#FF7A00"))
+            elems.append(Paragraph("Full Geotechnical Investigation Report", title_style))
+            elems.append(Spacer(1,8))
+            elems.append(Paragraph(f"Site: {site.get('Site Name','-')}  •  Date: {datetime.utcnow().strftime('%Y-%m-%d')}", styles["Normal"]))
+            elems.append(Spacer(1,10))
+            # 1. Project & Site
+            elems.append(Paragraph("1.0 Project & Site Information", styles["Heading2"]))
+            elems.append(Paragraph(f"Location: {site.get('Site Coordinates','Not provided')}", styles["BodyText"]))
+            elems.append(Spacer(1,8))
+            # 2. Field investigation
+            elems.append(Paragraph("2.0 Field Investigation & Observations", styles["Heading2"]))
+            fi_text = f"Soil Profile: {site.get('Soil Profile','Not provided')}\nFlood Data: {site.get('Flood Data','Not provided')}\nSeismic Data: {site.get('Seismic Data','Not provided')}\nTopography: {site.get('Topography','Not provided')}"
+            elems.append(Paragraph(fi_text.replace("\n","<br/>"), styles["BodyText"]))
+            elems.append(Spacer(1,8))
+            # 3. Lab results: show GSD table if available
+            elems.append(Paragraph("3.0 Laboratory Testing", styles["Heading2"]))
+            if site.get("GSD"):
+                g = site.get("GSD")
+                elems.append(Paragraph(f"GSD D10={g.get('D10')}, D30={g.get('D30')}, D60={g.get('D60')}, Cu={g.get('Cu')}, Cc={g.get('Cc')}", styles["BodyText"]))
+            else:
+                elems.append(Paragraph("GSD: Not provided", styles["BodyText"]))
+            elems.append(Spacer(1,8))
+            # 4. Analysis & Recommendations
+            elems.append(Paragraph("4.0 Evaluation & Recommendations", styles["Heading2"]))
+            # Quick evaluation based on USCS + other inputs
+            eval_lines=[]
+            eval_lines.append(f"USCS: {site.get('USCS','Not provided')}")
+            eval_lines.append(f"AASHTO: {site.get('AASHTO','Not provided')}")
+            eval_lines.append(f"Load bearing capacity: {site.get('Load Bearing Capacity','Not provided')}")
+            eval_lines.append("Recommendation: Preliminary—refer to detailed design after full testing.")
+            elems.append(Paragraph("<br/>".join(eval_lines), styles["BodyText"]))
+            elems.append(PageBreak())
+            doc.build(elems)
+            with open(fn,"wb") as f:
+                f.write(buf.getvalue())
+            return fn
+        except Exception as e:
+            st.error(f"ReportLab PDF build failed: {e}")
+    # fallback to simple FPDF
+    if 'FPDF' in globals() and FPDF is not None:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Arial","B",16)
+        pdf.cell(0,10,"Full Geotechnical Investigation Report",ln=True,align="C")
+        pdf.set_font("Arial","",11)
+        pdf.ln(6)
+        for k,v in site.items():
+            if k in ["classifier_inputs","chat_history","classifier_decision_path"]:
+                continue
+            pdf.multi_cell(0,7,f"{k}: {v if v else 'Not Provided'}")
+        pdf.output(fn)
+        return fn
+    # else return text fallback
+    fn_txt = fn.replace(".pdf",".txt")
+    with open(fn_txt,"w") as f:
+        for k,v in site.items():
+            f.write(f"{k}: {v}\n")
+    return fn_txt
+
+def export_dummy_report(site:Dict[str,Any]) -> str:
+    fn = f"{site.get('Site Name','site')}_Dummy_{now_str()}.pdf"
+    if 'FPDF' in globals() and FPDF is not None:
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Arial","B",18)
+        pdf.cell(0,10,"GeoMate — Dummy Geotechnical Report", ln=True, align="C")
+        pdf.ln(8)
+        pdf.set_font("Arial","",12)
+        pdf.multi_cell(0,8,"This dummy report is for layout testing. The final report will be more comprehensive and include charts, maps and tables.")
+        pdf.ln(6)
+        pdf.multi_cell(0,8,"Sample Conclusions:\n- Site is underlain by colluvial soils.\n- Recommended foundation: raft or piles depending on load.\n- Further testing (CPT, triaxial) recommended.")
+        pdf.output(fn)
+        return fn
+    else:
+        # fallback text
+        fn_txt = fn.replace(".pdf",".txt")
+        with open(fn_txt,"w") as f:
+            f.write("Dummy report (text fallback)\n")
+        return fn_txt
+
+# 21. Main page router
+PAGES = {
+    "Landing": landing_ui,
+    "Soil Recognizer": soil_recognizer_ui,
+    "Soil Classifier": soil_classifier_ui,
+    "GSD Curve": gsd_curve_ui,
+    "Locator": locator_ui,
+    "GeoMate Ask": rag_ui,
+    "Reports": reports_ui
+}
+
+def main():
+    sidebar_ui()
+    # top-level nav (use session page)
+    if "active_page" not in ss:
+        ss["active_page"]="Landing"
+    # small nav bar at top
+    cols = st.columns([1,3,1])
+    with cols[1]:
+        choice = st.selectbox("Open Page", options=list(PAGES.keys()), index=list(PAGES.keys()).index(ss["active_page"]))
+    ss["active_page"] = choice
+
+    # call page function
+    try:
+        page_func = PAGES.get(ss["active_page"], landing_ui)
+        page_func()
+    except Exception as e:
+        st.error(f"Page error: {e}\n{traceback.format_exc()}")
+
+if __name__ == "__main__":
+    main()