refactor: Update Gradio application to enhance MLOps agent functionality with improved tool resolution, refined chat handling, and clearer user prompts. Streamlined file upload process and removed outdated todo list.

app.py

@@ -1,5 +1,6 @@
 """
-Gradio + OpenAI MCP Connector — Clean, Fast, Streaming, With File Upload
+Gradio + OpenAI Responses API + Remote MCP Server (HTTP)
+CSV-based MLOps Agent with streaming final answer & MCP tools
 """
 
 import os
@@ -8,210 +9,363 @@ import shutil
 import gradio as gr
 from openai import OpenAI
 
-# ---------------------
-# CONFIGURATION
-# ---------------------
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-MCP_SERVER_URL = "https://mcp-1st-birthday-auto-deployer.hf.space/gradio_api/mcp/"
+# -------------------------
+# Config
+# -------------------------
 
-MODEL_FAST = "gpt-5-mini"  # for tool resolution / MCP calls
-MODEL_STREAM = "gpt-5"  # for final streaming reply
+MCP_SERVER_URL = "https://mcp-1st-birthday-auto-deployer.hf.space/gradio_api/mcp/"
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+MODEL = "gpt-5-mini"  # you can swap to gpt-5 for final answers if you want
 
 client = OpenAI(api_key=OPENAI_API_KEY)
 
