Initial Hugging Face Space deployment

.gitignore

@@ -0,0 +1,3 @@
+sandbox/
+__pycache__/
+*.pyc

README.md

@@ -0,0 +1,39 @@
+---
+title: Data Analyst Agent
+emoji: "📊"
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+app_file: app.py
+pinned: false
+---
+
+# Data Analyst Agent
+
+An autonomous data analyst built with LangGraph, OpenAI, and Gradio.
+Upload a CSV, ask a question, and the agent writes Python, analyzes the data,
+generates charts, and returns practical insights.
+
+## Features
+
+- CSV upload and sandboxed analysis workflow
+- Correlation analysis, anomaly detection, and trend exploration
+- Chart generation with downloadable notebook output
+- Gradio interface for interactive analysis
+
+## Required Secret
+
+- `OPENAI_API_KEY`
+
+## Optional Secrets
+
+- `SERPER_API_KEY`
+- `OPENROUTER_API_KEY`
+
+## Local Files Included
+
+- `app.py`
+- `analyst.py`
+- `analyst_tools.py`
+- `requirements.txt`
+- `sample_sales_data.csv`

analyst.py

@@ -0,0 +1,477 @@
+import os
+import json
+import re
+from typing import Annotated, List, Any, Optional, Dict
+from typing_extensions import TypedDict
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from dotenv import load_dotenv
+from langgraph.prebuilt import ToolNode
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage, ToolMessage
+from pydantic import BaseModel, Field
+from analyst_tools import (
+    get_analyst_tools,
+    get_session_sandbox_dir,
+    normalize_message_text,
+    build_notebook,
+    build_html_report,
+    extract_python_snippets,
+    collect_charts,
+    recover_orphaned_charts,
+)
+import uuid
+import logging
+from datetime import datetime
+load_dotenv(override=True)
+logger = logging.getLogger(__name__)
+# ── State ──────────────────────────────────────────────────────────────────────
+class State(TypedDict):
+    messages: Annotated[List[Any], add_messages]
+    success_criteria: str
+    dataset_filename: Optional[str]        # filename inside sandbox/
+    session_dir: str
+    feedback_on_work: Optional[str]
+    success_criteria_met: bool
+    user_input_needed: bool
+    max_iterations: int
+    iteration_count: int
+    max_worker_turns: int
+    worker_turn_count: int
+    tool_calls_made: List[str]
+    tool_outputs_observed: List[str]
+# ── Evaluator schema ───────────────────────────────────────────────────────────
+class EvaluatorOutput(BaseModel):
+    feedback: str = Field(
+        description="Detailed feedback on the analyst's response"
+    )
+    success_criteria_met: bool = Field(
+        description="True only when the success criteria are fully met"
+    )
+    user_input_needed: bool = Field(
+        description=(
+            "True if the analyst needs user clarification, is stuck, "
+            "or the task cannot proceed without more information"
+        )
+    )
+    insights_are_non_trivial: bool = Field(
+        description=(
+            "True if the insights go beyond trivial descriptive stats "
+            "(e.g. include correlations, anomalies, trends, or recommendations)"
+        )
+    )
+# ── Agent ──────────────────────────────────────────────────────────────────────
+class DataAnalystAgent:
+    def __init__(self, max_iterations: int = 3, max_worker_turns: int = 12):
+        self.graph = None
+        self.tools = None
+        self._tool_node = None
+        self.worker_llm_with_tools = None
+        self.evaluator_llm = None
+        self.agent_id = str(uuid.uuid4())
+        self.session_dir = str(get_session_sandbox_dir(self.agent_id))
+        self.max_iterations = max_iterations
+        self.max_worker_turns = max_worker_turns
+        self.memory = MemorySaver()
+    def _build_llm(self, *, evaluator: bool = False) -> ChatOpenAI:
+        using_openrouter = bool(os.getenv("OPENROUTER_API_KEY"))
+        if using_openrouter:
+            model = os.getenv(
+                "OPENROUTER_EVALUATOR_MODEL" if evaluator else "OPENROUTER_MODEL",
+                "anthropic/claude-3.7-sonnet",
+            )
+            reasoning = {"exclude": True}
+            reasoning_effort = os.getenv("OPENROUTER_REASONING_EFFORT")
+            reasoning_max_tokens = os.getenv("OPENROUTER_REASONING_MAX_TOKENS")
+            if reasoning_max_tokens:
+                reasoning["max_tokens"] = int(reasoning_max_tokens)
+            elif reasoning_effort:
+                reasoning["effort"] = reasoning_effort
+            elif not evaluator:
+                reasoning["max_tokens"] = 2048
+            return ChatOpenAI(
+                model=model,
+                api_key=os.getenv("OPENROUTER_API_KEY"),
+                base_url=os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1"),
+                default_headers={
+                    "HTTP-Referer": os.getenv("OPENROUTER_SITE_URL", "http://localhost:7860"),
+                    "X-Title": os.getenv("OPENROUTER_APP_NAME", "Data Analyst Agent"),
+                },
+                reasoning=reasoning,
+            )
+        model = os.getenv(
+            "OPENAI_EVALUATOR_MODEL" if evaluator else "OPENAI_MODEL",
+            "gpt-4o-mini",
+        )
+        return ChatOpenAI(model=model)
+    def setup(self):
+        self.tools = get_analyst_tools(self.session_dir)
+        worker_llm = self._build_llm(evaluator=False)
+        self.worker_llm_with_tools = worker_llm.bind_tools(self.tools)
+        self.evaluator_llm = self._build_llm(evaluator=True)
+        self.build_graph()
+    # ── Worker ───────��─────────────────────────────────────────────────────────
+    def _is_python_tool(self, tool_name: str) -> bool:
+        return "python" in (tool_name or "").lower()
+    def worker(self, state: State) -> Dict[str, Any]:
+        next_worker_turn = state.get("worker_turn_count", 0) + 1
+        if next_worker_turn > state["max_worker_turns"]:
+            return {
+                "messages": [
+                    AIMessage(
+                        content=(
+                            "I could not complete the analysis within the allowed tool-execution "
+                            "limit. Please refine the request or inspect the dataset manually."
+                        )
+                    )
+                ],
+                "worker_turn_count": next_worker_turn,
+            }
+        session_dir = state["session_dir"].replace("\\", "/")
+        tool_calls_made = state.get("tool_calls_made", [])
+        tool_outputs_observed = state.get("tool_outputs_observed", [])
+        python_already_used = any(self._is_python_tool(name) for name in (tool_calls_made + tool_outputs_observed))
+        dataset_hint = ""
+        if state.get("dataset_filename"):
+            if python_already_used:
+                dataset_hint = f"""
+A dataset has been uploaded by the user and you have already used Python to inspect it.
+It is available in the session sandbox directory as: {state['dataset_filename']}
+Its full path for Python code is: {session_dir}/{state['dataset_filename']}
+You have already gathered execution evidence from Python.
+Do not restart the analysis from scratch.
+Only call tools again if you need one missing detail for the final answer.
+Prefer producing the final response now, including:
+- non-trivial findings
+- anomalies or outliers
+- trends or patterns
+- actionable recommendations
+- chart filenames if any were saved
+"""
+            else:
+                dataset_hint = f"""
+A dataset has been uploaded by the user.
+It is available in the session sandbox directory as: {state['dataset_filename']}
+Its full path for Python code is: {session_dir}/{state['dataset_filename']}
+MANDATORY RULES when a dataset is present:
+1. You MUST use the Python REPL tool to inspect and analyse the data before answering.
+2. Always start with:
+   import pandas as pd
+   import matplotlib.pyplot as plt
+   df = pd.read_csv(r'{session_dir}/{state["dataset_filename"]}')
+   numeric_df = df.select_dtypes(include='number')
+   print(df.shape)
+   print(df.dtypes)
+   print(df.describe(include='all'))
+   print(numeric_df.corr(numeric_only=True))
+3. Your analysis MUST cover:
+   - Basic statistics (already done above)
+   - Correlation analysis on numeric columns only
+   - Outlier / anomaly detection (IQR method or z-score)
+   - At least one trend or pattern observation
+   - A concrete, actionable recommendation
+4. For chart generation, use matplotlib and save to {session_dir}/chart_<name>.png,
+   then tell the user the filename.
+5. Always print the outputs you rely on. Bare expressions are not enough in Python REPL.
+6. Never call plt.show(). Save the figure and then call plt.close().
+"""
+        system_message = f"""You are an expert data analyst AI assistant.
+You have access to a Python REPL, file tools, optional web search, and Wikipedia.
+The current date and time is {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+The current session sandbox directory is: {session_dir}
+{dataset_hint}
+Your success criteria:
+{state["success_criteria"]}
+When you have finished your analysis, present:
+1. A clear summary of key findings (bullet points)
+2. Any anomalies or outliers found
+3. Trends or patterns
+4. Actionable recommendations
+5. Names of any chart files saved
+If you need clarification, state: "Question: <your question>"
+"""
+        if python_already_used:
+            system_message += """
+You have already used Python in this run.
+Unless a crucial fact is still missing, stop calling tools and deliver the final answer.
+Treat the recorded Python tool outputs as authoritative evidence; summarize them clearly in the final answer.
+"""
+        if state.get("feedback_on_work"):
+            system_message += f"""
+A previous attempt was rejected. Feedback:
+{state['feedback_on_work']}
+Address this feedback and improve your analysis.
+"""
+        # Build a new message list with an updated system message
+        # (avoid mutating shared state objects in-place).
+        new_messages: list = []
+        sys_replaced = False
+        for msg in state["messages"]:
+            if isinstance(msg, SystemMessage) and not sys_replaced:
+                new_messages.append(SystemMessage(content=system_message))
+                sys_replaced = True
+            else:
+                new_messages.append(msg)
+        if not sys_replaced:
+            new_messages.insert(0, SystemMessage(content=system_message))
+        try:
+            response = self.worker_llm_with_tools.invoke(new_messages)
+        except Exception as exc:
+            logger.error("Worker LLM call failed: %s", exc, exc_info=True)
+            return {
+                "messages": [AIMessage(content=f"An error occurred during analysis: {exc}")],
+                "worker_turn_count": next_worker_turn,
+            }
+        tool_calls = [
+            tool_call.get("name", "unknown_tool")
+            for tool_call in getattr(response, "tool_calls", []) or []
+        ]
+        return {
+            "messages": [response],
+            "worker_turn_count": next_worker_turn,
+            "tool_calls_made": state.get("tool_calls_made", []) + tool_calls,
+        }
+    def worker_router(self, state: State) -> str:
+        last = state["messages"][-1]
+        if hasattr(last, "tool_calls") and last.tool_calls:
+            return "tools"
+        return "evaluator"
+    # ── Evaluator ──────────────────────────────────────────────────────────────
+    def _format_conversation(self, messages: List[Any]) -> str:
+        out = "Conversation history:\n\n"
+        for msg in messages:
+            if isinstance(msg, HumanMessage):
+                out += f"User: {self._message_text(msg.content)}\n"
+            elif isinstance(msg, AIMessage):
+                text = self._message_text(msg.content) or "[Tool use]"
+                out += f"Analyst: {text}\n"
+            elif isinstance(msg, ToolMessage):
+                out += f"Tool result ({msg.name or 'tool'}): {self._message_text(msg.content)}\n"
+        return out
+    def _message_text(self, content: Any) -> str:
+        return normalize_message_text(content)
+    def _tool_evidence(self, state: State) -> str:
+        tool_calls = state.get("tool_calls_made", [])
+        tool_outputs = state.get("tool_outputs_observed", [])
+        dataset_present = bool(state.get("dataset_filename"))
+        python_called = any(self._is_python_tool(tool) for tool in tool_calls)
+        python_output_seen = any(self._is_python_tool(tool) for tool in tool_outputs)
+        return (
+            f"Dataset provided: {dataset_present}\n"
+            f"Tool calls made: {tool_calls or ['none']}\n"
+            f"Tool outputs observed: {tool_outputs or ['none']}\n"
+            f"Python tool called: {python_called}\n"
+            f"Python output observed: {python_output_seen}\n"
+        )
+    def _parse_evaluator_output(self, content: Any) -> EvaluatorOutput:
+        if isinstance(content, list):
+            normalized_parts = []
+            for item in content:
+                if isinstance(item, dict):
+                    normalized_parts.append(item.get("text", str(item)))
+                else:
+                    normalized_parts.append(str(item))
+            content = "\n".join(normalized_parts)
+        elif content is None:
+            content = ""
+        else:
+            content = str(content)
+        try:
+            return EvaluatorOutput.model_validate_json(content)
+        except Exception:
+            pass
+        # Try each '{' position to find a valid JSON object.
+        for i, ch in enumerate(content):
+            if ch == "{":
+                try:
+                    obj = json.loads(content[i:])
+                    return EvaluatorOutput.model_validate(obj)
+                except (json.JSONDecodeError, Exception):
+                    continue
+        fallback_feedback = content.strip() or "Evaluator response could not be parsed."
+        lower_content = fallback_feedback.lower()
+        return EvaluatorOutput(
+            feedback=fallback_feedback,
+            success_criteria_met="meets the success criteria" in lower_content,
+            user_input_needed="user input" in lower_content or "clarification" in lower_content,
+            insights_are_non_trivial="non-trivial" in lower_content or "correlation" in lower_content,
+        )
+    def evaluator(self, state: State) -> Dict[str, Any]:
+        last_response = self._message_text(state["messages"][-1].content)
+        current_iteration = state.get("iteration_count", 0) + 1
+        system_message = (
+            "You are a senior data analyst evaluating whether a junior analyst's "
+            "response to a data task meets the required standard. Be rigorous: "
+            "reject responses that are only descriptive stats with no deeper insight."
+        )
+        user_message = f"""Evaluate this data analysis conversation.
+{self._format_conversation(state["messages"])}
+Execution evidence:
+{self._tool_evidence(state)}
+Success criteria: {state["success_criteria"]}
+Final response from the analyst:
+{last_response}
+Evaluate:
+1. Does it meet the success criteria?
+2. Are insights non-trivial (correlations, anomalies, trends, recommendations)?
+3. Does the analyst need user input or appear stuck?
+4. Was Python actually used to derive the insights (not just described)?
+If a dataset was provided, the analyst MUST have used the Python tool.
+If charts were requested, at least one must have been saved.
+Give the analyst reasonable benefit of the doubt on file saves.
+"""
+        if state.get("feedback_on_work"):
+            user_message += (
+                f"\nPrior feedback given: {state['feedback_on_work']}\n"
+                "If the analyst is repeating the same mistakes, mark user_input_needed=True."
+            )
+        try:
+            result_message = self.evaluator_llm.invoke([
+                SystemMessage(content=system_message),
+                HumanMessage(
+                    content=(
+                        user_message
+                        + "\n\nRespond with a single JSON object only using this schema: "
+                        '{"feedback": string, "success_criteria_met": boolean, '
+                        '"user_input_needed": boolean, "insights_are_non_trivial": boolean}'
+                    )
+                ),
+            ])
+            result = self._parse_evaluator_output(result_message.content)
+        except Exception as exc:
+            logger.error("Evaluator LLM call failed: %s", exc, exc_info=True)
+            result = EvaluatorOutput(
+                feedback=f"Evaluator error: {exc}",
+                success_criteria_met=False,
+                user_input_needed=True,
+                insights_are_non_trivial=False,
+            )
+        python_called = any(self._is_python_tool(tool) for tool in state.get("tool_calls_made", []))
+        python_output_seen = any(self._is_python_tool(tool) for tool in state.get("tool_outputs_observed", []))
+        # Trust actual tool evidence over the evaluator's uncertainty about whether Python was really used.
+        criteria_met = (
+            result.insights_are_non_trivial
+            and (result.success_criteria_met or (python_called and python_output_seen and not result.user_input_needed))
+        )
+        hit_iteration_limit = current_iteration >= state["max_iterations"] and not criteria_met
+        final_feedback = result.feedback
+        user_input_needed = result.user_input_needed
+        if hit_iteration_limit:
+            final_feedback = (
+                f"{result.feedback}\n\nMaximum retry limit reached after "
+                f"{current_iteration} evaluation attempts."
+            )
+            user_input_needed = True
+        return {
+            "messages": [{
+                "role": "assistant",
+                "content": (
+                    f"**Evaluator feedback:** {final_feedback}\n\n"
+                    f"Insights non-trivial: {result.insights_are_non_trivial}"
+                ),
+            }],
+            "feedback_on_work": final_feedback,
+            "success_criteria_met": criteria_met,
+            "user_input_needed": user_input_needed,
+            "iteration_count": current_iteration,
+        }
+    def route_based_on_evaluation(self, state: State) -> str:
+        if state["success_criteria_met"] or state["user_input_needed"]:
+            return "END"
+        return "worker"
+    # ── Graph ──────────────────────────────────────────────────────────────────
+    def tools_node(self, state: State) -> Dict[str, Any]:
+        tool_node = self._tool_node
+        result = tool_node.invoke(state)
+        tool_outputs = state.get("tool_outputs_observed", []) + self._extract_tool_outputs(result["messages"])
+        return {
+            "messages": result["messages"],
+            "tool_outputs_observed": tool_outputs,
+        }
+    def build_graph(self):
+        builder = StateGraph(State)
+        builder.add_node("worker", self.worker)
+        self._tool_node = ToolNode(tools=self.tools)
+        builder.add_node("tools", self.tools_node)
+        builder.add_node("evaluator", self.evaluator)
+        builder.add_edge(START, "worker")
+        builder.add_conditional_edges(
+            "worker",
+            self.worker_router,
+            {"tools": "tools", "evaluator": "evaluator"},
+        )
+        builder.add_edge("tools", "worker")
+        builder.add_conditional_edges(
+            "evaluator",
+            self.route_based_on_evaluation,
+            {"worker": "worker", "END": END},
+        )
+        self.graph = builder.compile(checkpointer=self.memory)
+    def _extract_tool_outputs(self, messages: List[Any]) -> List[str]:
+        outputs: List[str] = []
+        for msg in messages:
+            if isinstance(msg, ToolMessage):
+                outputs.append(msg.name or "unknown_tool")
+        return outputs
+    # ── Public API ─────────────────────────────────────────────────────────────
+    def run(self, message: str, success_criteria: str, dataset_filename: Optional[str], history: list) -> tuple:
+        config = {
+            "configurable": {"thread_id": self.agent_id},
+            "recursion_limit": max(50, self.max_worker_turns * 4),
+        }
+        state = {
+            "messages": message,
+            "success_criteria": success_criteria or "Provide clear, non-trivial insights from the data.",
+            "dataset_filename": dataset_filename,
+            "session_dir": self.session_dir,
+            "feedback_on_work": None,
+            "success_criteria_met": False,
+            "user_input_needed": False,
+            "max_iterations": self.max_iterations,
+            "iteration_count": 0,
+            "max_worker_turns": self.max_worker_turns,
+            "worker_turn_count": 0,
+            "tool_calls_made": [],
+            "tool_outputs_observed": [],
+        }
+        result = self.graph.invoke(state, config=config)
+        msgs = result["messages"]
+        user_msg = {"role": "user", "content": message}
+        # Guard against short message lists.
+        if len(msgs) >= 2:
+            analyst_reply = {"role": "assistant", "content": self._message_text(msgs[-2].content)}
+            eval_feedback_text = self._message_text(msgs[-1].content)
+        elif msgs:
+            analyst_reply = {"role": "assistant", "content": self._message_text(msgs[-1].content)}
+            eval_feedback_text = ""
+        else:
+            analyst_reply = {"role": "assistant", "content": "No response was generated."}
+            eval_feedback_text = ""
+        # Recover any chart PNGs that the agent saved to the CWD instead
+        # of the session sandbox (PythonREPLTool runs in the process CWD).
+        recover_orphaned_charts(self.session_dir)
+        # Build notebook + HTML report for in-browser preview.
+        analyst_text = analyst_reply["content"]
+        code_snippets = extract_python_snippets(msgs)
+        nb_path = build_notebook(
+            self.session_dir, analyst_text, code_snippets, dataset_filename,
+        )
+        html_report = build_html_report(
+            self.session_dir, analyst_text, dataset_filename,
+        )
+        return (
+            history + [user_msg, analyst_reply],
+            eval_feedback_text,
+            result,
+            nb_path,
+            html_report,
+        )
+    def reset(self):
+        """Return a fresh agent instance."""
+        new_agent = DataAnalystAgent(
+            max_iterations=self.max_iterations,
+            max_worker_turns=self.max_worker_turns,
+        )
+        new_agent.setup()
+        return new_agent

