added fastmcp

orchestrator.py

@@ -1,44 +1,52 @@
 import os
 import json
-from contextlib import AsyncExitStack
 from typing import Any, List, Tuple, AsyncGenerator, Dict
 
 from openai import AsyncOpenAI
 
-# Try to import MCP client with different possible paths
+# Try to import FastMCP client with streamable HTTP support
 MCP_AVAILABLE = False
+FastMCPClient = None
 ClientSession = None
-streamablehttp_client = None
 
-# Try multiple import paths for MCP
-try:
-    import mcp
-    print(f"MCP package found at: {mcp.__file__}")
-    # Try to see what's available
-    print(f"MCP module contents: {dir(mcp)}")
+print("Attempting to import FastMCP client...")
 
-    # Try direct import
-    from mcp import ClientSession, streamablehttp_client
+try:
+    # Try FastMCP client (latest version)
+    from fastmcp import Client
+    FastMCPClient = Client
     MCP_AVAILABLE = True
-    print("MCP imported successfully via direct path")
-except ImportError as e:
-    print(f"Direct MCP import failed: {e}")
+    print("✅ FastMCP Client imported successfully!")
+
+except ImportError as e1:
+    print(f"❌ Failed to import FastMCP Client: {e1}")
     try:
-        from mcp.client.session import ClientSession
-        from mcp.client.streamablehttp import streamablehttp_client
+        # Alternative FastMCP import pattern
+        from fastmcp import FastMCPClient
         MCP_AVAILABLE = True
-        print("MCP imported successfully via client.session path")
+        print("✅ FastMCPClient imported successfully!")
+
     except ImportError as e2:
-        print(f"Client.session path failed: {e2}")
+        print(f"❌ Failed to import FastMCPClient: {e2}")
         try:
+            # Fallback to original MCP package
             from mcp.client.session import ClientSession
-            from mcp.client.transport.streamablehttp import streamablehttp_client
+            from mcp.client.streamablehttp import streamablehttp_client
             MCP_AVAILABLE = True
-            print("MCP imported successfully via transport path")
+            print("✅ MCP client imported successfully via mcp.client.streamablehttp")
         except ImportError as e3:
-            print(f"All MCP imports failed. Final error: {e3}")
-            # MCP not available
-            pass
+            print(f"❌ Failed to import via mcp.client.streamablehttp: {e3}")
+            try:
+                # Try without streamablehttp_client - just use ClientSession
+                from mcp.client.session import ClientSession
+                MCP_AVAILABLE = True
+                print("✅ MCP ClientSession imported (streamablehttp_client not available)")
+            except ImportError as e4:
+                print(f"❌ All MCP import attempts failed: {e4}")
+                MCP_AVAILABLE = False
+
+if not MCP_AVAILABLE:
+    print("⚠️  MCP client not available - falling back to HTTP requests")
 
 MCP_SERVER_URL = "https://mcp-1st-birthday-auto-deployer.hf.space/gradio_api/mcp/"
 
@@ -54,107 +62,276 @@ def _is_data_or_model_question(message: str) -> bool:
     return any(keyword.lower() in message.lower() for keyword in keywords)
 
 
+async def _make_mcp_request(tool_name: str, arguments: dict) -> dict:
+    """
+    Make HTTP request to MCP server since streamablehttp_client is not available
+    """
+    import httpx
+
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            MCP_SERVER_URL,
+            json={
+                "jsonrpc": "2.0",
+                "id": "1",
+                "method": "tools/call",
+                "params": {
+                    "name": f"Auto_Deployer_{tool_name}",
+                    "arguments": arguments
+                }
+            }
+        )
+        return response.json()
+
+
 async def _mcp_chat_stream(full_prompt: str) -> AsyncGenerator[Dict[str, Any], None]:
     """
     Simple autonomous AI that uses MCP tools for data/model questions
     """
     if not MCP_AVAILABLE:
-        yield {"type": "error", "content": "❌ MCP tools not available. Please install MCP client."}
+        yield {"type": "error", "content": "❌ MCP tools not available. Please install proper MCP client package."}
         return
 
-    # Extract user message
-    user_message = full_prompt.split("👤 **New request**:")[-1].strip() if "👤 **New request**:" in full_prompt else full_prompt
-    file_url = full_prompt.split("HTTP URL:\n")[-1].split("\n\n")[0] if "HTTP URL:" in full_prompt else ""
+    # Extract user message and file URL
+    if "👤 **New request**:" in full_prompt:
+        user_message = full_prompt.split("👤 **New request**:")[-1].strip()
+    else:
+        user_message = full_prompt.strip()
+
+    if "📎 File available at: " in full_prompt:
+        file_url = full_prompt.split("📎 File available at: ")[-1].split("\n\n")[0].strip()
+    elif "📎 **File uploaded!**" in full_prompt:
+        # Try to extract from the actual format used
+        lines = full_prompt.split('\n')
+        for line in lines:
+            if 'HTTP URL:' in line:
+                file_url = line.split('HTTP URL:')[-1].strip()
+                break
+        else:
+            file_url = ""
+    else:
+        file_url = ""
 
     # Initialize OpenAI client
     client = AsyncOpenAI(api_key=os.environ.get("OPENAI_API_KEY", ""))
 
-    # Connect to MCP
-    async with AsyncExitStack() as stack:
-        sse_transport = await stack.enter_async_context(streamablehttp_client(MCP_SERVER_URL))
-        session = await stack.enter_async_context(ClientSession(sse_transport[0], sse_transport[1]))
-        await session.initialize()
-
-        # Get tools from MCP
-        mcp_tools = await session.list_tools()
-        openai_tools = []
-
-        for tool in mcp_tools.tools:
-            openai_tool = {
-                "type": "function",
-                "function": {
-                    "name": tool.name.replace("Auto_Deployer_", ""),
-                    "description": tool.description or "MCP tool",
-                    "parameters": tool.inputSchema or {}
-                }
-            }
-            openai_tools.append(openai_tool)
-
-        # System message for autonomous AI
-        system_message = (
-            "You are an intelligent MLOps assistant. "
-            "Automatically use MCP tools when users ask about data analysis, model training, or deployment. "
-            "Always analyze the CSV file first if available. "
-            "Extract relevant information and provide clear, human-readable answers. "
-            "Be proactive and helpful."
-        )
-
-        messages = [
-            {"role": "system", "content": system_message},
-            {"role": "user", "content": f"File URL: {file_url}\n\nQuestion: {user_message}"}
-        ]
+    # Try to use FastMCP client if available
+    if FastMCPClient and MCP_AVAILABLE:
+        yield {"type": "thinking", "content": "🤖 **Using FastMCP client...**"}
+        return await _use_proper_mcp_client(client, user_message, file_url)
+    else:
+        yield {"type": "thinking", "content": "🤖 **Using HTTP fallback for MCP...**"}
+        return await _use_http_fallback(client, user_message, file_url)
 
-        # Get AI response with tool calls
-        response = await client.chat.completions.create(
-            model="gpt-5-mini",
-            messages=messages,
-            tools=openai_tools
-        )
 
-        message = response.choices[0].message
-        tool_calls = message.tool_calls or []
+async def _use_proper_mcp_client(client, user_message: str, file_url: str):
+    """Use FastMCP client"""
+    if not FastMCPClient:
+        yield {"type": "error", "content": "❌ FastMCP client not available"}
+        return
 
-        # Execute tool calls if any
-        if tool_calls:
-            yield {"type": "thinking", "content": "🤖 **Analyzing your request and using appropriate tools...**"}
+    try:
+        # Connect to MCP server using FastMCP
+        async with FastMCPClient(MCP_SERVER_URL) as mcp_client:
+            # Get tools from MCP
+            mcp_tools = await mcp_client.list_tools()
+            openai_tools = []
+            for tool in mcp_tools.tools:
+                openai_tool = {
+                    "type": "function",
+                    "function": {
+                        "name": tool.name.replace("Auto_Deployer_", ""),
+                        "description": tool.description or "MCP tool",
+                        "parameters": tool.inputSchema or {}
+                    }
+                }
+                openai_tools.append(openai_tool)
+
+            # System message for autonomous AI
+            system_message = (
+                "You are an intelligent MLOps assistant. "
+                "Automatically use MCP tools when users ask about data analysis, model training, or deployment. "
+                "Always analyze the CSV file first if available. "
+                "Extract relevant information and provide clear, human-readable answers. "
+                "Be proactive and helpful."
+            )
 
-            for tool_call in tool_calls:
-                args = json.loads(tool_call.function.arguments)
+            messages = [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": f"File URL: {file_url}\n\nQuestion: {user_message}"}
+            ]
 
-                # Add file_url if not present and needed
-                if file_url and 'file_path' not in args and 'file_url' not in args:
-                    args['file_path'] = file_url
-                elif file_url and 'file_url' in [p.lower() for p in args.keys()]:
-                    args['file_url'] = file_url
+            # Get AI response with tool calls
+            response = await client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                tools=openai_tools
+            )
 
-                yield {"type": "tool", "content": f"🔧 **Using**: {tool_call.function.name}"}
+            message = response.choices[0].message
+            tool_calls = message.tool_calls or []
+
+            # Execute tool calls if any
+            if tool_calls:
+                yield {"type": "thinking", "content": "🤖 **Analyzing your request and using appropriate tools...**"}
+
+                for tool_call in tool_calls:
+                    args = json.loads(tool_call.function.arguments)
+
+                    # Add file_url if not present
+                    if file_url and 'file_path' not in args:
+                        args['file_path'] = file_url
+
+                    yield {"type": "tool", "content": f"🔧 **Using**: {tool_call.function.name}"}
+
+                    try:
+                        # Execute MCP tool via FastMCP client
+                        result = await mcp_client.call_tool(f"Auto_Deployer_{tool_call.function.name}", args)
+
+                        if hasattr(result, 'content'):
+                            content = result.content
+                            if isinstance(content, list):
+                                for item in content:
+                                    if hasattr(item, 'text'):
+                                        yield {"type": "result", "content": f"📊 **Result**: {item.text}"}
+                            else:
+                                yield {"type": "result", "content": f"📊 **Result**: {content}"}
+                        else:
+                            yield {"type": "result", "content": f"📊 **Result**: {str(result)}"}
+
+                    except Exception as e:
+                        yield {"type": "error", "content": f"❌ **Error executing tool**: {str(e)}"}
+
+                # Get final analysis
+                messages.append({"role": "assistant", "content": message.content or ""})
+
+                final_response = await client.chat.completions.create(
+                    model="gpt-4o",
+                    messages=messages
+                )
+
+                yield {"type": "final", "content": f"🎯 **Answer**: {final_response.choices[0].message.content}"}
+
+            else:
+                # No tools needed, just return AI response
+                yield {"type": "final", "content": f"🎯 **Answer**: {message.content}"}
+
+    except Exception as e:
+        yield {"type": "error", "content": f"❌ **FastMCP client error**: {str(e)}"}
+
+
+async def _use_http_fallback(client, user_message: str, file_url: str):
+    """Fallback using direct HTTP requests"""
+    # Define available tools (hardcoded for fallback)
+    openai_tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "analyze_data_tool",
+                "description": "Analyze a dataset to understand its structure, statistics, and insights",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {"type": "string", "description": "Path to the CSV file to analyze"}
+                    },
+                    "required": ["file_path"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "train_model_tool",
+                "description": "Train a machine learning model on the provided dataset",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "file_path": {"type": "string", "description": "Path to the training CSV file"},
+                        "target_column": {"type": "string", "description": "Name of the target column"},
+                        "task_type": {"type": "string", "enum": ["classification", "regression", "time_series"]},
+                        "test_size": {"type": "number", "default": 0.2},
+                        "random_state": {"type": "integer", "default": 42}
+                    },
+                    "required": ["file_path", "target_column", "task_type"]
+                }
+            }
+        }
+    ]
 