-# ---------------------
-# SYSTEM PROMPT
-# ---------------------
-SYSTEM_PROMPT = """
-You are a fast MLOps automation assistant equipped with remote MCP tools
-for dataset analysis, model training, evaluation, and deployment.
-
-Rules:
-- Use MCP tools when they directly address the user's request.
-- Treat the uploaded CSV file URL as the source of truth. Never modify it.
-- Never hallucinate tool names, arguments, or fields.
-- Keep your internal reasoning hidden.
-- Keep responses short, direct, and practical.
-
-Workflow:
-1) Decide if a tool is needed for the request.
-2) If needed, call the correct MCP tool with the exact schema.
-3) After tools complete, give a concise summary in plain language.
-4) If no tool is needed, answer directly and briefly.
-"""
-
-# ---------------------
-# NATIVE MCP CONNECTOR (HTTP STREAMING)
-# ---------------------
-TOOLS = [
+MCP_TOOLS = [
     {
         "type": "mcp",
-        "server_label": "deploy_tools",
-        "server_url": MCP_SERVER_URL,  # HTTP streaming MCP server
+        "server_label": "auto-deployer",
+        "server_url": MCP_SERVER_URL,
+        "require_approval": "never",
     }
 ]
 
+# -------------------------
+# Short prompts
+# -------------------------
+
+TOOL_SYSTEM_PROMPT = """
+You are an MLOps assistant with MCP tools for CSV analysis, training,
+evaluation, and deployment.
+
+If the user asks about data, datasets, CSVs, models, training,
+evaluation, or deployment, call MCP tools instead of guessing.
+
+Use the CSV file URL exactly as given when tools need a file path.
+Do not invent tool names or parameters.
+Keep internal reasoning hidden and reply briefly with technical details.
+"""
+
+FINAL_SYSTEM_PROMPT = """
+You are a helpful MLOps explainer and general assistant.
+
+You see the conversation plus a short technical summary of what tools did
+(if any). Explain in simple language what was done and what the results
+mean. Mention key metrics, model IDs, or endpoints if available.
+Suggest next steps briefly. For normal chat (no tools), just respond
+helpfully.
+
+Do not mention tools or internal phases explicitly.
+Keep the answer clear and concise.
+"""
+
 
-# ---------------------
-# FILE UPLOAD HANDLER
-# ---------------------
-def handle_upload(file_obj, request: gr.Request):
+# -------------------------
+# Helpers
+# -------------------------
+
+
+def history_to_text(history) -> str:
+    """
+    Turn Gradio history (list of {role, content}) into a plain-text
+    conversation transcript for the model.
+    """
+    if not history:
+        return ""
+    lines = []
+    for msg in history:
+        role = msg.get("role")
+        content = msg.get("content", "")
+        if role == "user":
+            lines.append(f"User: {content}")
+        elif role == "assistant":
+            lines.append(f"Assistant: {content}")
+    return "\n".join(lines)
+
+
+def extract_output_text(response) -> str:
     """
-    - Persist uploaded file to a stable /tmp path
-    - Return a public URL that the MCP tools can use directly
+    Extract plain text from a non-streaming Responses API call.
+    Fallback gracefully if the shape is unexpected.
+    """
+    try:
+        if response.output and len(response.output) > 0:
+            first = response.output[0]
+            if getattr(first, "content", None):
+                c0 = first.content[0]
+                text = getattr(c0, "text", None)
+                if text:
+                    return text
+        # Fallback
+        return getattr(response, "output_text", None) or str(response)
+    except Exception:
+        return str(response)
+
+
+def handle_upload(file_path, request: gr.Request):
     """
-    if file_obj is None:
+    1) Take uploaded file path (string)
+    2) Copy to /tmp for a stable path
+    3) Build a public Gradio file URL that the MCP server can fetch via HTTP
+    """
+    if not file_path:
         return None
 
-    local_path = file_obj.name
+    local_path = file_path
     stable_path = os.path.join("/tmp", os.path.basename(local_path))
-
     try:
         shutil.copy(local_path, stable_path)
         local_path = stable_path
     except Exception:
-        # If copy fails, still try original path
+        # If copy fails, just use the original path
         pass
 
-    base = str(request.base_url).rstrip("/")
-    return f"{base}/gradio_api/file={local_path}"
+    base_url = str(request.base_url).rstrip("/")
+    public_url = f"{base_url}/gradio_api/file={local_path}"
+    return public_url
 
 
-# ---------------------
-# MAIN CHAT HANDLER (STREAMING)
-# ---------------------
-def chat_send_stream(user_msg, history, file_url):
+def should_use_tools(user_msg: str) -> bool:
+    """
+    Simple heuristic to decide if this turn should trigger MCP tools.
+    Only fire tools if the user is clearly asking for data / model work.
     """
-    2-phase pipeline:
-      PHASE 1: Non-streaming tool resolution using MODEL_FAST
-      PHASE 2: Streaming final answer using MODEL_STREAM
+    text = user_msg.lower()
+    keywords = [
+        "data",
+        "dataset",
+        "csv",
+        "train",
+        "training",
+        "model",
+        "deploy",
+        "deployment",
+        "predict",
+        "prediction",
+        "inference",
+        "evaluate",
+        "evaluation",
+        "analyze",
+        "analysis",
+    ]
+    return any(k in text for k in keywords)
+
+
+# -------------------------
+# Main chat handler (streaming)
+# -------------------------
 
-    Gradio Chatbot (messages mode) expects:
-      history: list[{"role": "...", "content": "..."}]
+
+def chat_send_stream(user_msg, history, file_url):
+    """
+    Main Gradio streaming handler.
+
+    - If the user is just chatting (e.g., "hey"), respond directly
+      with a streaming answer (no tools, no CSV required).
+    - If the user clearly asks for data/model operations, run:
+        Phase 1: non-stream tool phase via Responses API + MCP tools
+        Phase 2: streaming final answer via Responses API (no tools)
+    - Keeps full chat history so follow-ups work.
+    - Shows status/progress messages in the UI when tools are used.
     """
 
-    # Ensure history is list[dict(role, content)]
+    # UI history (what Gradio displays)
     if history is None:
         history = []
 
-    # Append the user message to the UI history first
+    # Append the user message to the UI history
     history.append({"role": "user", "content": user_msg})
 
-    # ---- Build messages for OpenAI (sanitize away metadata etc.) ----
-    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-    for msg in history:
-        role = msg.get("role")
-        content = msg.get("content", "")
-        if role in ("user", "assistant"):
-            messages.append({"role": role, "content": content})
-
-    # Inject file context into *last* user message for the model
-    if file_url:
-        last_user = messages[-1]
-        if last_user["role"] == "user":
-            last_user["content"] = f"[Uploaded CSV file: {file_url}]\n\n{user_msg}"
-
-    # -----------------------------
-    # PHASE 1 — TOOL RESOLUTION
-    # -----------------------------
-    tool_phase = client.responses.create(
-        model=MODEL_FAST,
-        reasoning={"effort": "low"},  # minimal thinking for speed
-        tools=TOOLS,
-        instructions=SYSTEM_PROMPT,
-        input=messages,
+    # Conversation before this turn (for context)
+    convo_before = history_to_text(history[:-1])
+
+    # Decide if this message should trigger tools
+    use_tools = should_use_tools(user_msg)
+
+    # -------------------------
+    # BRANCH 1: No tools (normal chat, e.g. "hey")
+    # -------------------------
+    if not use_tools:
+        # Add a small status bubble then stream
+        history.append({"role": "assistant", "content": "✏️ Generating answer..."})
+        yield history
+
+        # Build input text for Responses API
+        input_text = (
+            (f"Conversation so far:\n{convo_before}\n\n" if convo_before else "")
+            + "Latest user message:\n"
+            + user_msg
+        )
+
+        stream = client.responses.create(
+            model=MODEL,
+            instructions=FINAL_SYSTEM_PROMPT,
+            input=input_text,
+            reasoning={"effort": "low"},
+            stream=True,
+        )
+
+        final_text = ""
+        for event in stream:
+            if event.type == "response.output_text.delta":
+                final_text += event.delta
+                history[-1]["content"] = final_text
+                yield history
+            elif event.type == "response.completed":
+                break
+
+        return
+
+    # -------------------------
+    # BRANCH 2: Tools needed (data / model operations)
+    # -------------------------
+
+    # If tools are needed but no file URL, ask for CSV
+    if not file_url:
+        history.append(
+            {
+                "role": "assistant",
+                "content": (
+                    "To analyze, train, or deploy, please upload a CSV file first "
+                    "using the file upload control."
+                ),
+            }
+        )
+        yield history
+        return
+
+    # User message for the model includes the CSV URL
+    user_with_file = f"[Uploaded CSV file URL: {file_url}]\n\n{user_msg}"
+
+    # -------------------------
+    # Phase 1: Tool + technical summary (non-streaming)
+    # -------------------------
+
+    # Show a status message in UI
+    history.append(
+        {
+            "role": "assistant",
+            "content": "⏳ Analyzing your request and selecting MCP tools...",
+        }
+    )
+    yield history
+
+    # Build a single string input for the tool phase
+    tool_phase_input = (
+        (f"Conversation so far:\n{convo_before}\n\n" if convo_before else "")
+        + "Latest user request (with file URL):\n"
+        + user_with_file
+        + "\n\nYour task: decide which MCP tools to call and run them. "
+        "Then return a short technical summary of what you did and what the tools returned."
     )
 
-    tool_feedback_lines = []
-
-    # Collect MCP tool usage info if present
-    if tool_phase.output:
-        for item in tool_phase.output:
-            # Types may vary; handle generically
-            item_type = getattr(item, "type", None)
-            if item_type == "tool_call":
-                tool_feedback_lines.append(f"🛠️ Used tool `{item.name}`.")
-            elif item_type == "tool_result":
-                tool_feedback_lines.append(str(item.content))
-
-    if not tool_feedback_lines:
-        tool_feedback_lines.append("No MCP tools needed.")
-
-    tool_feedback_text = "\n".join(tool_feedback_lines)
-
-    # Add assistant message with tool feedback to both histories
-    history.append({"role": "assistant", "content": tool_feedback_text})
-    yield history  # show tool feedback immediately in UI
+    tool_phase = client.responses.create(
+        model=MODEL,
+        instructions=TOOL_SYSTEM_PROMPT,
+        input=tool_phase_input,
+        tools=MCP_TOOLS,
+        reasoning={"effort": "low"},
+    )
 
-    # Add that same feedback into messages for the final answer
-    messages.append({"role": "assistant", "content": tool_feedback_text})
+    scratchpad = extract_output_text(tool_phase).strip()
+    if not scratchpad:
+        scratchpad = "No MCP tool output was returned."
 
-    # -----------------------------
-    # PHASE 2 — STREAMING FINAL ANSWER
-    # -----------------------------
-    final_text = tool_feedback_text + "\n\n"
+    # Update status message to show tools finished
+    history[-1] = {
+        "role": "assistant",
+        "content": "✅ MCP tools finished. Preparing explanation...",
+    }
+    yield history
+
+    # -------------------------
+    # Phase 2: Final streaming explanation
+    # -------------------------
+
+    # Replace last assistant message with streaming answer
+    history[-1] = {"role": "assistant", "content": ""}
+
+    # Build a single string input for the final explanation phase
+    final_input = (
+        (f"Conversation so far:\n{convo_before}\n\n" if convo_before else "")
+        + "Latest user request (with file URL):\n"
+        + user_with_file
+        + "\n\nTechnical summary of tool actions and results:\n"
+        + scratchpad
+        + "\n\nNow explain this clearly to the user."
+    )
 
     stream = client.responses.create(
-        model=MODEL_STREAM,
+        model=MODEL,
+        instructions=FINAL_SYSTEM_PROMPT,
+        input=final_input,
         reasoning={"effort": "low"},
-        instructions=SYSTEM_PROMPT,
-        input=messages,
         stream=True,
     )
 
-    # Stream tokens and update the last assistant message
-    for ev in stream:
-        if ev.type == "response.output_text.delta":
-            final_text += ev.delta
+    final_text = ""
+    for event in stream:
+        if event.type == "response.output_text.delta":
+            final_text += event.delta
             history[-1]["content"] = final_text
             yield history
-        elif ev.type == "response.completed":
+        elif event.type == "response.completed":
             break
 
-    stream.close()
 
+# -------------------------
+# Gradio UI
+# -------------------------
 
-# ---------------------
-# GRADIO UI
-# ---------------------
-with gr.Blocks(title="MCP + GPT-5 — Fast Streaming MLOps Agent") as demo:
+with gr.Blocks(title="MCP + GPT-5 mini - Streaming MLOps Agent") as demo:
     gr.Markdown(
         """
-        # 🚀 AI-Driven MLOps Agent (MCP-Powered)
-        - Upload a CSV file  
-        - Tools resolve quickly via MCP  
-        - Final answer streams smoothly  
+        # AI-Driven MLOps Agent 🤖
+
+        - You can just chat (e.g. "hey") — no tools needed.
+        - For data work, **upload a CSV file** and ask to analyze, train, or deploy.
+        - When tools are used, you’ll see status updates.
+        - Final answers stream token by token.
         """
     )
 
-    file_state = gr.State()  # stores uploaded CSV URL
+    file_url_state = gr.State(value=None)
 
     uploader = gr.File(
-        label="Upload CSV file",
-        type="filepath",
+        label="Optional CSV file upload (required for data/model operations)",
         file_count="single",
+        type="filepath",
         file_types=[".csv"],
     )
 
     uploader.change(
         handle_upload,
         inputs=[uploader],
-        outputs=[file_state],
+        outputs=[file_url_state],
     )
 
-    chatbot = gr.Chatbot(label="Chat")  # uses messages format (dicts)
-    msg = gr.Textbox(label="Message")
-    send = gr.Button("Send")
+    chatbot = gr.Chatbot(
+        label="Chat",
+        avatar_images=(
+            None,
+            "https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.png",
+        ),
+    )
+
+    msg = gr.Textbox(
+        label="Message",
+        interactive=True,
+        placeholder="Say hi, or ask me to analyze / train / deploy on your dataset...",
+    )
+    send = gr.Button("Send", interactive=True)
 
     send.click(
         chat_send_stream,
-        inputs=[msg, chatbot, file_state],
+        inputs=[msg, chatbot, file_url_state],
         outputs=[chatbot],
     ).then(lambda: "", outputs=[msg])
 
     msg.submit(
         chat_send_stream,
-        inputs=[msg, chatbot, file_state],
+        inputs=[msg, chatbot, file_url_state],
         outputs=[chatbot],
     ).then(lambda: "", outputs=[msg])
 
@@ -219,6 +373,6 @@ with gr.Blocks(title="MCP + GPT-5 — Fast Streaming MLOps Agent") as demo:
 if __name__ == "__main__":
     demo.queue().launch(
         allowed_paths=["/tmp"],
+        ssr_mode=False,
         show_error=True,
-        quiet=True,
-    )
+        )

todolist.md

@@ -1,5 +0,0 @@
-- [] Diable message and send button while the final reosne is not recived. 
-- [] reduce the thinking preces in tools secaltiona dn then analysing the dataset.
-- [] clear the message when user end the message. 
-- [] model is not taking an acocunt of previous ocnverations. 
-- [] add more infor to the readme