analyst_tools.py

@@ -0,0 +1,337 @@
+import os
+import re
+import json
+import glob
+import base64
+import shutil
+import logging
+from pathlib import Path
+from dotenv import load_dotenv
+from langchain.agents import Tool
+from langchain_community.agent_toolkits import FileManagementToolkit
+from langchain_community.tools.wikipedia.tool import WikipediaQueryRun
+from langchain_experimental.tools import PythonREPLTool
+from langchain_community.utilities import GoogleSerperAPIWrapper
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+load_dotenv(override=True)
+os.environ.setdefault("MPLBACKEND", "Agg")
+logger = logging.getLogger(__name__)
+try:
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    plt.show = lambda *args, **kwargs: None
+except Exception:
+    matplotlib = None
+# Use an absolute path anchored to this file's directory so the sandbox
+# location is predictable regardless of the working directory at launch.
+_SCRIPT_DIR = Path(__file__).resolve().parent
+SANDBOX_DIR = _SCRIPT_DIR / "sandbox"
+SANDBOX_DIR.mkdir(exist_ok=True)
+# -- Shared text helpers -------------------------------------------------------
+def normalize_message_text(content) -> str:
+    """Convert LangChain message content (str | list[dict] | None) to a plain string."""
+    if isinstance(content, list):
+        parts = []
+        for item in content:
+            if isinstance(item, dict):
+                parts.append(item.get("text", str(item)))
+            else:
+                parts.append(str(item))
+        return "\n".join(parts)
+    return "" if content is None else str(content)
+# -- Sandbox helpers ------------------------------------------------------------
+def get_session_sandbox_dir(session_id: str) -> Path:
+    session_dir = SANDBOX_DIR / session_id
+    session_dir.mkdir(parents=True, exist_ok=True)
+    return session_dir
+def cleanup_session_sandbox(session_dir: str | Path) -> None:
+    shutil.rmtree(session_dir, ignore_errors=True)
+def get_file_tools(session_dir: str | Path):
+    toolkit = FileManagementToolkit(root_dir=str(session_dir))
+    return toolkit.get_tools()
+def copy_uploaded_file(src_path: str, filename: str, session_dir: str | Path) -> str:
+    """Copy an uploaded Gradio file into the session sandbox so the agent can access it."""
+    dest = Path(session_dir) / filename
+    shutil.copy(src_path, dest)
+    return str(dest)
+def collect_charts(session_dir: str) -> list[str]:
+    """Return paths of any .png files saved in the current session sandbox."""
+    return sorted(glob.glob(os.path.join(str(session_dir), "*.png")))
+def recover_orphaned_charts(session_dir: str | Path) -> None:
+    """
+    The PythonREPLTool executes code in the process CWD, which is usually the
+    project root — not the session sandbox.  Charts saved with a bare filename
+    (e.g. ``plt.savefig('chart.png')``) end up in the CWD.
+    This helper moves any .png files found in the CWD (and the sandbox root)
+    into the session directory so that ``collect_charts`` picks them up.
+    """
+    session_path = Path(session_dir)
+    search_dirs = {Path.cwd(), SANDBOX_DIR}
+    # Also check _SCRIPT_DIR in case the user launched from there
+    search_dirs.add(_SCRIPT_DIR)
+    for search_dir in search_dirs:
+        if not search_dir.is_dir() or search_dir == session_path:
+            continue
+        for png in search_dir.glob("*.png"):
+            dest = session_path / png.name
+            if not dest.exists():
+                try:
+                    shutil.move(str(png), str(dest))
+                    logger.info("Recovered orphaned chart %s → %s", png, dest)
+                except Exception:
+                    logger.warning("Could not move %s", png, exc_info=True)
+# -- Notebook generation -------------------------------------------------------
+def _make_nb_cell(cell_type: str, source: str, outputs=None) -> dict:
+    """Build a single Jupyter notebook cell dict."""
+    cell = {
+        "cell_type": cell_type,
+        "metadata": {},
+        "source": source.splitlines(keepends=True) if source else [],
+    }
+    if cell_type == "code":
+        cell["execution_count"] = None
+        cell["outputs"] = outputs or []
+    return cell
+def _png_to_nb_output(png_path: str) -> dict:
+    """Create a notebook display_data output that embeds a PNG image."""
+    with open(png_path, "rb") as f:
+        b64 = base64.b64encode(f.read()).decode("ascii")
+    return {
+        "output_type": "display_data",
+        "metadata": {},
+        "data": {
+            "image/png": b64,
+            "text/plain": [f"<Figure: {Path(png_path).name}>"],
+        },
+    }
+def build_notebook(
+    session_dir: str,
+    analyst_summary: str,
+    code_snippets: list[str] | None = None,
+    dataset_filename: str | None = None,
+) -> str:
+    """
+    Build an .ipynb file that bundles:
+      - a markdown cell with the analyst's summary / findings
+      - code cells for each Python snippet the agent ran
+      - inline chart images (embedded as base64 display_data outputs)
+    Returns the absolute path to the saved notebook.
+    """
+    cells: list[dict] = []
+    cells.append(_make_nb_cell(
+        "markdown",
+        "# Data Analysis Report\n\n*Auto-generated by Data Analyst Agent*",
+    ))
+    if dataset_filename:
+        cells.append(_make_nb_cell("markdown", f"**Dataset:** `{dataset_filename}`"))
+    if code_snippets:
+        cells.append(_make_nb_cell("markdown", "## Analysis Code"))
+        for snippet in code_snippets:
+            cells.append(_make_nb_cell("code", snippet))
+    chart_paths = collect_charts(session_dir)
+    if chart_paths:
+        cells.append(_make_nb_cell("markdown", "## Charts"))
+        for chart_path in chart_paths:
+            try:
+                output = _png_to_nb_output(chart_path)
+                chart_name = Path(chart_path).stem
+                cells.append(_make_nb_cell(
+                    "code",
+                    (
+                        f"# Chart: {chart_name}\n"
+                        f"from IPython.display import Image, display\n"
+                        f"display(Image(filename=r'{chart_path}'))"
+                    ),
+                    outputs=[output],
+                ))
+            except Exception:
+                logger.warning("Could not embed chart %s", chart_path, exc_info=True)
+    cells.append(_make_nb_cell("markdown", f"## Findings\n\n{analyst_summary}"))
+    notebook = {
+        "nbformat": 4,
+        "nbformat_minor": 5,
+        "metadata": {
+            "kernelspec": {
+                "display_name": "Python 3",
+                "language": "python",
+                "name": "python3",
+            },
+            "language_info": {"name": "python", "version": "3.11.0"},
+        },
+        "cells": cells,
+    }
+    nb_path = os.path.join(session_dir, "analysis_report.ipynb")
+    with open(nb_path, "w", encoding="utf-8") as f:
+        json.dump(notebook, f, indent=1, ensure_ascii=False)
+    logger.info("Notebook saved to %s", nb_path)
+    return nb_path
+# -- HTML report for in-browser preview ----------------------------------------
+def build_html_report(
+    session_dir: str,
+    analyst_summary: str,
+    dataset_filename: str | None = None,
+) -> str:
+    """
+    Build a self-contained HTML report with:
+      - the analyst's markdown findings rendered as HTML
+      - charts embedded as base64 <img> tags
+    Returns the HTML string (also saved to disk).
+    """
+    summary_html = _md_to_simple_html(analyst_summary)
+    chart_paths = collect_charts(session_dir)
+    charts_html = ""
+    for cp in chart_paths:
+        try:
+            with open(cp, "rb") as f:
+                b64 = base64.b64encode(f.read()).decode("ascii")
+            name = Path(cp).stem.replace("_", " ").title()
+            charts_html += (
+                f'<div class="chart"><h3>{name}</h3>'
+                f'<img src="data:image/png;base64,{b64}" alt="{name}" /></div>\n'
+            )
+        except Exception:
+            logger.warning("Could not embed chart %s in HTML", cp, exc_info=True)
+    ds_label = (
+        f"<p class='meta'>Dataset: <code>{dataset_filename}</code></p>"
+        if dataset_filename else ""
+    )
+    html = (
+        "<div style='font-family:Inter,Segoe UI,system-ui,sans-serif;"
+        "width:100%;padding:1rem;color:#1e293b;box-sizing:border-box;'>"
+        "<style>\n"
+        ".rpt h1{font-size:1.4rem;color:#3730a3;border-bottom:2px solid #c7d2fe;"
+        "padding-bottom:.4rem;margin-top:0}\n"
+        ".rpt h2{font-size:1.15rem;color:#3730a3;margin-top:1.5rem}\n"
+        ".rpt h3{font-size:1rem;color:#1e293b;font-weight:600}\n"
+        ".rpt .meta{color:#475569;font-size:.85rem}\n"
+        ".rpt .chart{margin:1rem 0}\n"
+        ".rpt .chart img{max-width:100%;border-radius:10px;"
+        "box-shadow:0 2px 12px rgba(0,0,0,.06);margin:.4rem 0 1rem}\n"
+        ".rpt .findings{background:#f8faff;padding:1.2rem;"
+        "border-radius:10px;border:1px solid #e0e7ff;margin-top:.8rem}\n"
+        ".rpt .findings h1,.rpt .findings h2,.rpt .findings h3{"
+        "color:#1e3a5f}\n"
+        ".rpt .findings p,.rpt .findings li,.rpt .findings span{"
+        "color:#1e293b}\n"
+        ".rpt .findings strong{color:#0f172a}\n"
+        ".rpt code{background:#e0e7ff;padding:2px 6px;border-radius:4px;"
+        "font-size:.88em;color:#3730a3}\n"
+        ".rpt pre{background:#f1f5f9;padding:.8rem;border-radius:8px;"
+        "overflow-x:auto;font-size:.85em;color:#1e293b}\n"
+        ".rpt ul,.rpt ol{padding-left:1.4rem}"
+        ".rpt li{margin-bottom:.25rem;line-height:1.6;color:#1e293b}\n"
+        ".rpt p{line-height:1.6;color:#1e293b}\n"
+        "</style>\n"
+        f"<div class='rpt'>\n<h1>Data Analysis Report</h1>\n{ds_label}\n"
+    )
+    if charts_html:
+        html += f"<h2>Charts</h2>\n{charts_html}\n"
+    html += (
+        f"<h2>Findings</h2>\n<div class='findings'>\n{summary_html}\n</div>\n"
+        "<p class='meta' style='margin-top:2rem;text-align:center;color:#64748b'>"
+        "Generated by Data Analyst Agent</p>\n</div>\n</div>"
+    )
+    html_path = os.path.join(session_dir, "analysis_report.html")
+    with open(html_path, "w", encoding="utf-8") as f:
+        f.write(html)
+    logger.info("HTML report saved to %s", html_path)
+    return html
+def _md_to_simple_html(text: str) -> str:
+    """Minimal markdown-to-HTML conversion for analyst output."""
+    if not text:
+        return ""
+    lines = text.split("\n")
+    out: list[str] = []
+    in_ul = False
+    in_ol = False
+    in_code = False
+    for line in lines:
+        s = line.strip()
+        if s.startswith("```"):
+            if in_code:
+                out.append("</code></pre>")
+            else:
+                out.append("<pre><code>")
+            in_code = not in_code
+            continue
+        if in_code:
+            out.append(line)
+            continue
+        if s.startswith("### "):
+            if in_ul: out.append("</ul>"); in_ul = False
+            if in_ol: out.append("</ol>"); in_ol = False
+            out.append(f"<h3>{_inline_fmt(s[4:])}</h3>"); continue
+        if s.startswith("## "):
+            if in_ul: out.append("</ul>"); in_ul = False
+            if in_ol: out.append("</ol>"); in_ol = False
+            out.append(f"<h2>{_inline_fmt(s[3:])}</h2>"); continue
+        if s.startswith("# "):
+            if in_ul: out.append("</ul>"); in_ul = False
+            if in_ol: out.append("</ol>"); in_ol = False
+            out.append(f"<h1>{_inline_fmt(s[2:])}</h1>"); continue
+        if s.startswith("- ") or s.startswith("* "):
+            if in_ol: out.append("</ol>"); in_ol = False
+            if not in_ul: out.append("<ul>"); in_ul = True
+            out.append(f"<li>{_inline_fmt(s[2:])}</li>"); continue
+        m = re.match(r"^(\d+)\.\s+(.+)$", s)
+        if m:
+            if in_ul: out.append("</ul>"); in_ul = False
+            if not in_ol: out.append("<ol>"); in_ol = True
+            out.append(f"<li>{_inline_fmt(m.group(2))}</li>"); continue
+        if in_ul: out.append("</ul>"); in_ul = False
+        if in_ol: out.append("</ol>"); in_ol = False
+        if not s:
+            out.append(""); continue
+        out.append(f"<p>{_inline_fmt(s)}</p>")
+    if in_ul: out.append("</ul>")
+    if in_ol: out.append("</ol>")
+    if in_code: out.append("</code></pre>")
+    return "\n".join(out)
+def _inline_fmt(text: str) -> str:
+    """Apply bold and inline-code markdown formatting."""
+    text = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", text)
+    text = re.sub(r"`(.+?)`", r"<code>\1</code>", text)
+    return text
+# -- Extract code snippets from conversation -----------------------------------
+def extract_python_snippets(messages) -> list[str]:
+    """
+    Walk through LangChain messages and pull out the Python code that was
+    sent to the PythonREPLTool (via tool_calls).
+    """
+    from langchain_core.messages import AIMessage
+    snippets: list[str] = []
+    for msg in messages:
+        if isinstance(msg, AIMessage) and hasattr(msg, "tool_calls") and msg.tool_calls:
+            for tc in msg.tool_calls:
+                name = tc.get("name", "")
+                if "python" in name.lower():
+                    args = tc.get("args", {})
+                    code = (
+                        args.get("command")
+                        or args.get("code")
+                        or args.get("query")
+                        or ""
+                    )
+                    if code.strip():
+                        snippets.append(code.strip())
+    return snippets
+# -- Tool factory --------------------------------------------------------------
+def get_analyst_tools(session_dir: str | Path, enable_web_search: bool | None = None):
+    file_tools = get_file_tools(session_dir)
+    tools = list(file_tools)
+    if enable_web_search is None:
+        enable_web_search = bool(os.getenv("SERPER_API_KEY"))
+    if enable_web_search:
+        serper = GoogleSerperAPIWrapper()
+        search_tool = Tool(
+            name="web_search",
+            func=serper.run,
+            description="Search the web for context about data, industry benchmarks, or methodology questions.",
+        )
+        tools.append(search_tool)
+    wikipedia = WikipediaAPIWrapper()
+    wiki_tool = WikipediaQueryRun(api_wrapper=wikipedia)
+    python_repl = PythonREPLTool()
+    tools.extend([python_repl, wiki_tool])
+    return tools

app.py

@@ -0,0 +1,412 @@
+import gradio as gr
+import os
+from analyst import DataAnalystAgent
+from analyst_tools import (
+    copy_uploaded_file,
+    cleanup_session_sandbox,
+    normalize_message_text,
+    collect_charts,
+)
+# ── Helpers ────────────────────────────────────────────────────────────────────
+def _init_agent():
+    agent = DataAnalystAgent()
+    agent.setup()
+    return agent
+def _show_status(text: str) -> str:
+    """Return a small HTML status badge."""
+    return (
+        f'<div class="status-badge">'
+        f'<span class="pulse"></span> {text}</div>'
+    )
+def _status_done(text: str) -> str:
+    return f'<div class="status-badge done">{text}</div>'
+def process_message(agent, message, success_criteria, dataset_file, history):
+    """Run the agent and return updated UI state with HTML report + notebook."""
+    if not message.strip():
+        return (
+            history, agent, gr.update(),
+            gr.update(visible=False),
+            gr.update(value="", visible=False),
+            gr.update(visible=False),
+            gr.update(value=None, visible=False),
+            gr.update(value=""),
+        )
+    dataset_filename = None
+    if dataset_file is not None:
+        original_name = os.path.basename(dataset_file)
+        copy_uploaded_file(dataset_file, original_name, agent.session_dir)
+        dataset_filename = original_name
+    updated_history, evaluator_feedback, _, nb_path, html_report = agent.run(
+        message, success_criteria, dataset_filename, history,
+    )
+    evaluator_feedback = normalize_message_text(evaluator_feedback)
+    # Charts gallery
+    charts = collect_charts(agent.session_dir)
+    chart_update = gr.update(value=charts, visible=True) if charts else gr.update(visible=False)
+    # HTML report rendered in-browser
+    report_update = gr.update(value=html_report, visible=True) if html_report else gr.update(visible=False)
+    # Notebook download
+    nb_update = gr.update(value=nb_path, visible=True) if nb_path else gr.update(value=None, visible=False)
+    # Status line
+    chart_count = len(charts)
+    status_parts = ["Analysis complete"]
+    if chart_count:
+        status_parts.append(f"{chart_count} chart{'s' if chart_count != 1 else ''}")
+    if nb_path:
+        status_parts.append("notebook ready")
+    status_text = _status_done(" | ".join(status_parts))
+    return (
+        updated_history,
+        agent,
+        gr.update(value=""),
+        chart_update,
+        gr.update(value=evaluator_feedback, visible=bool(evaluator_feedback)),
+        report_update,
+        nb_update,
+        gr.update(value=status_text),
+    )
+def reset_agent(agent):
+    cleanup_session_sandbox(agent.session_dir)
+    new_agent = agent.reset()
+    return (
+        [],
+        new_agent,
+        gr.update(value=""),
+        gr.update(value=""),
+        gr.update(value=None),
+        gr.update(visible=False),
+        gr.update(value="", visible=False),
+        gr.update(visible=False),
+        gr.update(value=None, visible=False),
+        gr.update(value=""),
+    )
+# ── CSS ────────────────────────────────────────────────────────────────────────
+CSS = """
+/* ── Page background ─────────────────────────────────────────────────────── */
+body {
+    background:
+        radial-gradient(ellipse at 10% 0%, rgba(99,102,241,.12), transparent 50%),
+        radial-gradient(ellipse at 90% 0%, rgba(234,179,8,.10), transparent 40%),
+        linear-gradient(180deg, #f8faff 0%, #eef2fb 100%);
+}
+.gradio-container { max-width: 1200px !important; }
+/* ── Header ──────────────────────────────────────────────────────────────── */
+#app-header {
+    text-align: center;
+    padding: 1.2rem 0 .6rem;
+}
+#app-header h1 {
+    font-size: 1.8rem;
+    background: linear-gradient(135deg, #1e40af 0%, #6366f1 55%, #d97706 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+    margin: 0;
+    letter-spacing: -0.02em;
+}
+#app-header p {
+    color: #64748b;
+    font-size: .92rem;
+    margin: .3rem 0 0;
+}
+/* ── Cards ───────────────────────────────────────────────────────────────── */
+.card {
+    background: rgba(255,255,255,.92);
+    backdrop-filter: blur(12px);
+    border: 1px solid rgba(99,102,241,.10);
+    border-radius: 16px;
+    box-shadow: 0 4px 24px rgba(30,64,175,.06);
+    padding: 1rem;
+}
+/* ── Chatbot ───���─────────────────────────────────────────────────────────── */
+#chatbot {
+    border-radius: 16px !important;
+    border: 1px solid rgba(99,102,241,.12) !important;
+    box-shadow: 0 8px 32px rgba(30,64,175,.08) !important;
+    background: linear-gradient(180deg, #fff 0%, #f8faff 100%) !important;
+}
+/* ── Input area ──────────────────────────────────────────────────────────── */
+#input-group {
+    background: rgba(255,255,255,.88);
+    backdrop-filter: blur(10px);
+    border: 1px solid rgba(99,102,241,.10);
+    border-radius: 16px;
+    box-shadow: 0 4px 20px rgba(30,64,175,.05);
+    padding: .8rem 1rem;
+}
+/* ── Buttons ─────────────────────────────────────────────────────────────── */
+#go-btn {
+    min-width: 140px;
+    background: linear-gradient(135deg, #4f46e5 0%, #6366f1 60%, #d97706 100%) !important;
+    color: #fff !important;
+    border: none !important;
+    border-radius: 12px !important;
+    font-weight: 600 !important;
+    font-size: .95rem !important;
+    box-shadow: 0 4px 16px rgba(79,70,229,.30) !important;
+    transition: transform .15s, box-shadow .15s;
+}
+#go-btn:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 6px 24px rgba(79,70,229,.36) !important;
+}
+#reset-btn {
+    border: 1px solid rgba(239,68,68,.25) !important;
+    background: rgba(254,242,242,.8) !important;
+    color: #b91c1c !important;
+    border-radius: 12px !important;
+    font-weight: 500 !important;
+    transition: background .15s;
+}
+#reset-btn:hover { background: rgba(254,226,226,.9) !important; }
+/* ── Tabs ────────────────────────────────────────────────────────────────── */
+.gr-tab-nav button {
+    font-weight: 600 !important;
+    color: #475569 !important;
+    border-radius: 10px 10px 0 0 !important;
+    transition: color .15s;
+}
+.gr-tab-nav button.selected {
+    color: #4f46e5 !important;
+    border-bottom: 2px solid #4f46e5 !important;
+}
+/* ── Sidebar labels ──────────────────────────────────────────────────────── */
+.sidebar-label {
+    font-size: .82rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: .06em;
+    color: #6366f1;
+    margin: .6rem 0 .3rem;
+}
+/* ── Status badge ────────────────────────────────────────────────────────── */
+.status-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    font-size: .82rem;
+    font-weight: 600;
+    color: #4f46e5;
+    padding: 4px 12px;
+    border-radius: 999px;
+    background: rgba(99,102,241,.08);
+}
+.status-badge.done { color: #15803d; background: rgba(22,163,74,.08); }
+.pulse {
+    width: 8px; height: 8px;
+    border-radius: 50%;
+    background: #4f46e5;
+    animation: pulse-anim 1.4s infinite;
+}
+@keyframes pulse-anim {
+    0%   { opacity: 1; transform: scale(1); }
+    50%  { opacity: .4; transform: scale(1.4); }
+    100% { opacity: 1; transform: scale(1); }
+}
+/* ── Gallery ─────────────────────────────────────────────────────────────── */
+.gr-gallery {
+    border-radius: 12px !important;
+    border: 1px solid rgba(99,102,241,.08) !important;
+}
+/* ── File upload / download ──────────────────────────────────────────────── */
+.gr-file {
+    border-radius: 12px !important;
+    border: 1px dashed rgba(99,102,241,.20) !important;
+    background: rgba(248,250,255,.9) !important;
+}
+/* ── Report embed ────────────────────────────────────────────────────────── */
+#tab-report > div {
+    width: 100% !important;
+    max-width: 100% !important;
+}
+#tab-report .prose {
+    max-width: 100% !important;
+}
+/* Force dark text inside the HTML report for readability */
+#tab-report .rpt,
+#tab-report .rpt * {
+    color: #1e293b;
+}
+#tab-report .rpt h1, #tab-report .rpt h2 {
+    color: #3730a3;
+}
+#tab-report .rpt .findings {
+    background: #f8faff;
+    border: 1px solid #e0e7ff;
+}
+/* ── Tab panel backgrounds ───────────────────────────────────────────────── */
+.gr-tabitem {
+    background: rgba(255,255,255,.6) !important;
+    border-radius: 0 0 12px 12px;
+}
+/* ── Misc ────────────────────────────────────────────────────────────────── */
+footer { display: none !important; }
+.gr-examples .gr-samples-table { border-radius: 12px !important; }
+"""
+# ── Build UI ───────────────────────────────────────────────────────────────────
+with gr.Blocks(
+    title="Data Analyst Agent",
+    theme=gr.themes.Soft(
+        primary_hue=gr.themes.colors.indigo,
+        secondary_hue=gr.themes.colors.amber,
+        neutral_hue=gr.themes.colors.slate,
+        font=[
+            gr.themes.GoogleFont("Inter"),
+            "system-ui",
+            "sans-serif",
+        ],
+    ),
+    css=CSS,
+) as ui:
+    # ── Header ─────────────────────────────────────────────────────────────────
+    gr.HTML(
+        '<div id="app-header">'
+        "<h1>Data Analyst Agent</h1>"
+        "<p>Upload a CSV, ask a question — the agent writes &amp; runs Python, "
+        "then delivers insights you can save as a notebook.</p>"
+        "</div>"
+    )
+    agent_state = gr.State()
+    # ── Top bar: dataset upload + status ───────────────────────────────────────
+    with gr.Row(equal_height=True):
+        with gr.Column(scale=3):
+            dataset_upload = gr.File(
+                label="Dataset (CSV)",
+                file_types=[".csv"],
+                type="filepath",
+                elem_classes=["card"],
+            )
+        with gr.Column(scale=2):
+            status_html = gr.HTML(value="", elem_id="status-bar")
+    # ── Main content: left = chat, right = results tabs ────────────────────────
+    with gr.Row(equal_height=False):
+        # ── Left: conversation ─────────────────────────────────────────────────
+        with gr.Column(scale=5, min_width=440):
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                elem_id="chatbot",
+                height=500,
+                type="messages",
+                show_copy_button=True,
+                avatar_images=(
+                    None,
+                    "https://api.dicebear.com/9.x/bottts/svg?seed=analyst",
+                ),
+            )
+            # ── Input area ─────────────────────────────────────────────────────
+            with gr.Group(elem_id="input-group"):
+                message = gr.Textbox(
+                    show_label=False,
+                    placeholder="Ask a question about your data ...",
+                    lines=1,
+                    max_lines=4,
+                    scale=4,
+                )
+                success_criteria = gr.Textbox(
+                    show_label=False,
+                    placeholder="Success criteria (optional) — e.g. Include correlation matrix and at least one chart",
+                    lines=1,
+                    max_lines=2,
+                    scale=4,
+                )
+                with gr.Row():
+                    reset_btn = gr.Button(
+                        "Reset",
+                        variant="stop",
+                        elem_id="reset-btn",
+                        size="sm",
+                    )
+                    go_btn = gr.Button(
+                        "Analyse",
+                        variant="primary",
+                        elem_id="go-btn",
+                        size="lg",
+                    )
+        # ── Right: results tabs ────────────────────────────────────────────────
+        with gr.Column(scale=4, min_width=360):
+            with gr.Tabs():
+                # Tab 1 — Report
+                with gr.Tab("Report", id="tab-report"):
+                    report_html = gr.HTML(
+                        label="Analysis Report",
+                        visible=False,
+                    )
+                    gr.Markdown(
+                        "<p style='text-align:center;color:#94a3b8;font-size:.85rem'>"
+                        "Run an analysis to see the report here.</p>",
+                        elem_id="report-placeholder",
+                    )
+                # Tab 2 — Charts
+                with gr.Tab("Charts", id="tab-charts"):
+                    chart_gallery = gr.Gallery(
+                        label="Generated Charts",
+                        columns=2,
+                        rows=2,
+                        visible=False,
+                        height=400,
+                        object_fit="contain",
+                    )
+                    gr.Markdown(
+                        "<p style='text-align:center;color:#94a3b8;font-size:.85rem'>"
+                        "Charts will appear here after analysis.</p>",
+                        elem_id="charts-placeholder",
+                    )
+                # Tab 3 — Save / Download
+                with gr.Tab("Save", id="tab-save"):
+                    gr.HTML(
+                        '<p class="sidebar-label">Download Notebook</p>'
+                        '<p style="color:#64748b;font-size:.85rem">'
+                        "The notebook (.ipynb) bundles your analysis code, "
+                        "charts, and findings in one file.</p>"
+                    )
+                    notebook_download = gr.File(
+                        label="Notebook (.ipynb)",
+                        visible=False,
+                        interactive=False,
+                    )
+                # Tab 4 — Evaluator
+                with gr.Tab("Evaluator", id="tab-eval"):
+                    gr.Markdown(
+                        "<p style='color:#64748b;font-size:.85rem'>"
+                        "Internal quality evaluator feedback.</p>"
+                    )
+                    evaluator_feedback = gr.Markdown(visible=False)
+    # ── Example prompts ────────────────────────────────────────────────────────
+    gr.Examples(
+        examples=[
+            [
+                "What are the key trends in this dataset? Detect any outliers.",
+                "Include at least one chart",
+            ],
+            [
+                "Run a correlation analysis and identify the top 3 most correlated pairs.",
+                "",
+            ],
+            [
+                "Forecast the next 3 periods using a simple linear trend.",
+                "",
+            ],
+        ],
+        inputs=[message, success_criteria],
+        label="Quick-start prompts",
+    )
+    # ── Events ─────────────────────────────────────────────────────────────────
+    ui.load(_init_agent, [], [agent_state])
+    shared_inputs = [agent_state, message, success_criteria, dataset_upload, chatbot]
+    shared_outputs = [
+        chatbot, agent_state, message, chart_gallery, evaluator_feedback,
+        report_html, notebook_download, status_html,
+    ]
+    go_btn.click(process_message, shared_inputs, shared_outputs)
+    message.submit(process_message, shared_inputs, shared_outputs)
+    reset_btn.click(
+        reset_agent,
+        [agent_state],
+        [
+            chatbot, agent_state, message, success_criteria, dataset_upload,
+            chart_gallery, evaluator_feedback, report_html, notebook_download,
+            status_html,
+        ],
+    )
+if __name__ == "__main__":
+    ui.launch()

