Deploy QueryLens (Gradio-SDK launcher: worker :8700 / MCP :8701 / web :7860)

Agent/agentic_workflow.py

@@ -834,6 +834,7 @@ PLACEHOLDER_REGEXES = [
 # Global readiness flag so we can re-attempt handshake before first real generation
 LLM_HANDSHAKE_COMPLETE = False
 LAST_GENERATED_SQL = None  # updated each time a final SQL statement is produced
+LAST_MCP_HINT_SQL = None   # last validated fast-SQL hint (deterministic fallback path)
 # Cached real department names from DB — populated during initialize_database
 # Fallback: known employee-DB departments (used if DB query fails)
 _cached_dept_names: set = {
@@ -848,7 +849,11 @@ def build_cloud_llm():
     This is the same path used on Hugging Face Spaces. It is also used as an
     automatic fallback inside initialize_llm() when the configured local
     Ollama model is not installed.
-    """
+
+    Credits-resilience: on HF Inference 402/401/429 (credits exhausted, expired
+    token, rate limit) the same prompt is re-issued to Groq's OpenAI-compatible
+    endpoint (GROQ_API_KEY is already a Space secret). Model is configurable via
+    GROQ_LLM_MODEL (default: llama-3.3-70b-versatile)."""
     hf_token = os.environ.get("HF_API_TOKEN")
     hf_model = os.environ.get("HF_LLM_MODEL", "Qwen/Qwen2.5-Coder-7B-Instruct")
     if not hf_token:
@@ -874,11 +879,23 @@ def build_cloud_llm():
             # Talk directly to HF serverless pool using the Chat Completion API
             # This satisfies providers that require the "conversational" task
             hf_client = InferenceClient(model=self.model_name, token=hf_token)
-            resp = hf_client.chat_completion(
-                messages=[{"role": "user", "content": prompt}],
-                max_tokens=1024
-            )
-            return CompletionResponse(text=resp.choices[0].message.content)
+            try:
+                resp = hf_client.chat_completion(
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=1024
+                )
+                return CompletionResponse(text=resp.choices[0].message.content)
+            except Exception as hf_exc:
+                if _is_provider_quota_error(hf_exc):
+                    print(f"[LLM-FALLBACK] HF Inference unavailable "
+                          f"({hf_exc.__class__.__name__}); falling back to Groq "
+                          f"text model '{GROQ_TEXT_MODEL}'", flush=True)
+                    try:
+                        groq_text = _groq_text_completion(prompt)
+                        return CompletionResponse(text=groq_text)
+                    except Exception as groq_exc:
+                        print(f"[LLM-FALLBACK] Groq fallback also failed: {groq_exc}", flush=True)
+                raise
 
         def stream_complete(self, prompt: str, **kwargs):
             # Not needed for our agent, but required by base class
@@ -901,6 +918,44 @@ def build_cloud_llm():
     return llm
 
 
+def _is_provider_quota_error(exc: Exception) -> bool:
+    """Detect HF Inference failures that a Groq fallback can plausibly fix:
+    out of credits (402), expired/missing token (401) and rate limits (429)."""
+    status = getattr(exc, "status_code", None)
+    if status is None:
+        response = getattr(exc, "response", None)
+        status = getattr(response, "status_code", None)
+    if status in (401, 402, 429):
+        return True
+    msg = str(exc)
+    return any(sig in msg for sig in (
+        "402", "Payment Required", "no remaining credits",
+        "401", "Unauthorized", "429", "rate limit",
+    ))
+
+
+GROQ_TEXT_MODEL = os.environ.get("GROQ_LLM_MODEL", "llama-3.3-70b-versatile")
+
+
+def _groq_text_completion(prompt: str, max_tokens: int = 1024, timeout: float = 90.0) -> str:
+    """Plain chat completion against Groq's OpenAI-compatible endpoint."""
+    groq_key = os.environ.get("GROQ_API_KEY")
+    if not groq_key:
+        raise RuntimeError("GROQ_API_KEY is not set; Groq text-LLM fallback unavailable")
+    r = requests.post(
+        "https://api.groq.com/openai/v1/chat/completions",
+        headers={"Authorization": f"Bearer {groq_key}"},
+        json={
+            "model": GROQ_TEXT_MODEL,
+            "messages": [{"role": "user", "content": prompt}],
+            "max_tokens": max_tokens,
+        },
+        timeout=timeout,
+    )
+    r.raise_for_status()
+    return r.json()["choices"][0]["message"]["content"]
+
+
 def _ollama_model_available(model_name: str, base_url: str) -> bool:
     """Return True if the given model tag exists on the Ollama server.
 
@@ -2555,6 +2610,11 @@ def get_mcp_hint_if_available(question: str):
         if isinstance(tool_res, dict) and 'sql' in tool_res:
             sql = tool_res['sql']
             _fast_log('TOOL_SQL', ms=int(dur*1000), sql_preview=sql[:160])
+            # Remember for the deterministic post-3-level fallback (see the
+            # "All 3 levels failed" block): if every LLM call fails due to
+            # provider outage/credits, this schema-true SQL still answers.
+            global LAST_MCP_HINT_SQL
+            LAST_MCP_HINT_SQL = sql
             return sql  # Return as hint
         else:
             _fast_log('NO_SQL', raw=tool_res)
@@ -3951,6 +4011,17 @@ def query_craft(question: str) -> str:
     
     # All 3 levels failed
     print("[3-LEVEL] ✗ All 3 levels failed to generate valid SQL")
+    # Deterministic last resort: the MCP fast-SQL hint produced during Level 3
+    # is schema-true and question-matched. If all LLM calls failed because of
+    # provider outage / exhausted credits, return it instead of erroring out.
+    if LAST_MCP_HINT_SQL:
+        try:
+            if is_sql_valid(LAST_MCP_HINT_SQL, question):
+                print("[3-LEVEL] ✓ FALLBACK: using deterministic MCP fast-SQL hint as final answer")
+                print(f"[GEN] Final SQL: {LAST_MCP_HINT_SQL[:200]}")
+                return LAST_MCP_HINT_SQL
+        except Exception as fb_err:
+            print(f"[3-LEVEL] MCP fast-SQL fallback skipped: {fb_err}")
     raise ValueError("Unable to generate SQL query after 3-level attempts; try rephrasing.")
     # salvage path (unreachable due to raise above, kept for reference)
 

Agent/worker.py

@@ -124,27 +124,40 @@ async def startup_event():
         try:
             await agent.initialize_database(uri=target_uri)
             # Keep the registry's active entry in sync with what we connected to.
+            # IMPORTANT: force the booted database to OWN the active slot — the
+            # demo registration above grabs "active" on a fresh store (ProfileRegistry
+            # .add() activates when no active exists), which left Space deployments
+            # showing the demo DB even though the env DB_CONNECTION_URL booted.
             try:
-                if profile_registry.active_id is None:
+                entries = profile_registry.list()
+                match = next(
+                    (p for p in entries
+                     if ((p.get("db_url") or "").replace("\\", "/") == target_uri.replace("\\", "/"))),
+                    None,
+                )
+                if match is None:
                     prof = getattr(agent, "ACTIVE_SCHEMA_PROFILE", None)
-                    _kind = "demo" if (prof and prof.is_employee_db) else "user"
+                    _from_env = bool(db_url and target_uri == db_url)
+                    _kind = "user" if _from_env else (
+                        "demo" if (prof and getattr(prof, "is_employee_db", False)) else "user")
+                    _name = (getattr(prof, "name", None) if prof else None) or (
+                        "Employee_DB" if _from_env else "demo_employee")
                     pid = f"boot_{uuid.uuid4().hex[:8]}"
                     profile_registry.profiles[pid] = {
-                        "name": (prof.name if prof else "startup_db") or "startup_db",
+                        "name": _name,
                         "db_url": target_uri,
                         "kind": _kind,
                         "created_at": __import__("time").time(),
                     }
                     profile_registry.active_id = pid
                     profile_registry.save()
-                    print(f"[WORKER] Registered active schema profile '{pid}' for {target_uri}")
+                    print(f"[WORKER] Registered ACTIVE schema profile '{_name}' (kind={_kind}) for env DB")
                 else:
-                    # point the active id at the profile that owns target_uri
-                    entries = profile_registry.list()
-                    match = next((p for p in entries if (p.get("db_url") or "").replace("\\", "/") == target_uri.replace("\\", "/")), None)
-                    if match and profile_registry.active_id != match["id"]:
+                    if profile_registry.active_id != match["id"]:
                         profile_registry.switch(match["id"])
                         print(f"[WORKER] Active profile switched to '{match['name']}'")
+                    else:
+                        print(f"[WORKER] Active profile already '{match['name']}'")
             except Exception as reg_err:
                 print(f"[WORKER] profile bootstrap skipped: {reg_err}")
         except Exception as e: