Update neuravend.py

neuravend.py

@@ -11,14 +11,12 @@ from dataclasses import dataclass, field, asdict
 from typing import Any, Dict, List, Optional, Tuple
 
 # CRITICAL FIX: Ensure all required third-party libraries are imported
-# at the top level for module execution and type hints.
 import numpy as np
 import pandas as pd
 import requests
-# The google.generativeai import is handled within the load_gemini function
-# but we need to ensure the requirements.txt is correct (which we fixed previously).
 
-# Logging
+# --- Logging and Metrics ---
+
 LOG_FN = "neuravend.log"
 logging.basicConfig(
     level=logging.INFO,
@@ -59,7 +57,8 @@ class Session:
             return cls(**data)
         return None
 
-# Gemini optional loader
+# --- Gemini Configuration (Fallback Safe) ---
+
 def load_gemini():
     key = os.environ.get("GEMINI_API_KEY") or os.environ.get("AI_API_KEY")
     if not key:
@@ -68,7 +67,6 @@ def load_gemini():
     try:
         import google.generativeai as genai
         genai.configure(api_key=key)
-        # Attempt to get the model in a modern way
         try:
             model = genai.GenerativeModel("gemini-1.5-flash")
         except Exception as e:
@@ -77,7 +75,6 @@ def load_gemini():
             
         if model:
             logger.info("Gemini configured (optional).")
-            # Return the genai module and the configured model instance
             return (genai, model), True
     except Exception as e:
         logger.warning(f"Gemini SDK init failed: {e}; continuing offline.")
@@ -93,7 +90,8 @@ def _set_seed():
     logger.info("Internal seed set.")
 _set_seed()
 
-# Vendor synthesis
+# --- Vendor Synthesis ---
+
 NAME_WORDS = ["Astra", "Blue", "Nova", "Prime", "Eco", "Vertex", "Luma", "Grid", "Core", "Pioneer", "Green"]
 SUFFIX = ["Ltd", "Pvt Ltd", "Inc", "LLC", "Corp"]
 
@@ -104,6 +102,7 @@ def synthesize_vendors(n: int = 10, scenario: str = "Normal") -> pd.DataFrame:
     rows = []
     for i in range(n):
         name = gen_name(i)
+        # Data synthesis logic based on scenario
         if scenario == "Disruption":
             cost = int(max(1000, random.gauss(11000, 3000)))
             quality = int(min(100, max(40, random.gauss(72, 10))))
@@ -122,7 +121,7 @@ def synthesize_vendors(n: int = 10, scenario: str = "Normal") -> pd.DataFrame:
             delivery = int(max(1, random.gauss(9, 4)))
             risk = int(min(100, max(10, random.gauss(45, 15))))
             ethics = int(min(100, max(20, random.gauss(60, 15))))
-        else:
+        else: # Normal
             cost = int(max(1000, random.gauss(10000, 2000)))
             quality = int(min(100, max(45, random.gauss(75, 8))))
             delivery = int(max(1, random.gauss(7, 2)))
@@ -134,27 +133,7 @@ def synthesize_vendors(n: int = 10, scenario: str = "Normal") -> pd.DataFrame:
         df[col] = df[col].astype(int)
     return df
 
-# DuckDuckGo search wrapper
-def duckduckgo_search(query: str, max_items: int = 5) -> List[Dict[str, str]]:
-    metrics["search_calls"] += 1
-    save_metrics()
-    try:
-        r = requests.get("https://api.duckduckgo.com/",
-                         params={"q": query, "format": "json", "no_redirect": 1, "no_html": 1},
-                         timeout=10)
-        data = r.json()
-        out = []
-        if data.get("AbstractText"):
-            out.append({"source": "DDG", "text": data["AbstractText"]})
-        for topic in data.get("RelatedTopics", []):
-            if isinstance(topic, dict) and topic.get("Text"):
-                out.append({"source": "DDG", "text": topic["Text"]})
-            elif isinstance(topic, dict) and topic.get("Name"):
-                out.append({"source": "DDG", "text": topic.get("Name")})
-        return out[:max_items]
-    except Exception:
-        logger.warning("DuckDuckGo search failed; returning empty list.")
-        return []
+# --- LLM and Offline Fallback ---
 
 # Gemini safe-call
 def gemini_safe_call(prompt: str, max_output_tokens: int = 200) -> Tuple[bool, str]:
@@ -163,9 +142,6 @@ def gemini_safe_call(prompt: str, max_output_tokens: int = 200) -> Tuple[bool, s
         return False, ""
     try:
         genai, model = GENAI_ENV
-        
-        # Use the standard generate_content call for modern SDKs
-        # Note: We configured model to be a GenerativeModel instance in load_gemini
         resp = model.generate_content(prompt, 
                                       generation_config=genai.types.GenerateContentConfig(
                                           max_output_tokens=max_output_tokens
@@ -173,7 +149,6 @@ def gemini_safe_call(prompt: str, max_output_tokens: int = 200) -> Tuple[bool, s
         metrics["gemini_calls"] += 1; save_metrics()
         text = getattr(resp, "text", str(resp))
         return True, text.strip()
-        
     except Exception as e:
         logger.warning(f"Gemini call failed: {e}")
         USE_GEMINI = False
@@ -185,66 +160,58 @@ def offline_profile_str(row: pd.Series) -> str:
     return (f"{row['VendorID']}: cost {row['Cost']}, quality {row['Quality']}/100, "
             f"delivery {row['DeliveryTime']} days, risk {row['Risk']}/100, ethics {row.get('Ethics', 0)}/100.")
 
-def offline_search_sim(query: str, vendors_df: pd.DataFrame, top_k: int = 5) -> List[Dict[str, Any]]:
-    scores = []
-    q = query.lower()
-    for _, r in vendors_df.iterrows():
-        s = 0.2 * (r["Quality"] / 100.0) + 0.2 * (1 - r["Risk"] / 100.0) + 0.2 * (1 - r["DeliveryTime"] / 20.0)
-        if "cost" in q or "cheap" in q:
-            s += 0.3 * (1 - (r["Cost"] / max(1, vendors_df["Cost"].max())))
-        if "ethical" in q or "eco" in q or "sustain" in q:
-            s += 0.3 * (r["Ethics"] / 100.0)
-        scores.append((s, r))
-    scores.sort(key=lambda x: x[0], reverse=True)
-    out = []
-    for s, r in scores[:top_k]:
-        d = r.to_dict()
-        d["relevance_score"] = float(round(s, 4))
-        out.append(d)
-    return out
-
-# TOPSIS MCDA
+# --- TOPSIS MCDA ---
 def topsis_scores(df: pd.DataFrame, criteria: List[str], weights: List[float], criteria_type: Dict[str, str]) -> pd.DataFrame:
     X = df[criteria].astype(float).values
     w = np.array(weights, dtype=float)
     if w.sum() == 0:
+        # Handle zero weights by raising an error or defaulting, raise for robustness
         raise ValueError("Weights sum to zero")
     w = w / w.sum()
+    
+    # 1. Normalization (Vector Normalization)
     denom = np.sqrt((X**2).sum(axis=0)); denom[denom == 0] = 1e-12
     R = X / denom
+    
+    # 2. Weighted Normalized Decision Matrix
     V = R * w
+    
+    # 3. Determine Ideal Best (A+) and Ideal Worst (A-)
     m = V.shape[1]
     ideal_best = np.zeros(m); ideal_worst = np.zeros(m)
     for j, crit in enumerate(criteria):
         if criteria_type[crit] == 'benefit':
             ideal_best[j] = V[:, j].max(); ideal_worst[j] = V[:, j].min()
-        else:
+        else: # cost
             ideal_best[j] = V[:, j].min(); ideal_worst[j] = V[:, j].max()
+            
+    # 4. Calculate Separation Measure (Euclidean distance)
     dist_best = np.sqrt(((V - ideal_best) ** 2).sum(axis=1))
     dist_worst = np.sqrt(((V - ideal_worst) ** 2).sum(axis=1))
+    
+    # 5. Calculate Relative Closeness (TOPSIS Score)
     denom2 = dist_best + dist_worst; denom2[denom2 == 0] = 1e-12
     score = dist_worst / denom2
+    
+    # 6. Final Results
     res = df.copy().reset_index(drop=True)
     res["TOPSIS_Score"] = score
     res["Rank"] = res["TOPSIS_Score"].rank(ascending=False, method="min").astype(int)
     return res.sort_values("Rank").reset_index(drop=True)
 
-# Agent base
+# --- Agent System ---
+
 class Agent:
     def __init__(self, name: str, session: Session):
         self.name = name
         self.session = session
         self.log = logging.getLogger(name)
 
-    def run(self, *args, **kwargs):
-        raise NotImplementedError
-
     def log_event(self, tag: str, details: Dict[str, Any]):
         self.session.history.append({"time": time.time(), "agent": self.name, "tag": tag, "details": details})
         self.session.persist()
         self.log.info(f"{self.name}:{tag}")
 
-# DataRetrievalAgent
 class DataRetrievalAgent(Agent):
     def __init__(self, name: str, session: Session, vendors_df: pd.DataFrame):
         super().__init__(name, session)
@@ -253,7 +220,6 @@ class DataRetrievalAgent(Agent):
     def run(self, query: str = "general market scan") -> pd.DataFrame:
         enriched = []
         for idx, row in self.vendors_df.iterrows():
-            # Use 'Description' column for LLM enrichment if available, otherwise fallback
             prompt = f"Provide a 1-2 sentence procurement profile for: {row.to_dict()}"
             ok, text = gemini_safe_call(prompt, max_output_tokens=120) if USE_GEMINI else (False, "")
             enriched.append(text if (ok and text) else offline_profile_str(row))
@@ -261,7 +227,6 @@ class DataRetrievalAgent(Agent):
         self.log_event("data_enriched", {"count": len(enriched)})
         return self.vendors_df
 
-# EvaluationAgent
 class EvaluationAgent(Agent):
     def __init__(self, name: str, session: Session):
         super().__init__(name, session)
@@ -269,6 +234,8 @@ class EvaluationAgent(Agent):
     def run(self, vendors_df: pd.DataFrame, scenarios: Dict[str, List[float]], criteria: List[str], criteria_type: Dict[str, str], perturb: bool = True) -> Dict[str, Any]:
         results = {}
         for scen_name, weights in scenarios.items():
+            
+            # Weight perturbation logic
             if perturb:
                 delta = np.random.normal(0, 0.02, size=len(weights))
                 w = np.array(weights) + delta
@@ -278,20 +245,20 @@ class EvaluationAgent(Agent):
                 w = list(w / w.sum())
             else:
                 w = weights
-            
-            # CRITICAL CHECK: Ensure weights have the same length as criteria
+
+            # CRITICAL CHECK: Weights length validation
             if len(w) != len(criteria):
                  self.log.error(f"Weights length ({len(w)}) does not match criteria length ({len(criteria)}) for scenario {scen_name}. Skipping.")
                  continue
-
+                 
             res = topsis_scores(vendors_df, criteria, w, criteria_type)
             results[scen_name] = {"meta": {"weights": [float(x) for x in w]}, "result_table": res.to_dict(orient="list")}
             self.log_event("scenario_scored", {"scenario": scen_name, "top1": res.iloc[0]["VendorID"]})
-        self.session.topsis_results = results
+            
+        self.session.topsis_results.update(results) # Use update to preserve compliance iterations
         self.session.persist()
         return results
 
-# EthicsAgent
 class EthicsAgent(Agent):
     def __init__(self, name: str, session: Session):
         super().__init__(name, session)
@@ -306,36 +273,6 @@ class EthicsAgent(Agent):
         self.log_event("ethics_evaluated", {"avg_penalty": float(np.mean(penalties))})
         return vendors_df
 
-# DecisionAgent
-class DecisionAgent(Agent):
-    def __init__(self, name: str, session: Session):
-        super().__init__(name, session)
-
-    def run(self, chosen: Optional[Dict[str, Any]], initial_top: Optional[Dict[str, Any]], scenario_name: str, risk_threshold: float) -> str:
-        prompt = (f"You are a procurement analyst. Explain why '{chosen.get('vendor') if chosen else 'None'}' is selected over '{initial_top.get('VendorID') if initial_top else 'None'}'. "
-                  f"Include key tradeoffs and next steps. Scenario: {scenario_name}, risk threshold: {risk_threshold}.")
-        ok, text = gemini_safe_call(prompt, max_output_tokens=250) if USE_GEMINI else (False, "")
-        if ok and text:
-            report = text
-        else:
-            report = (f"Selected {chosen.get('vendor') if chosen else 'None'}: meets compliance checks and offers acceptable tradeoffs. "
-                      f"Initial top candidate: {initial_top.get('VendorID') if initial_top else 'None'}. Next steps: due diligence, reference checks.")
-        self.session.mem["last_explanation"] = report
-        self.session.persist()
-        self.log_event("decision_explained", {"chosen": chosen})
-        return report
-
-# ReportAgent
-class ReportAgent(Agent):
-    def __init__(self, name: str, session: Session):
-        super().__init__(name, session)
-
-    def run(self, session: Session) -> Dict[str, Any]:
-        summary = {"session_id": session.session_id, "scenarios": list(session.topsis_results.keys())}
-        self.log_event("report_generated", {"scenarios": len(summary["scenarios"])})
-        return summary
-
-# ComplianceAgent
 class ComplianceAgent(Agent):
     def __init__(self, name: str, session: Session, risk_threshold: float = 50, max_iters: int = 5):
         super().__init__(name, session)
@@ -344,8 +281,7 @@ class ComplianceAgent(Agent):
 
     def _assess(self, row: Dict[str, Any]) -> List[str]:
         issues = []
-        # CRITICAL FIX: Ensure 'Risk' is accessed via .get() to avoid KeyError if data structure is missing it
-        # Note: Since the DataFrame is created here, this is mainly for robustness.
+        # Check risk threshold and quality compliance
         if row.get("Risk", 100) > self.risk_threshold:
             issues.append("HighRisk")
         if row.get("Quality", 0) < 60:
@@ -354,7 +290,6 @@ class ComplianceAgent(Agent):
 
     def find_compliant(self, topsis_df: pd.DataFrame) -> Optional[Dict[str, Any]]:
         for _, r in topsis_df.iterrows():
-            # Pass dictionary row to _assess
             if not self._assess(r.to_dict()):
                 return {"vendor": r["VendorID"], "row": r.to_dict()}
         return None
@@ -368,7 +303,6 @@ class ComplianceAgent(Agent):
         for name, out in session.topsis_results.items():
             if "result_table" not in out:
                 continue
-            # CRITICAL FIX: Ensure result_table is converted to a DataFrame before use
             try:
                 df = pd.DataFrame(out["result_table"])
             except Exception as e:
@@ -381,32 +315,33 @@ class ComplianceAgent(Agent):
                 chosen_scenario = name
                 break
                 
-        # 2. Iterate if no compliant vendor found
+        # 2. Iteratively re-run if no compliant vendor is found
         while chosen is None and iterations < self.max_iters:
             iterations += 1
+            # Define new weights to try finding a compliant vendor
             if iterations == 1:
                 new = {"W_risk_strong": [0.1, 0.2, 0.2, 0.5]}
             elif iterations == 2:
                 new = {"W_quality_strong": [0.15, 0.6, 0.15, 0.1]}
             else:
-                new = {"W_balanced": [0.25, 0.35, 0.2, 0.2]}
+                new = {"W_balanced_recheck": [0.25, 0.35, 0.2, 0.2]}
             
             eval_agent = EvaluationAgent("EvalInner", session)
-            # CRITICAL FIX: Read vendor data from JSON string back into a DataFrame
-            # This ensures the EvaluationAgent has the necessary data frame.
+            # Recreate DataFrame from JSON string for inner loop consistency
             vendors_df_from_json = pd.read_json(session.vendors_df_json, orient="records")
             
+            # Run evaluation with new weights
             new_results = eval_agent.run(vendors_df_from_json, new, criteria, criteria_type, perturb=True)
             session.topsis_results.update(new_results)
             session.persist()
             
+            # Check new results
             for name, out in new_results.items():
                 if "result_table" not in out:
                     continue
                 try:
                     df = pd.DataFrame(out["result_table"])
-                except Exception as e:
-                    self.log.error(f"Failed to create DataFrame in iteration {iterations}: {e}")
+                except Exception:
                     continue
                     
                 candidate = self.find_compliant(df)
@@ -420,16 +355,52 @@ class ComplianceAgent(Agent):
         self.log_event("compliance_completed", {"iterations": iterations, "chosen": bool(chosen)})
         return {"iterations": iterations, "found": bool(chosen), "chosen": chosen, "chosen_scenario": chosen_scenario}
 
-# Orchestrator
+class DecisionAgent(Agent):
+    def __init__(self, name: str, session: Session):
+        super().__init__(name, session)
+
+    def run(self, chosen: Optional[Dict[str, Any]], initial_top: Optional[Dict[str, Any]], scenario_name: str, risk_threshold: float) -> str:
+        
+        chosen_vendor_id = chosen.get('vendor') if chosen else 'None'
+        initial_top_id = initial_top.get('VendorID') if initial_top else 'None'
+        
+        prompt = (f"You are a procurement analyst. Explain why '{chosen_vendor_id}' is selected over '{initial_top_id}'. "
+                  f"Include key tradeoffs and next steps. Scenario: {scenario_name}, risk threshold: {risk_threshold}.")
+                  
+        ok, text = gemini_safe_call(prompt, max_output_tokens=250) if USE_GEMINI else (False, "")
+        
+        if ok and text:
+            report = text
+        else:
+            report = (f"Selected **{chosen_vendor_id}**: meets compliance checks (Risk < {risk_threshold}, Quality > 60) and offers acceptable tradeoffs. "
+                      f"Initial top candidate (before compliance check): **{initial_top_id}**. Next steps: conduct due diligence and reference checks.")
+                      
+        self.session.mem["last_explanation"] = report
+        self.session.persist()
+        self.log_event("decision_explained", {"chosen": chosen})
+        return report
+
+class ReportAgent(Agent):
+    def __init__(self, name: str, session: Session):
+        super().__init__(name, session)
+
+    def run(self, session: Session) -> Dict[str, Any]:
+        summary = {"session_id": session.session_id, "scenarios": list(session.topsis_results.keys())}
+        self.log_event("report_generated", {"scenarios": len(summary["scenarios"])})
+        return summary
+
+# --- Orchestrator ---
+
 def run_full_pipeline(n_vendors: int = 10, profile_weights: Optional[Dict[str, List[float]]] = None, scenario: str = "Normal", risk_threshold: float = 50) -> Tuple[Session, Dict[str, Any]]:
+    
     session = Session.load() or Session()
-    vendors_df = synthesize_vendors(n_vendors, scenario)
     
-    # Store the vendors DataFrame as a JSON string in the session object
+    # --- 1. Synthesis & Setup ---
+    vendors_df = synthesize_vendors(n_vendors, scenario)
     session.vendors_df_json = vendors_df.to_json(orient="records")
     session.persist()
 
-    # Data Retrieval and Ethics Agents run first
+    # --- 2. Data & Ethics Processing ---
     data_agent = DataRetrievalAgent("DataAgent", session, vendors_df)
     vendors_df = data_agent.run(query="market scan")
     ethics_agent = EthicsAgent("EthicsAgent", session)
@@ -439,27 +410,27 @@ def run_full_pipeline(n_vendors: int = 10, profile_weights: Optional[Dict[str, L
     criteria_type = {"Cost": "cost", "Quality": "benefit", "DeliveryTime": "cost", "Risk": "cost"}
     scenarios = profile_weights or {"ProfileBase": [0.25, 0.35, 0.2, 0.2], "Equal": [0.25, 0.25, 0.25, 0.25]}
     
-    # Evaluation Agent (Initial TOPSIS run)
+    # --- 3. Initial Evaluation ---
     eval_agent = EvaluationAgent("EvalAgent", session)
-    eval_results = eval_agent.run(vendors_df, scenarios, criteria, criteria_type, perturb=True)
+    eval_agent.run(vendors_df, scenarios, criteria, criteria_type, perturb=True)
 
-    # Compliance Agent (Check compliance and re-run TOPSIS if needed)
+    # --- 4. Compliance Check & Rerun Loop ---
     comp_agent = ComplianceAgent("CompAgent", session, risk_threshold=risk_threshold, max_iters=4)
     comp_out = comp_agent.run(session, scenarios, criteria, criteria_type)
     chosen = comp_out.get("chosen")
-    chosen_scenario = comp_out.get("chosen_scenario") or list(scenarios.keys())[0] # Fallback to first scenario name
+    chosen_scenario = comp_out.get("chosen_scenario") or list(scenarios.keys())[0]
 
-    # Decision Agent (Generate explanation)
+    # --- 5. Decision & Reporting ---
     initial_top = None
     if chosen_scenario and session.topsis_results.get(chosen_scenario):
         rt = session.topsis_results[chosen_scenario]
         if "result_table" in rt:
             df = pd.DataFrame(rt["result_table"])
             initial_top = df.iloc[0].to_dict()
+            
     decision_agent = DecisionAgent("DecisionAgent", session)
     report_text = decision_agent.run(chosen or {"vendor": "None"}, initial_top, chosen_scenario, risk_threshold)
 
-    # Report Agent (Final summary)
     report_agent = ReportAgent("ReportAgent", session)
     summary = report_agent.run(session)