Removed LLM call

app.py

@@ -1,5 +1,5 @@
 """
-Data Analyst Duo MCP with OpenAI Integration
+Data Analyst Duo MCP without OpenAI Integration
 """
 
 import os
@@ -13,12 +13,6 @@ import pandas as pd
 import numpy as np
 import requests
 import gradio as gr
-import openai
-
-# ——— OpenAI Setup ——————————————————————————————————————
-openai.api_key = os.getenv("OPENAI_API_KEY")
-if not openai.api_key:
-    raise EnvironmentError("Missing OPENAI_API_KEY environment variable")
 
 # ——— Logging setup —————————————————————————————————————
 logging.basicConfig(
@@ -37,9 +31,13 @@ class MCPMessage:
         self.timestamp = datetime.datetime.now().isoformat()
 
     def to_dict(self):
-        return {"id": self.id, "sender": self.sender,
-                "message_type": self.message_type,
-                "content": self.content, "timestamp": self.timestamp}
+        return {
+            "id": self.id,
+            "sender": self.sender,
+            "message_type": self.message_type,
+            "content": self.content,
+            "timestamp": self.timestamp,
+        }
 
 class MCPTool:
     def __init__(self, name, description, func):
@@ -105,129 +103,114 @@ class ComputeAgent(MCPAgent):
             url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/cereal.csv"
         try:
             self.df = pd.read_csv(url)
-            return {"status":"success","rows":self.df.shape[0],
-                    "columns":list(self.df.columns),
-                    "preview":self.df.head(5).to_dict(orient="records")}
+            return {
+                "status": "success",
+                "rows": self.df.shape[0],
+                "columns": list(self.df.columns),
+                "preview": self.df.head(5).to_dict(orient="records")
+            }
         except Exception as e:
             logger.exception("Load failed")
-            return {"status":"error","message":str(e)}
+            return {"status": "error", "message": str(e)}
 
     def _stats(self, params):
         if self.df is None:
-            return {"status":"error","message":"No data loaded"}
+            return {"status": "error", "message": "No data loaded"}
         try:
             cols = list(self.df.select_dtypes(include=[np.number]).columns)
             stats = self.df[cols].describe().to_dict()
-            return {"status":"success","statistics":stats}
+            return {"status": "success", "statistics": stats}
         except Exception as e:
             logger.exception("Stats failed")
-            return {"status":"error","message":str(e)}
+            return {"status": "error", "message": str(e)}
 
     def _corr(self, params):
         if self.df is None:
-            return {"status":"error","message":"No data loaded"}
+            return {"status": "error", "message": "No data loaded"}
         try:
             cols = list(self.df.select_dtypes(include=[np.number]).columns)
             corr = self.df[cols].corr().to_dict()
-            return {"status":"success","correlation_matrix":corr}
+            return {"status": "success", "correlation_matrix": corr}
         except Exception as e:
             logger.exception("Corr failed")
-            return {"status":"error","message":str(e)}
+            return {"status": "error", "message": str(e)}
 
     def handle_message(self, m):
         if m.message_type == "request_data_load":
-            res = self._load(m.content);
+            res = self._load(m.content)
             self.send_message(m.sender, "data_load_result", res)
         elif m.message_type == "request_statistics":
-            res = self._stats(m.content);
+            res = self._stats(m.content)
             self.send_message(m.sender, "statistics_result", res)
         elif m.message_type == "request_correlation":
-            res = self._corr(m.content);
+            res = self._corr(m.content)
             self.send_message(m.sender, "correlation_result", res)
 
-# ——— InterpretAgent with LLM —————————————————————————————————
+# ——— InterpretAgent with stubs ———————————————————————————————
 class InterpretAgent(MCPAgent):
     def __init__(self):
-        super().__init__("InterpretAgent","Interprets & reports via LLM")
+        super().__init__("InterpretAgent", "Interprets & reports (no LLM)")
         self.data_info = None
         self.stats = None
         self.corr = None
-        # tools for rule-based fallback
-        self.register_tool(MCPTool("interpret_statistics","",self._int_stats))
-        self.register_tool(MCPTool("interpret_correlation","",self._int_corr))
-        # LLM-powered tools
-        self.register_tool(MCPTool("llm_interpret","GPT-4 insights",self._llm_interpret))
-        self.register_tool(MCPTool("llm_report","GPT-4 report",self._llm_report))
+        # rule-based tools
+        self.register_tool(MCPTool("interpret_statistics", "", self._int_stats))
+        self.register_tool(MCPTool("interpret_correlation", "", self._int_corr))
+        # LLM stubs
+        self.register_tool(MCPTool("llm_interpret", "LLM stub", self._llm_interpret))
+        self.register_tool(MCPTool("llm_report", "LLM stub", self._llm_report))
 
     def _int_stats(self, params):
-        ins=[]
-        for col,vals in self.stats.get("statistics",{}).items():
-            if "mean" in vals: ins.append(f"{col} avg={vals['mean']:.2f}")
+        ins = []
+        for col, vals in self.stats.get("statistics", {}).items():
+            if "mean" in vals:
+                ins.append(f"{col} avg={vals['mean']:.2f}")
             if "min" in vals and "max" in vals:
                 ins.append(f"{col} ∈ [{vals['min']:.2f},{vals['max']:.2f}]")
-        return {"status":"success","insights":ins[:3],"summary":"Rule-based insights"}
+        return {"status": "success", "insights": ins[:3], "summary": "Rule-based insights"}
 
     def _int_corr(self, params):
-        return {"status":"success","insights":["Correlation computed"],"summary":"Rule-based corr"}
+        return {"status": "success", "insights": ["Correlation computed"], "summary": "Rule-based corr"}
 
     def _llm_interpret(self, params):
-        prompt = (
-            "I have these statistics in JSON format:\n" +
-            json.dumps(self.stats, indent=2) +
-            "\nPlease summarize the top 3 insights in plain English." )
-        resp = openai.ChatCompletion.create(
-            model="gpt-4",
-            messages=[{"role":"user","content":prompt}]
-        )
-        text = resp.choices[0].message.content.strip()
-        lines = [l for l in text.split("\n") if l.strip()]
-        return {"status":"success","insights":lines,"summary":text}
+        # stubbed out; no OpenAI
+        return {"status": "skipped", "insights": [], "summary": "LLM removed"}
 
     def _llm_report(self, params):
-        prompt = (
-            "Generate a concise analysis report in Markdown format based on the following:\n" +
-            f"Dataset info: rows={self.data_info['rows']}, cols={len(self.data_info['columns'])}\n" +
-            json.dumps(self.stats, indent=2) + "\n" +
-            json.dumps(self.corr, indent=2)
-        )
-        resp = openai.ChatCompletion.create(
-            model="gpt-4",
-            messages=[{"role":"user","content":prompt}]
-        )
-        return {"status":"success","report_md":resp.choices[0].message.content.strip()}
+        # stubbed out; no OpenAI
+        return {"status": "skipped", "report_md": ""}
 
     def handle_message(self, m):
         if m.message_type == "data_load_result":
             self.data_info = m.content
-            self.send_message(m.sender,"ack",{"status":"loaded"})
+            self.send_message(m.sender, "ack", {"status": "loaded"})
         elif m.message_type == "statistics_result":
             self.stats = m.content
-            # LLM-driven interpretation
             llm_res = self._llm_interpret({})
-            self.send_message(m.sender,"llm_statistics_interpretation",llm_res)
+            self.send_message(m.sender, "llm_statistics_interpretation", llm_res)
         elif m.message_type == "correlation_result":
             self.corr = m.content
             llm_res = self._llm_interpret({})
-            self.send_message(m.sender,"llm_correlation_interpretation",llm_res)
+            self.send_message(m.sender, "llm_correlation_interpretation", llm_res)
         elif m.message_type == "request_report":
             llm_res = self._llm_report({})
-            self.send_message(m.sender,"report_result",llm_res)
+            self.send_message(m.sender, "report_result", llm_res)
 
-# ——— Orchestration & Gradio —————————————————————————————————
+# ——— Orchestration (unchanged) —————————————————————————————
 class DataAnalystDuo:
     def __init__(self):
-        self.C=ComputeAgent(); self.I=InterpretAgent()
-        self.C.connect(self.I); self.I.connect(self.C)
+        self.C = ComputeAgent()
+        self.I = InterpretAgent()
+        self.C.connect(self.I)
+        self.I.connect(self.C)
 
-    def run(self,url):
-        self.I.send_message("ComputeAgent","request_data_load",{"url":url});
+    def run(self, url):
+        self.I.send_message("ComputeAgent", "request_data_load", {"url": url})
         self.C.process(); self.I.process()
-        self.I.send_message("ComputeAgent","request_statistics",{});
+        self.I.send_message("ComputeAgent", "request_statistics", {})
         self.C.process(); self.I.process()
-        self.I.send_message("ComputeAgent","request_correlation",{});
+        self.I.send_message("ComputeAgent", "request_correlation", {})
         self.C.process(); self.I.process()
-        self.C.send_message("InterpretAgent","request_report",{"report_title":"Analysis Report"});
+        self.C.send_message("InterpretAgent", "request_report", {"report_title": "Analysis Report"})
         self.I.process(); self.C.process()
         return self.C.get_history(), self.I.get_history()
-
-