requirements.txt

@@ -0,0 +1,15 @@
+gradio>=4.0.0
+langchain>=0.2.0
+langchain-openai>=0.1.0
+langchain-community>=0.2.0
+langchain-experimental>=0.0.60
+langgraph>=0.2.0
+python-dotenv
+openai>=1.0.0
+pandas
+matplotlib
+seaborn
+scipy
+# Optional: provide SERPER_API_KEY to enable web search via LangChain's GoogleSerperAPIWrapper.
+wikipedia
+pydantic>=2.0.0

sample_sales_data.csv

@@ -0,0 +1,73 @@
+date,region,category,revenue,orders,marketing_spend,customer_satisfaction,returns,inventory_days
+2024-01-01,North,Electronics,42000,210,9000,4.2,8,28
+2024-02-01,North,Electronics,43800,218,9200,4.3,9,27
+2024-03-01,North,Electronics,45100,225,9500,4.4,7,26
+2024-04-01,North,Electronics,46700,232,9800,4.3,10,25
+2024-05-01,North,Electronics,48900,245,10100,4.5,8,24
+2024-06-01,North,Electronics,51200,252,10400,4.4,9,23
+2024-07-01,North,Electronics,54800,268,11000,4.6,8,22
+2024-08-01,North,Electronics,56200,274,11200,4.5,7,22
+2024-09-01,North,Electronics,57900,281,11400,4.6,8,21
+2024-10-01,North,Electronics,60100,289,11700,4.7,7,20
+2024-11-01,North,Electronics,64800,305,12600,4.6,11,19
+2024-12-01,North,Electronics,73500,338,13900,4.5,16,18
+2024-01-01,South,Home,28500,175,6100,4.1,6,34
+2024-02-01,South,Home,29100,179,6200,4.2,7,33
+2024-03-01,South,Home,30500,184,6400,4.1,6,32
+2024-04-01,South,Home,31700,190,6600,4.2,5,31
+2024-05-01,South,Home,33200,197,6900,4.3,6,30
+2024-06-01,South,Home,34800,205,7200,4.4,7,29
+2024-07-01,South,Home,35900,211,7400,4.5,6,28
+2024-08-01,South,Home,37200,219,7600,4.4,7,28
+2024-09-01,South,Home,38100,224,7800,4.5,8,27
+2024-10-01,South,Home,39500,231,8100,4.6,7,26
+2024-11-01,South,Home,42100,242,8600,4.5,9,25
+2024-12-01,South,Home,50600,278,9800,4.3,15,24
+2024-01-01,West,Fashion,19800,160,5200,3.9,12,42
+2024-02-01,West,Fashion,20500,164,5300,4.0,11,41
+2024-03-01,West,Fashion,21400,168,5450,4.0,10,40
+2024-04-01,West,Fashion,22100,171,5600,4.1,9,40
+2024-05-01,West,Fashion,23600,178,5900,4.2,8,39
+2024-06-01,West,Fashion,24900,183,6100,4.2,8,38
+2024-07-01,West,Fashion,25800,188,6300,4.3,9,37
+2024-08-01,West,Fashion,26600,192,6500,4.2,10,36
+2024-09-01,West,Fashion,27400,195,6700,4.1,11,36
+2024-10-01,West,Fashion,28900,201,6950,4.2,10,35
+2024-11-01,West,Fashion,30100,206,7200,4.1,11,34
+2024-12-01,West,Fashion,41500,244,8800,3.8,24,33
+2025-01-01,North,Electronics,45200,226,9700,4.4,8,24
+2025-02-01,North,Electronics,46600,230,9900,4.3,9,24
+2025-03-01,North,Electronics,48100,236,10100,4.4,8,23
+2025-04-01,North,Electronics,50300,244,10500,4.5,7,22
+2025-05-01,North,Electronics,52700,253,10800,4.5,8,21
+2025-06-01,North,Electronics,55100,261,11100,4.6,8,20
+2025-07-01,North,Electronics,58800,278,11800,4.7,7,19
+2025-08-01,North,Electronics,60300,284,12000,4.6,8,19
+2025-09-01,North,Electronics,62100,291,12300,4.7,7,18
+2025-10-01,North,Electronics,64800,299,12600,4.7,8,17
+2025-11-01,North,Electronics,69400,316,13400,4.6,10,16
+2025-12-01,North,Electronics,81200,358,15100,4.4,18,15
+2025-01-01,South,Home,31400,188,6700,4.2,6,30
+2025-02-01,South,Home,32200,191,6800,4.2,7,30
+2025-03-01,South,Home,33600,198,7050,4.3,6,29
+2025-04-01,South,Home,34900,204,7250,4.3,6,28
+2025-05-01,South,Home,36500,211,7550,4.4,5,27
+2025-06-01,South,Home,38100,219,7800,4.5,6,26
+2025-07-01,South,Home,39200,225,8000,4.5,6,26
+2025-08-01,South,Home,40700,233,8250,4.4,7,25
+2025-09-01,South,Home,41900,239,8450,4.5,7,24
+2025-10-01,South,Home,43400,246,8700,4.6,6,23
+2025-11-01,South,Home,46100,258,9200,4.5,8,22
+2025-12-01,South,Home,54800,291,10400,4.2,16,21
+2025-01-01,West,Fashion,22600,172,5600,4.0,10,37
+2025-02-01,West,Fashion,23400,176,5750,4.1,9,36
+2025-03-01,West,Fashion,24300,181,5900,4.1,8,35
+2025-04-01,West,Fashion,25200,185,6050,4.2,8,34
+2025-05-01,West,Fashion,26800,191,6300,4.2,7,33
+2025-06-01,West,Fashion,28100,196,6500,4.3,7,32
+2025-07-01,West,Fashion,29200,201,6700,4.3,8,31
+2025-08-01,West,Fashion,30100,205,6900,4.2,9,31
+2025-09-01,West,Fashion,30900,208,7100,4.1,10,30
+2025-10-01,West,Fashion,32400,214,7350,4.2,9,29
+2025-11-01,West,Fashion,33700,219,7600,4.1,10,28
+2025-12-01,West,Fashion,46800,261,9300,3.7,25,27