-                # Execute MCP tool
-                result = await session.call_tool(f"Auto_Deployer_{tool_call.function.name}", args)
+    # System message for autonomous AI
+    system_message = (
+        "You are an intelligent MLOps assistant. "
+        "Automatically use MCP tools when users ask about data analysis, model training, or deployment. "
+        "Always analyze the CSV file first if available. "
+        "Extract relevant information and provide clear, human-readable answers. "
+        "Be proactive and helpful."
+    )
+
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": f"File URL: {file_url}\n\nQuestion: {user_message}"}
+    ]
 
-                # Extract and display results
-                if hasattr(result, 'content'):
-                    content = result.content
-                    if isinstance(content, list):
-                        for item in content:
-                            if hasattr(item, 'text'):
-                                yield {"type": "result", "content": f"📊 **Result**: {item.text}"}
+    # Get AI response with tool calls
+    response = await client.chat.completions.create(
+        model="gpt-4o",
+        messages=messages,
+        tools=openai_tools
+    )
+
+    message = response.choices[0].message
+    tool_calls = message.tool_calls or []
+
+    # Execute tool calls if any
+    if tool_calls:
+        yield {"type": "thinking", "content": "🤖 **Analyzing your request and using appropriate tools...**"}
+
+        for tool_call in tool_calls:
+            args = json.loads(tool_call.function.arguments)
+
+            # Add file_url if not present
+            if file_url and 'file_path' not in args:
+                args['file_path'] = file_url
+
+            yield {"type": "tool", "content": f"🔧 **Using**: {tool_call.function.name}"}
+
+            try:
+                # Execute MCP tool via HTTP request
+                result = await _make_mcp_request(tool_call.function.name, args)
+
+                if "result" in result:
+                    tool_result = result["result"]
+                    if hasattr(tool_result, 'content'):
+                        content = tool_result.content
+                        if isinstance(content, list):
+                            for item in content:
+                                if hasattr(item, 'text'):
+                                    yield {"type": "result", "content": f"📊 **Result**: {item.text}"}
+                        else:
+                            yield {"type": "result", "content": f"📊 **Result**: {content}"}
                     else:
-                        yield {"type": "result", "content": f"📊 **Result**: {content}"}
+                        yield {"type": "result", "content": f"📊 **Result**: {str(tool_result)}"}
+                elif "error" in result:
+                    yield {"type": "error", "content": f"❌ **Tool Error**: {result['error']}"}
+                else:
+                    yield {"type": "result", "content": f"📊 **Result**: {str(result)}"}
 
-            # Get final analysis
-            messages.append({"role": "assistant", "content": message.content or ""})
+            except Exception as e:
+                yield {"type": "error", "content": f"❌ **Error executing tool**: {str(e)}"}
 
-            final_response = await client.chat.completions.create(
-                model="gpt-5-mini",
-                messages=messages
-            )
+        # Get final analysis
+        messages.append({"role": "assistant", "content": message.content or ""})
+
+        final_response = await client.chat.completions.create(
+            model="gpt-4o",
+            messages=messages
+        )
 
-            yield {"type": "final", "content": f"🎯 **Answer**: {final_response.choices[0].message.content}"}
+        yield {"type": "final", "content": f"🎯 **Answer**: {final_response.choices[0].message.content}"}
 
-        else:
-            # No tools needed, just return AI response
-            yield {"type": "final", "content": f"🎯 **Answer**: {message.content}"}
+    else:
+        # No tools needed, just return AI response
+        yield {"type": "final", "content": f"🎯 **Answer**: {message.content}"}
 
 
 async def run_orchestrated_chat_stream(

requirements.txt

@@ -1,3 +1,2 @@
 openai==2.8.1
-gradio[mcp]==6.0.0
-mcp
+fastmcp>=2.13.1