refactor: Remove legacy files and consolidate functionality into a streamlined Gradio application with enhanced MCP client integration, improved file handling, and updated AI orchestration for better user experience.

README.md

@@ -13,196 +13,3 @@ tags:
   - mcp-in-action-track-customer
 ---
 
-
-# AI-Driven MLOps Agent 🤖
-
-[![Hugging Face](https://img.shields.io/badge/🤗-HuggingFace-yellow?style=flat-square&logo=huggingface)](https://huggingface.co)
-[![Python](https://img.shields.io/badge/Python-3.8+-blue?style=flat-square&logo=python)](https://python.org)
-[![License](https://img.shields.io/badge/License-Apache%202.0-green?style=flat-square)](LICENSE)
-[![OpenAI](https://img.shields.io/badge/OpenAI-GPT--4o--mini-red?style=flat-square&logo=openai)](https://openai.com)
-
-> Chat interface for automated ML pipeline operations - Analyze, train, deploy, and test API, all in seconds.
-
-## 🚀 Overview
-
-AI-Driven MLOps Agent is a intelligent chat-based application that automates machine learning workflows using Hugging Face's MCP (Model Context Protocol) servers. This agent can analyze datasets, train models, deploy them to production, and provide comprehensive insights - all through natural language conversations.
-
-## ✨ Features
-
-- **🤖 Intelligent Chat Interface**: Natural language interaction with AI-powered ML operations
-- **📊 Automated Data Analysis**: Instant CSV analysis with data quality insights
-- **🎯 Smart Intent Recognition**: AI understands your ML goals and selects appropriate tools
-- **🔧 MCP Integration**: Seamlessly connects to Hugging Face's MCP servers for ML operations
-- **📁 File Upload & Processing**: Automatic CSV file handling with URL generation
-- **🔄 Streaming Responses**: Real-time feedback during long-running operations
-- **🎨 Modern UI**: Clean, intuitive Gradio interface with responsive design
-
-## 🛠️ Available Tools
-
-The agent integrates with these powerful MCP tools:
-
-- **📊 Data Analysis**: Comprehensive dataset analysis and insights
-- **🚈 Model Training**: Automated ML model training with optimized parameters
-- **🚀 Model Deployment**: One-click deployment to production APIs
-- **⚡ Auto-Deploy Pipeline**: End-to-end ML workflow automation
-
-## 📋 Prerequisites
-
-- Python 3.8 or higher
-- OpenAI API key (set as `OPENAI_API_KEY` environment variable)
-- Access to Hugging Face's MCP server
-
-## 🔧 Installation
-
-1. **Clone the repository**:
-   ```bash
-   git clone <repository-url>
-   cd mlops-agent
-   ```
-
-2. **Install dependencies**:
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-3. **Set up environment variables**:
-   ```bash
-   export OPENAI_API_KEY="your-openai-api-key-here"
-   ```
-
-4. **Run the application**:
-   ```bash
-   python app.py
-   ```
-
-## 🎯 Usage
-
-### Quick Start
-
-1. **Upload a CSV file** using the file upload component
-2. **Start chatting** with the AI about your ML goals:
-   - "Analyze my data"
-   - "Train a classification model"
-   - "Deploy this to production"
-   - "Run the complete pipeline"
-
-### Example Interactions
-
-#### Data Analysis
-```
-User: "Can you analyze my dataset?"
-Agent: "I'll analyze your CSV file and provide insights about data quality, patterns, and recommendations."
-```
-
-#### Model Training
-```
-User: "I want to train a model to predict customer churn"
-Agent: "I'll use your uploaded data to train a classification model optimized for churn prediction."
-```
-
-#### Auto-Deploy
-```
-User: "Handle the complete ML pipeline for me"
-Agent: "I'll analyze your data, train an optimized model, and deploy it to a live API endpoint."
-```
-
-## 🏗️ Architecture
-
-```
-mlops-agent/
-├── app.py                 # Main Gradio application
-├── mcp_client.py          # MCP server connection and tool execution
-├── ai_orchestrator.py     # GPT-5-mini integration and reasoning
-├── file_handler.py        # File upload and URL generation
-├── config.py             # Configuration and environment variables
-├── requirements.txt       # Python dependencies
-└── README.md             # Project documentation
-```
-
-### Core Components
-
-- **MCPClientManager**: Handles connections to Hugging Face MCP servers
-- **AIOrchestrator**: Uses GPT-5-mini for intent recognition and response generation
-- **FileHandler**: Processes CSV uploads and generates accessible URLs
-- **ChatbaseMCPApp**: Main application orchestrating all components
-
-## ⚙️ Configuration
-
-### Environment Variables
-
-| Variable | Description | Required |
-|----------|-------------|----------|
-| `OPENAI_API_KEY` | Your OpenAI API key | Yes |
-
-### Configuration Options
-
-The `config.py` file contains customizable parameters:
-
-- **MCP_SERVER_URL**: MCP server endpoint (default: Hugging Face Auto-Deployer)
-- **OPENAI_MODEL**: OpenAI model to use (default: gpt-5-mini)
-- **ALLOWED_FILE_TYPES**: Supported file types (default: CSV only)
-- **MAX_FILE_SIZE**: Maximum upload size (default: 100MB)
-
-## 🔒 Security Features
-
-- **Input Validation**: File type and size restrictions
-- **API Key Protection**: Secure environment variable handling
-- **Safe URL Generation**: Secure file access mechanisms
-- **Error Handling**: Graceful failure handling with user-friendly messages
-
-## 🚀 Deployment
-
-### Local Development
-
-```bash
-python app.py
-```
-
-The application will start on `http://localhost:7860`
-
-### Hugging Face Spaces
-
-This application is designed for deployment on Hugging Face Spaces:
-
-1. Set `OPENAI_API_KEY` in Space secrets
-2. Use the included `README.md` configuration
-3. Deploy automatically
-
-## 🧪 Testing
-
-### Manual Testing
-
-1. Upload a sample CSV file
-2. Test various intents:
-   - "analyze my data"
-   - "train a model" 
-   - "deploy this"
-   - "auto deploy the pipeline"
-
-### Sample CSV for Testing
-
-```csv
-age,income,education,target
-25,50000,Bachelor,0
-35,75000,Master,1
-45,90000,PhD,0
-55,120000,Bachelor,1
-```
-
-## 🐛 Troubleshooting
-
-### Common Issues
-
-1. **OpenAI API Key Error**:
-   - Ensure `OPENAI_API_KEY` is set correctly
-   - Check API key permissions and billing
-
-2. **MCP Connection Issues**:
-   - Verify internet connection
-   - Check Hugging Face MCP server status
-
-3. **File Upload Problems**:
-   - Ensure file is CSV format
-   - Check file size limit (100MB)
-
-

ai_orchestrator.py

@@ -1,303 +0,0 @@
-"""
-AI Orchestrator using GPT-5-mini for intent recognition, tool selection, and response generation
-Integrates with MCP client to provide intelligent tool execution
-"""
-import asyncio
-import json
-import logging
-import re
-from typing import Dict, Any, List, Optional, Tuple
-from openai import AsyncOpenAI
-from mcp_client import MCPClient
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class AIOrchestrator:
-    """AI-powered orchestrator for tool selection and execution"""
-
-    def __init__(self, openai_api_key: str, model: str = "gpt-5-mini"):
-        self.client = AsyncOpenAI(api_key=openai_api_key)
-        self.model = model
-        self.mcp_client: Optional[MCPClient] = None
-        self.conversation_history: List[Dict[str, str]] = []
-        self.file_context: Dict[str, Any] = {}
-
-    async def initialize(self):
-        """Initialize the orchestrator and connect to MCP client"""
-        try:
-            self.mcp_client = MCPClient()
-            success = await self.mcp_client.connect()
-            if not success:
-                raise RuntimeError("Failed to connect to MCP client")
-            logger.info("AI Orchestrator initialized successfully")
-        except Exception as e:
-            logger.error(f"Failed to initialize AI Orchestrator: {str(e)}")
-            raise
-
-    async def process_message(
-        self,
-        message: str,
-        file_url: Optional[str] = None,
-        stream: bool = False
-    ) -> Tuple[str, List[str]]:
-        """Process user message and return response with tool execution steps"""
-        try:
-            # Add file context if available
-            if file_url:
-                self.file_context['file_url'] = file_url
-                self.file_context['has_file'] = True
-            else:
-                self.file_context['has_file'] = False
-
-            # Add user message to conversation history
-            self.conversation_history.append({
-                "role": "user",
-                "content": message
-            })
-
-            # Get available tools from MCP client
-            available_tools = self.mcp_client.get_available_tools()
-
-            # Analyze user intent and select tools
-            tool_plan = await self._analyze_intent_and_plan_tools(message, available_tools)
-
-            if not tool_plan['tools']:
-                # No tools needed, respond directly
-                response = await self._generate_direct_response(message)
-                return response, []
-
-            # Execute tools and generate response
-            execution_steps = []
-            final_response = await self._execute_tools_and_respond(
-                tool_plan, message, execution_steps, stream
-            )
-
-            return final_response, execution_steps
-
-        except Exception as e:
-            logger.error(f"Error processing message: {str(e)}")
-            error_response = f"❌ An error occurred: {str(e)}\n\nPlease try again or rephrase your request."
-            return error_response, []
-
-    async def _analyze_intent_and_plan_tools(
-        self,
-        message: str,
-        available_tools: Dict[str, str]
-    ) -> Dict[str, Any]:
-        """Analyze user intent and create tool execution plan"""
-
-        system_prompt = """You are an AI assistant that analyzes user requests and determines which ML tools to use.
-
-Available tools:
-1. Auto_Deployer_analyze_data_tool - Analyze CSV datasets and provide statistical metadata
-   Parameters: file_path (URL to CSV file)
-
-2. Auto_Deployer_train_model_tool - Train ML models on CSV data
-   Parameters: file_path (URL to CSV file), target_column (string), task_type (classification/regression/time_series)
-
-3. Auto_Deployer_deploy_model_tool - Deploy trained models to production API
-   Parameters: model_id (string from training result)
-
-4. Auto_Deployer_auto_deploy_tool - Complete ML pipeline (analyze → train → deploy)
-   Parameters: file_path (URL to CSV file), target_column (string), task_type (classification/regression/time_series)
-
-File context: {file_context}
-
-Analyze the user's message and determine:
-1. What the user wants to accomplish
-2. Which tools are needed
-3. What parameters are required
-4. The order of tool execution
-
-Respond with JSON format:
-{{
-    "intent": "brief description of user's goal",
-    "tools": [
-        {{
-            "tool_name": "tool name",
-            "parameters": {{
-                "param1": "value1",
-                "param2": "value2"
-            }},
-            "reasoning": "why this tool is needed"
-        }}
-    ],
-    "missing_info": ["list of missing required information if any"]
-}}
-
-If no tools are needed, set tools to empty array and provide helpful response directly."""
-
-        user_prompt = f"""User message: "{message}"
-
-File context: {json.dumps(self.file_context, indent=2)}"""
-
-        try:
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_prompt}
-                ],
-                temperature=0.1,
-                max_tokens=1000
-            )
-
-            content = response.choices[0].message.content
-
-            # Extract JSON from response
-            json_match = re.search(r'```json\n(.*?)\n```', content, re.DOTALL)
-            if json_match:
-                tool_plan = json.loads(json_match.group(1))
-            else:
-                # Try to parse JSON directly
-                tool_plan = json.loads(content)
-
-            logger.info(f"Tool plan generated: {tool_plan}")
-            return tool_plan
-
-        except Exception as e:
-            logger.error(f"Error analyzing intent: {str(e)}")
-            return {"intent": "error", "tools": [], "missing_info": []}
-
-    async def _execute_tools_and_respond(
-        self,
-        tool_plan: Dict[str, Any],
-        original_message: str,
-        execution_steps: List[str],
-        stream: bool
-    ) -> str:
-        """Execute tools according to plan and generate response"""
-
-        if tool_plan.get('missing_info'):
-            # Ask for missing information
-            missing_info = "\n".join([f"• {info}" for info in tool_plan['missing_info']])
-            return f"I need some additional information to help you:\n\n{missing_info}\n\nPlease provide the missing details and I'll proceed with your request."
-
-        response_parts = []
-        results = {}
-
-        # Execute each tool in sequence
-        for i, tool_info in enumerate(tool_plan['tools']):
-            tool_name = tool_info['tool_name']
-            parameters = tool_info['parameters']
-            reasoning = tool_info.get('reasoning', '')
-
-            # Add reasoning to response
-            if reasoning:
-                response_parts.append(f"🤔 **Reasoning**: {reasoning}\n")
-
-            # Add execution step
-            step_info = f"Step {i+1}: Executing {tool_name}"
-            execution_steps.append(step_info)
-
-            response_parts.append(f"🔄 **{step_info}**\n")
-
-            try:
-                # Add file URL if available and not already in parameters
-                if (self.file_context.get('has_file') and
-                    'file_path' not in parameters and
-                    'file_path' in str(parameters)):
-                    parameters['file_path'] = self.file_context['file_url']
-
-                # Execute the tool
-                result = await self.mcp_client.call_tool(tool_name, parameters)
-                results[tool_name] = result
-
-                response_parts.append("✅ **Tool execution completed successfully**\n")
-
-                # Store model_id from training result for potential deployment
-                if tool_name == "Auto_Deployer_train_model_tool" and isinstance(result, dict):
-                    if 'model_id' in result:
-                        self.file_context['model_id'] = result['model_id']
-                    elif 'data' in result and isinstance(result['data'], dict) and 'model_id' in result['data']:
-                        self.file_context['model_id'] = result['data']['model_id']
-
-            except Exception as e:
-                error_msg = f"❌ Error executing {tool_name}: {str(e)}"
-                response_parts.append(error_msg)
-                logger.error(f"Tool execution error: {str(e)}")
-
-        # Generate final response with results
-        if results:
-            response_parts.append("\n📊 **Results:**\n")
-            for tool_name, result in results.items():
-                response_parts.append(f"\n**{tool_name} Output:**\n")
-                response_parts.append(f"```json\n{json.dumps(result, indent=2, default=str)}\n```\n")
-
-        # Add follow-up suggestions
-        if len(results) > 0:
-            last_tool = tool_plan['tools'][-1]['tool_name']
-            if last_tool == "Auto_Deployer_analyze_data_tool":
-                response_parts.append("\n💡 **Next Steps:**\n")
-                response_parts.append("• I can help you train a machine learning model on this data\n")
-                response_parts.append("• Just specify which column you'd like to predict and the type of task\n")
-            elif last_tool == "Auto_Deployer_train_model_tool":
-                response_parts.append("\n💡 **Next Steps:**\n")
-                response_parts.append("• I can deploy this model to a production API endpoint\n")
-                response_parts.append("• Just ask me to deploy the trained model\n")
-
-        return "".join(response_parts)
-
-    async def _generate_direct_response(self, message: str) -> str:
-        """Generate direct response without using tools"""
-
-        system_prompt = """You are a helpful AI assistant for machine learning and data science tasks.
-You have access to ML tools but the current conversation doesn't require tool usage.
-
-Respond helpfully about:
-- ML concepts and best practices
-- Data analysis suggestions
-- Model selection guidance
-- General ML workflow advice
-
-Be concise but informative."""
-
-        try:
-            response = await self.client.chat.completions.create(
-                model=self.model,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": message}
-                ],
-                temperature=0.7,
-                max_tokens=500
-            )
-
-            assistant_response = response.choices[0].message.content
-
-            # Add assistant response to conversation history
-            self.conversation_history.append({
-                "role": "assistant",
-                "content": assistant_response
-            })
-
-            return assistant_response
-
-        except Exception as e:
-            logger.error(f"Error generating direct response: {str(e)}")
-            return "I apologize, but I'm having trouble generating a response. Please try again."
-
-    def get_tool_descriptions(self) -> str:
-        """Get formatted descriptions of available tools"""
-        if not self.mcp_client:
-            return "Tools not available"
-
-        descriptions = ["**Available ML Tools:**\n"]
-
-        for tool_name, description in self.mcp_client.get_available_tools().items():
-            descriptions.append(f"• **{tool_name}**: {description}\n")
-
-        return "".join(descriptions)
-
-    def clear_conversation_history(self):
-        """Clear conversation history"""
-        self.conversation_history = []
-        self.file_context = {}
-        logger.info("Conversation history cleared")
-
-    async def __del__(self):
-        """Cleanup when orchestrator is destroyed"""
-        if self.mcp_client:
-            await self.mcp_client.disconnect()

app.py

@@ -1,324 +1,252 @@
 """
-Gradio Interface for Chatbase MCP Client
-Provides web-based chat interface with file upload and tool execution
+Gradio MCP Client for Remote MCP Server - With File Upload
 """
+
 import os
-import asyncio
-import logging
-from typing import Dict, Any, List, Tuple, Optional, Generator
+import json
 import gradio as gr
-from ai_orchestrator import AIOrchestrator
-from file_handler import FileHandler
-import tempfile
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class ChatbaseGradioApp:
-    """Main application class for the Chatbase Gradio interface"""
-
-    def __init__(self):
-        self.orchestrator: Optional[AIOrchestrator] = None
-        self.file_handler = FileHandler()
-        self.current_file_path: Optional[str] = None
-        self.current_file_analysis: Optional[Dict[str, Any]] = None
-        self.public_file_url: Optional[str] = None
-
-    async def initialize_app(self):
-        """Initialize the application components"""
-
-        # Get OpenAI API key from environment
-        api_key = os.getenv("OPENAI_API_KEY")
-        if not api_key:
-            raise ValueError("OPENAI_API_KEY environment variable is required")
-
-        # Initialize AI Orchestrator
-        self.orchestrator = AIOrchestrator(openai_api_key=api_key)
-        await self.orchestrator.initialize()
-
-        logger.info("Application initialized successfully")
-
-    def handle_file_upload(self, file_obj) -> Tuple[str, str]:
-        """Handle file upload and generate file analysis"""
-
-        if file_obj is None:
-            return "No file uploaded", ""
-
-        try:
-            # Run async file handling
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-            file_path, analysis = loop.run_until_complete(
-                self.file_handler.save_upload_file(file_obj, os.path.basename(file_obj.name))
-            )
-
-            self.current_file_path = file_path
-
-            # Generate public URL (for demo purposes, use file path)
-            # In production, this would upload to a public service
-            self.public_file_url = f"file://{file_path}"
-
-            # Format file analysis for display
-            file_summary = self.file_handler.format_file_summary(analysis)
-
-            loop.close()
-
-            return f"✅ File uploaded successfully: {os.path.basename(file_path)}", file_summary
-
-        except Exception as e:
-            logger.error(f"Error handling file upload: {str(e)}")
-            return f"❌ Error uploading file: {str(e)}", ""
-
-    def handle_message(
-        self,
-        message: str,
-        history: List[Tuple[str, str]]
-    ) -> Generator[str, None, None]:
-        """Handle user message with streaming response"""
-
-        if not message.strip():
-            yield ""
-            return
-
-        if not self.orchestrator:
-            yield "❌ AI Orchestrator not initialized. Please check configuration."
-            return
-
-        try:
-            # Create new event loop for async processing
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-            # Start with initial message
-            yield "🤔 Analyzing your request..."
-
-            # Process the message with the orchestrator
-            response, execution_steps = loop.run_until_complete(
-                self.orchestrator.process_message(
-                    message=message,
-                    file_url=self.public_file_url,
-                    stream=True
-                )
-            )
-
-            # Show execution steps if any
-            if execution_steps:
-                steps_text = "\n🔄 **Execution Steps:**\n" + "\n".join([f"• {step}" for step in execution_steps]) + "\n\n"
-                yield steps_text
-
-            # Show final response
-            yield response
-
-            loop.close()
-
-        except Exception as e:
-            logger.error(f"Error processing message: {str(e)}")
-            yield f"❌ An error occurred: {str(e)}\n\nPlease try again or rephrase your request."
-
-    def clear_conversation(self):
-        """Clear conversation history and reset state"""
-
-        try:
-            if self.orchestrator:
-                self.orchestrator.clear_conversation_history()
-
-            # Clear file state
-            self.current_file_path = None
-            self.current_file_analysis = None
-            self.public_file_url = None
-
-            # Clean up files
-            self.file_handler.cleanup_all_files()
-
-            return [], "Conversation cleared. Ready for new chat!", ""
-
-        except Exception as e:
-            logger.error(f"Error clearing conversation: {str(e)}")
-            return [], f"Error clearing conversation: {str(e)}", ""
-
-    def get_system_info(self) -> str:
-        """Get system information and available tools"""
-
-        if not self.orchestrator:
-            return "System not initialized"
-
-        try:
-            tools_info = self.orchestrator.get_tool_descriptions()
-
-            system_info = """
-🤖 **Chatbase ML Assistant**
-
-I can help you with machine learning tasks including:
-
-📊 **Data Analysis:** Analyze CSV datasets and get statistical insights
-🤖 **Model Training:** Train ML models for classification, regression, or time series
-🚀 **Model Deployment:** Deploy trained models to production APIs
-⚡ **Complete Pipeline:** End-to-end ML workflow from data to deployed model
-
-**How to use:**
-1. Upload a CSV file (optional, but recommended for best results)
-2. Ask questions in natural language
-3. I'll automatically select and execute the appropriate tools
-
-**Example requests:**
-• "Analyze this dataset and tell me about it"
-• "Train a model to predict the 'price' column"
-• "Deploy a classification model for the 'category' column"
-• "Run the complete ML pipeline on my data"
-
-"""
-            system_info += tools_info
-
-            return system_info
-
-        except Exception as e:
-            logger.error(f"Error getting system info: {str(e)}")
-            return "Error retrieving system information"
-
-    def create_interface(self) -> gr.Interface:
-        """Create the Gradio interface"""
-
-        # Custom CSS for better appearance
-        css = """
-        .gradio-container {
-            max-width: 1200px !important;
-            margin: auto !important;
-        }
-        .message.user {
-            background-color: #e3f2fd !important;
-        }
-        .message.assistant {
-            background-color: #f5f5f5 !important;
-        }
-        """
-
-        with gr.Blocks(
-            title="Chatbase ML Assistant",
-            theme=gr.themes.Soft(),
-            css=css
-        ) as interface:
-
-            gr.Markdown("# 🤖 Chatbase ML Assistant")
-            gr.Markdown("Upload your CSV dataset and chat with AI to perform ML tasks automatically!")
-
-            with gr.Row():
-                with gr.Column(scale=2):
-                    # File upload section
-                    file_upload = gr.File(
-                        label="📁 Upload CSV File",
-                        file_types=[".csv"],
-                        type="binary"
-                    )
-
-                    file_status = gr.Textbox(
-                        label="File Status",
-                        interactive=False,
-                        placeholder="No file uploaded"
-                    )
-
-                    file_analysis = gr.Markdown(
-                        label="📊 File Analysis",
-                        value="Upload a CSV file to see analysis..."
-                    )
-
-                with gr.Column(scale=3):
-                    # Chat interface
-                    chatbot = gr.Chatbot(
-                        label="💬 Chat",
-                        height=500,
-                        bubble_full_width=False
-                    )
-
-                    msg = gr.Textbox(
-                        label="Type your message...",
-                        placeholder="Ask me to analyze data, train models, or deploy ML pipelines...",
-                        lines=2
+from contextlib import asynccontextmanager
+
+from openai import OpenAI
+from fastmcp import Client
+from fastmcp.client.transports import StreamableHttpTransport
+
+# Configuration
+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"
+
+
+class MCPClientManager:
+    def __init__(self, server_url: str):
+        self.server_url = server_url
+
+    @asynccontextmanager
+    async def get_client(self):
+        transport = StreamableHttpTransport(self.server_url)
+        async with Client(transport) as client:
+            yield client
+
+    async def get_tools(self) -> list:
+        async with self.get_client() as client:
+            return await client.list_tools()
+
+    async def call_tool(self, tool_name: str, arguments: dict) -> str:
+        async with self.get_client() as client:
+            result = await client.call_tool(tool_name, arguments)
+            if hasattr(result, "content"):
+                if isinstance(result.content, list):
+                    return "\n".join(
+                        str(item.text) if hasattr(item, "text") else str(item)
+                        for item in result.content
                     )
-
-                    with gr.Row():
-                        submit_btn = gr.Button("💬 Send", variant="primary")
-                        clear_btn = gr.Button("🗑️ Clear Chat")
-
-                    # System info display
-                    with gr.Accordion("ℹ️ Available Tools & Help", open=False):
-                        gr.Markdown(self.get_system_info())
-
-            # Event handlers
-            file_upload.upload(
-                fn=self.handle_file_upload,
-                inputs=[file_upload],
-                outputs=[file_status, file_analysis]
+                return str(result.content)
+            return str(result)
+
+    def to_openai_tools(self, tools: list) -> list:
+        return [
+            {
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description or "",
+                    "parameters": {
+                        "type": "object",
+                        "properties": tool.inputSchema.get("properties", {})
+                        if tool.inputSchema
+                        else {},
+                        "required": tool.inputSchema.get("required", [])
+                        if tool.inputSchema
+                        else [],
+                    },
+                },
+            }
+            for tool in tools
+        ]
+
+
+mcp = MCPClientManager(MCP_SERVER_URL)
+openai_client = OpenAI(api_key=OPENAI_API_KEY)
+
+SYSTEM_PROMPT = """You are a helpful ML assistant with access to Auto Deployer tools.
+
+IMPORTANT: When calling tools with file_path parameter:
+- If the user uploaded a file, use the provided file URL directly
+- Pass ONLY the raw URL (e.g., "https://...")
+- Never add prefixes like "Gradio File Input - "
+
+Always pass URLs directly without any prefix."""
+
+
+async def chat(message: str, history: list, file_url: str):
+    """Process chat with optional file URL"""
+    tools = await mcp.get_tools()
+    openai_tools = mcp.to_openai_tools(tools)
+
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+
+    # Add file context if available
+    user_content = message
+    if file_url:
+        user_content = f"[Uploaded CSV file URL: {file_url}]\n\n{message}"
+
+    # Build history - handle both old tuple format and new dict format
+    for item in history:
+        if isinstance(item, dict):
+            messages.append({"role": item["role"], "content": item["content"]})
+        elif isinstance(item, (list, tuple)) and len(item) == 2:
+            user_msg, assistant_msg = item
+            messages.append({"role": "user", "content": user_msg})
+            if assistant_msg:
+                messages.append({"role": "assistant", "content": assistant_msg})
+
+    messages.append({"role": "user", "content": user_content})
+
+    # First call
+    response = openai_client.chat.completions.create(
+        model=MODEL,
+        messages=messages,
+        tools=openai_tools,
+        tool_choice="auto",
+    )
+
+    assistant_message = response.choices[0].message
+
+    # Handle tool calls
+    while assistant_message.tool_calls:
+        messages.append(assistant_message)
+
+        yield "🔧 Calling tools...\n\n"
+
+        for tool_call in assistant_message.tool_calls:
+            tool_name = tool_call.function.name
+            arguments = json.loads(tool_call.function.arguments)
+
+            # Clean file_path
+            if "file_path" in arguments:
+                fp = arguments["file_path"]
+                if fp.startswith("Gradio File Input - "):
+                    arguments["file_path"] = fp.replace("Gradio File Input - ", "")
+
+            yield f"⚙️ Running `{tool_name}`...\n\n"
+
+            try:
+                tool_result = await mcp.call_tool(tool_name, arguments)
+            except Exception as e:
+                tool_result = f"Error: {e}"
+
+            messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": tool_call.id,
+                    "content": tool_result,
+                }
             )
 
-            msg.submit(
-                fn=self.handle_message,
-                inputs=[msg, chatbot],
-                outputs=[chatbot]
+        response = openai_client.chat.completions.create(
+            model=MODEL,
+            messages=messages,
+            tools=openai_tools,
+            tool_choice="auto",
+        )
+        assistant_message = response.choices[0].message
+
+    # Stream final response
+    stream = openai_client.chat.completions.create(
+        model=MODEL,
+        messages=messages,
+        stream=True,
+    )
+
+    partial_response = ""
+    for chunk in stream:
+        if chunk.choices[0].delta.content:
+            partial_response += chunk.choices[0].delta.content
+            yield partial_response
+
+
+def handle_file_upload(file):
+    """Return the file path when uploaded"""
+    if file is None:
+        return ""
+    return file
+
+
+with gr.Blocks(title="Auto Deployer MCP Client") as demo:
+    gr.Markdown(
+        """
+        # 🤖 Auto Deployer MCP Client
+        Upload a CSV file and chat about ML tasks: analyze, train, deploy models.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_input = gr.File(
+                label="📁 Upload CSV File",
+                file_types=[".csv"],
+                type="filepath",
             )
-
-            submit_btn.click(
-                fn=self.handle_message,
-                inputs=[msg, chatbot],
-                outputs=[chatbot]
+            file_url = gr.Textbox(
+                label="File URL",
+                placeholder="Upload a file or paste a URL",
+                interactive=True,
             )
-
-            clear_btn.click(
-                fn=self.clear_conversation,
-                outputs=[chatbot, file_status, file_analysis]
+            gr.Markdown(
+                """
+                ### 💡 Tips
+                - Upload a CSV file above
+                - Or paste a direct URL to a CSV
+                - Then ask questions in the chat
+                """
             )
 
-            # Add examples
-            gr.Examples(
-                examples=[
-                    ["Analyze this dataset and tell me about the main insights"],
-                    ["Train a classification model to predict the target column"],
-                    ["What are the key statistics and patterns in this data?"],
-                    ["Train and deploy a machine learning model for this dataset"],
-                    ["What type of ML task would be best suited for this data?"]
-                ],
-                inputs=[msg],
-                label="💡 Example Messages"
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(label="Chat", height=400)
+            msg = gr.Textbox(
+                label="Message",
+                placeholder="e.g., Analyze this dataset and train a model",
             )
-
-        return interface
-
-    async def run(self):
-        """Run the application"""
-
-        try:
-            # Initialize components
-            await self.initialize_app()
-
-            # Create and launch interface
-            interface = self.create_interface()
-
-            logger.info("Starting Gradio interface...")
-            interface.launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                share=True,
-                show_error=True
-            )
-
-        except Exception as e:
-            logger.error(f"Error running application: {str(e)}")
-            raise
-
-def main():
-    """Main entry point"""
-
-    app = ChatbaseGradioApp()
-
-    # Run the app
-    try:
-        asyncio.run(app.run())
-    except KeyboardInterrupt:
-        logger.info("Application stopped by user")
-    except Exception as e:
-        logger.error(f"Fatal error: {str(e)}")
-        raise
+            with gr.Row():
+                submit = gr.Button("Send", variant="primary")
+                clear = gr.Button("Clear")
+
+    gr.Examples(
+        examples=[
+            "What tools do you have available?",
+            "Analyze this CSV file",
+            "Train a classification model with 'species' as the target column",
+            "Auto deploy a model predicting 'Survived'",
+        ],
+        inputs=msg,
+    )
+
+    # Update file URL when file is uploaded
+    file_input.change(fn=handle_file_upload, inputs=file_input, outputs=file_url)
+
+    # Chat handlers
+    async def respond(message, history, url):
+        history = history or []
+        history.append([message, ""])
+        response = ""
+        async for chunk in chat(message, history[:-1], url):
+            response = chunk
+            history[-1][1] = response
+            yield history
+
+    submit.click(
+        fn=respond,
+        inputs=[msg, chatbot, file_url],
+        outputs=chatbot,
+    ).then(lambda: "", outputs=msg)
+
+    msg.submit(
+        fn=respond,
+        inputs=[msg, chatbot, file_url],
+        outputs=chatbot,
+    ).then(lambda: "", outputs=msg)
+
+    clear.click(lambda: ([], "", None), outputs=[chatbot, file_url, file_input])
 
 if __name__ == "__main__":
-    main()
+    demo.launch(allowed_paths=["/tmp"])

config.py

@@ -1,87 +0,0 @@
-"""
-Configuration settings for Chatbase Gradio MCP Client
-"""
-import os
-from typing import Optional
-
-class Config:
-    """Configuration class for the application"""
-
-    # MCP Server Settings
-    MCP_SERVER_URL = os.getenv(
-        "MCP_SERVER_URL",
-        "https://mcp-1st-birthday-auto-deployer.hf.space/gradio_api/mcp/"
-    )
-
-    # OpenAI Settings
-    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-    OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-5-mini")
-
-    # Gradio Settings
-    GRADIO_SERVER_NAME = os.getenv("GRADIO_SERVER_NAME", "0.0.0.0")
-    GRADIO_SERVER_PORT = int(os.getenv("GRADIO_SERVER_PORT", "7860"))
-    GRADIO_SHARE = os.getenv("GRADIO_SHARE", "true").lower() == "true"
-
-    # File Settings
-    UPLOAD_DIR = os.getenv("UPLOAD_DIR", "uploads")
-    MAX_FILE_SIZE = int(os.getenv("MAX_FILE_SIZE", "100")) * 1024 * 1024  # 100MB
-    ALLOWED_EXTENSIONS = [".csv"]
-
-    # Logging Settings
-    LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
-    LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-
-    # AI Orchestrator Settings
-    MAX_CONVERSATION_HISTORY = int(os.getenv("MAX_CONVERSATION_HISTORY", "20"))
-    DEFAULT_TEMPERATURE = float(os.getenv("DEFAULT_TEMPERATURE", "0.1"))
-    MAX_TOKENS = int(os.getenv("MAX_TOKENS", "1000"))
-
-    @classmethod
-    def validate(cls) -> bool:
-        """Validate that required configuration is present"""
-
-        if not cls.OPENAI_API_KEY:
-            print("❌ OPENAI_API_KEY environment variable is required")
-            return False
-
-        if not cls.MCP_SERVER_URL:
-            print("❌ MCP_SERVER_URL is required")
-            return False
-
-        print("✅ Configuration is valid")
-        return True
-
-    @classmethod
-    def get_info(cls) -> str:
-        """Get configuration information for display"""
-
-        info = """
-**Configuration Status:**
-• MCP Server: {mcp_server}
-• OpenAI Model: {openai_model}
-• Gradio Server: {server_name}:{server_port}
-• Upload Directory: {upload_dir}
-• Max File Size: {max_file_size}MB
-• Log Level: {log_level}
-
-**Required Environment Variables:**
-• OPENAI_API_KEY: {"✅ Set" if cls.OPENAI_API_KEY else "❌ Missing"}
-• MCP_SERVER_URL: {"✅ Set" if cls.MCP_SERVER_URL else "❌ Missing"}
-
-**Optional Environment Variables:**
-• GRADIO_SERVER_NAME: {server_name}
-• GRADIO_SERVER_PORT: {server_port}
-• GRADIO_SHARE: {share}
-• LOG_LEVEL: {log_level}
-""".format(
-            mcp_server=cls.MCP_SERVER_URL,
-            openai_model=cls.OPENAI_MODEL,
-            server_name=cls.GRADIO_SERVER_NAME,
-            server_port=cls.GRADIO_SERVER_PORT,
-            upload_dir=cls.UPLOAD_DIR,
-            max_file_size=cls.MAX_FILE_SIZE // (1024 * 1024),
-            log_level=cls.LOG_LEVEL,
-            share=cls.GRADIO_SHARE
-        )
-
-        return info

file_handler.py

@@ -1,296 +0,0 @@
-"""
-File Handler for CSV processing and public URL generation
-Supports file upload, validation, and preparation for MCP tools
-"""
-import os
-import tempfile
-import uuid
-import logging
-from typing import Optional, Dict, Any, Tuple
-import pandas as pd
-from pathlib import Path
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class FileHandler:
-    """Handles file operations for the ML pipeline"""
-
-    def __init__(self, upload_dir: str = "uploads"):
-        self.upload_dir = Path(upload_dir)
-        self.upload_dir.mkdir(exist_ok=True)
-        self.temp_files = {}
-        self.file_analyses = {}
-
-    async def save_upload_file(
-        self,
-        file_obj,
-        filename: Optional[str] = None
-    ) -> Tuple[str, Dict[str, Any]]:
-        """
-        Save uploaded file and return file path and analysis
-
-        Args:
-            file_obj: File-like object (from Gradio upload)
-            filename: Original filename
-
-        Returns:
-            Tuple of (file_path, file_analysis)
-        """
-        try:
-            # Generate unique filename
-            if not filename:
-                filename = str(uuid.uuid4())
-
-            # Ensure .csv extension for CSV files
-            if not filename.lower().endswith('.csv'):
-                filename = f"{filename}.csv"
-
-            file_path = self.upload_dir / filename
-
-            # Save the file
-            with open(file_path, 'wb') as f:
-                content = file_obj.read()
-                f.write(content)
-
-            logger.info(f"File saved: {file_path}")
-
-            # Analyze the file
-            analysis = await self._analyze_file(file_path)
-
-            # Store file info for cleanup
-            self.temp_files[str(file_path)] = file_path
-
-            return str(file_path), analysis
-
-        except Exception as e:
-            logger.error(f"Error saving upload file: {str(e)}")
-            raise
-
-    async def _analyze_file(self, file_path: Path) -> Dict[str, Any]:
-        """Analyze uploaded file and return metadata"""
-
-        try:
-            # Read CSV file
-            df = pd.read_csv(file_path)
-
-            analysis = {
-                'filename': file_path.name,
-                'file_size': file_path.stat().st_size,
-                'rows': len(df),
-                'columns': len(df.columns),
-                'column_names': list(df.columns),
-                'column_types': {col: str(dtype) for col, dtype in df.dtypes.items()},
-                'missing_values': df.isnull().sum().to_dict(),
-                'sample_data': df.head().to_dict('records'),
-                'numeric_columns': list(df.select_dtypes(include=['number']).columns),
-                'categorical_columns': list(df.select_dtypes(include=['object']).columns),
-                'datetime_columns': list(df.select_dtypes(include=['datetime']).columns),
-                'file_path': str(file_path)
-            }
-
-            # Additional analysis for better ML insights
-            analysis['target_column_suggestions'] = self._suggest_target_columns(df)
-            analysis['task_type_suggestions'] = self._suggest_task_types(df)
-            analysis['data_quality_issues'] = self._check_data_quality(df)
-
-            # Store analysis for later use
-            self.file_analyses[str(file_path)] = analysis
-
-            logger.info(f"File analysis completed: {analysis['rows']} rows, {analysis['columns']} columns")
-            return analysis
-
-        except Exception as e:
-            logger.error(f"Error analyzing file: {str(e)}")
-            raise ValueError(f"Failed to analyze file: {str(e)}")
-
-    def _suggest_target_columns(self, df: pd.DataFrame) -> Dict[str, str]:
-        """Suggest potential target columns for ML tasks"""
-
-        suggestions = {}
-
-        # Numeric columns for regression
-        numeric_cols = df.select_dtypes(include=['number']).columns
-        for col in numeric_cols:
-            if df[col].nunique() > 10:  # Likely continuous
-                suggestions[col] = "regression (continuous target)"
-            elif df[col].nunique() <= 10:  # Likely classification
-                suggestions[col] = "classification (discrete target)"
-
-        # Categorical columns for classification
-        categorical_cols = df.select_dtypes(include=['object']).columns
-        for col in categorical_cols:
-            unique_count = df[col].nunique()
-            if 2 <= unique_count <= 20:  # Good for classification
-                suggestions[col] = f"classification ({unique_count} classes)"
-
-        return suggestions
-
-    def _suggest_task_types(self, df: pd.DataFrame) -> Dict[str, Any]:
-        """Suggest ML task types based on data characteristics"""
-
-        suggestions = {}
-
-        # Check for datetime columns (potential time series)
-        datetime_cols = df.select_dtypes(include=['datetime']).columns
-        if len(datetime_cols) > 0:
-            suggestions['time_series_possible'] = True
-            suggestions['time_series_columns'] = list(datetime_cols)
-
-        # Data size considerations
-        if len(df) < 1000:
-            suggestions['size_category'] = 'small'
-            suggestions['recommendation'] = 'Good for quick experimentation and prototyping'
-        elif len(df) < 10000:
-            suggestions['size_category'] = 'medium'
-            suggestions['recommendation'] = 'Suitable for most ML tasks'
-        else:
-            suggestions['size_category'] = 'large'
-            suggestions['recommendation'] = 'Consider sampling for initial experiments'
-
-        # Check for imbalance in categorical columns
-        categorical_cols = df.select_dtypes(include=['object']).columns
-        for col in categorical_cols:
-            value_counts = df[col].value_counts()
-            if len(value_counts) > 1:
-                ratio = value_counts.iloc[0] / value_counts.iloc[1]
-                if ratio > 3:  # Significant imbalance
-                    suggestions[f'{col}_imbalance'] = True
-                    suggestions[f'{col}_imbalance_ratio'] = ratio
-
-        return suggestions
-
-    def _check_data_quality(self, df: pd.DataFrame) -> Dict[str, Any]:
-        """Check for common data quality issues"""
-
-        issues = {}
-
-        # Missing values
-        missing_percentage = (df.isnull().sum() / len(df) * 100).to_dict()
-        high_missing = [col for col, pct in missing_percentage.items() if pct > 50]
-        if high_missing:
-            issues['high_missing_columns'] = high_missing
-
-        # Duplicate rows
-        duplicate_count = df.duplicated().sum()
-        if duplicate_count > 0:
-            issues['duplicate_rows'] = int(duplicate_count)
-            issues['duplicate_percentage'] = round(duplicate_count / len(df) * 100, 2)
-
-        # Constant columns
-        constant_cols = [col for col in df.columns if df[col].nunique() == 1]
-        if constant_cols:
-            issues['constant_columns'] = constant_cols
-
-        # Potential ID columns
-        id_candidates = []
-        for col in df.columns:
-            if (df[col].dtype == 'object' and
-                df[col].nunique() == len(df) and
-                not df[col].str.contains(' ', regex=False).any()):
-                id_candidates.append(col)
-        if id_candidates:
-            issues['potential_id_columns'] = id_candidates
-
-        return issues
-
-    def format_file_summary(self, analysis: Dict[str, Any]) -> str:
-        """Format file analysis into human-readable summary"""
-
-        summary_parts = [
-            f"📄 **File Analysis: {analysis['filename']}**\n",
-            f"📊 **Dataset Info:**\n",
-            f"• Rows: {analysis['rows']:,}\n",
-            f"• Columns: {analysis['columns']}\n",
-            f"• File Size: {analysis['file_size']:,} bytes\n\n",
-            f"📋 **Columns:**\n"
-        ]
-
-        # Add column information
-        for col in analysis['column_names'][:10]:  # Limit to first 10 columns
-            col_type = analysis['column_types'][col]
-            missing = analysis['missing_values'].get(col, 0)
-            missing_pct = round(missing / analysis['rows'] * 100, 1)
-            summary_parts.append(f"• {col} ({col_type}) - {missing_pct}% missing\n")
-
-        if len(analysis['column_names']) > 10:
-            summary_parts.append(f"• ... and {len(analysis['column_names']) - 10} more columns\n")
-
-        # Add ML suggestions
-        if analysis['target_column_suggestions']:
-            summary_parts.append(f"\n🎯 **Suggested Target Columns:**\n")
-            for col, suggestion in list(analysis['target_column_suggestions'].items())[:5]:
-                summary_parts.append(f"• {col}: {suggestion}\n")
-
-        # Add task type suggestions
-        if analysis['task_type_suggestions']:
-            suggestions = analysis['task_type_suggestions']
-            summary_parts.append(f"\n💡 **ML Task Insights:**\n")
-
-            if 'size_category' in suggestions:
-                summary_parts.append(f"• Dataset size: {suggestions['size_category']}\n")
-                summary_parts.append(f"• {suggestions['recommendation']}\n")
-
-            if suggestions.get('time_series_possible'):
-                summary_parts.append(f"• Time series analysis possible with: {suggestions['time_series_columns']}\n")
-
-        # Add data quality warnings
-        if analysis['data_quality_issues']:
-            issues = analysis['data_quality_issues']
-            summary_parts.append(f"\n⚠️ **Data Quality Notes:**\n")
-
-            if 'duplicate_rows' in issues:
-                summary_parts.append(f"• {issues['duplicate_rows']:,} duplicate rows ({issues['duplicate_percentage']}%)\n")
-
-            if 'constant_columns' in issues:
-                summary_parts.append(f"• Constant columns: {issues['constant_columns']}\n")
-
-            if 'high_missing_columns' in issues:
-                summary_parts.append(f"• High missing values in: {issues['high_missing_columns']}\n")
-
-        return "".join(summary_parts)
-
-    def cleanup_file(self, file_path: str):
-        """Remove uploaded file and associated data"""
-
-        try:
-            # Remove file
-            path = Path(file_path)
-            if path.exists():
-                path.unlink()
-                logger.info(f"Removed file: {file_path}")
-
-            # Remove from tracking
-            self.temp_files.pop(file_path, None)
-            self.file_analyses.pop(file_path, None)
-
-        except Exception as e:
-            logger.error(f"Error cleaning up file {file_path}: {str(e)}")
-
-    def cleanup_all_files(self):
-        """Remove all temporary files"""
-
-        for file_path in list(self.temp_files.keys()):
-            self.cleanup_file(file_path)
-
-        logger.info("All temporary files cleaned up")
-
-    def get_file_analysis(self, file_path: str) -> Optional[Dict[str, Any]]:
-        """Get previously computed file analysis"""
-
-        return self.file_analyses.get(file_path)
-
-    def is_valid_csv(self, file_path: str) -> bool:
-        """Check if file is a valid CSV"""
-
-        try:
-            df = pd.read_csv(file_path)
-            return len(df) > 0 and len(df.columns) > 0
-        except Exception:
-            return False
-
-    async def __del__(self):
-        """Cleanup when handler is destroyed"""
-
-        self.cleanup_all_files()

mcp_client.py

@@ -1,200 +0,0 @@
-"""
-MCP Client for connecting to remote MCP server
-Handles tool discovery, execution, and streaming responses
-"""
-import asyncio
-import json
-import logging
-from typing import Dict, Any, Optional, AsyncGenerator
-import aiohttp
-from fastmcp import Client
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class MCPClient:
-    """Client for interacting with remote MCP server"""
-
-    def __init__(self, server_url: str = "https://mcp-1st-birthday-auto-deployer.hf.space/gradio_api/mcp/"):
-        self.server_url = server_url
-        self.client: Optional[Client] = None
-        self.available_tools = {}
-
-    async def connect(self):
-        """Establish connection to MCP server"""
-        try:
-            logger.info(f"Connecting to MCP server at {self.server_url}")
-            self.client = Client(self.server_url)
-            await self.client.__aenter__()
-
-            # Discover available tools
-            await self.discover_tools()
-            logger.info(f"Connected successfully. Found {len(self.available_tools)} tools.")
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to connect to MCP server: {str(e)}")
-            return False
-
-    async def discover_tools(self):
-        """Discover available tools on the MCP server"""
-        if not self.client:
-            raise RuntimeError("Client not connected")
-
-        try:
-            # Get list of available tools
-            tools_result = await self.client.list_tools()
-
-            for tool in tools_result.tools:
-                self.available_tools[tool.name] = {
-                    'name': tool.name,
-                    'description': tool.description,
-                    'input_schema': tool.inputSchema
-                }
-
-            logger.info(f"Discovered tools: {list(self.available_tools.keys())}")
-
-        except Exception as e:
-            logger.error(f"Failed to discover tools: {str(e)}")
-            raise
-
-    async def call_tool(
-        self,
-        tool_name: str,
-        arguments: Dict[str, Any],
-        stream: bool = False
-    ) -> Dict[str, Any]:
-        """Call a specific tool with given arguments"""
-        if not self.client:
-            raise RuntimeError("Client not connected")
-
-        if tool_name not in self.available_tools:
-            raise ValueError(f"Tool '{tool_name}' not available. Available tools: {list(self.available_tools.keys())}")
-
-        try:
-            logger.info(f"Calling tool '{tool_name}' with arguments: {arguments}")
-
-            # Validate arguments against tool schema if available
-            tool_info = self.available_tools[tool_name]
-            if 'input_schema' in tool_info:
-                self._validate_arguments(tool_info['input_schema'], arguments)
-
-            # Call the tool
-            result = await self.client.call_tool(tool_name, arguments)
-
-            logger.info(f"Tool '{tool_name}' completed successfully")
-            return result
-
-        except Exception as e:
-            logger.error(f"Error calling tool '{tool_name}': {str(e)}")
-            raise
-
-    async def call_tool_stream(
-        self,
-        tool_name: str,
-        arguments: Dict[str, Any]
-    ) -> AsyncGenerator[str, None]:
-        """Call a tool with streaming response"""
-        if not self.client:
-            raise RuntimeError("Client not connected")
-
-        if tool_name not in self.available_tools:
-            raise ValueError(f"Tool '{tool_name}' not available")
-
-        try:
-            logger.info(f"Calling tool '{tool_name}' with streaming")
-
-            # For streaming, we'll simulate progress updates
-            # In a real implementation, this would depend on the specific tool
-            yield f"🔄 Starting tool execution: {tool_name}\n"
-            yield f"📋 Arguments: {json.dumps(arguments, indent=2)}\n"
-
-            # Call the actual tool
-            result = await self.call_tool(tool_name, arguments)
-
-            yield "✅ Tool execution completed\n"
-            yield f"📊 Results:\n{json.dumps(result, indent=2)}\n"
-
-        except Exception as e:
-            logger.error(f"Error in streaming tool call: {str(e)}")
-            yield f"❌ Error: {str(e)}\n"
-
-    def _validate_arguments(self, schema: Dict[str, Any], arguments: Dict[str, Any]):
-        """Validate arguments against tool schema"""
-        if not schema or 'properties' not in schema:
-            return
-
-        required = schema.get('required', [])
-        properties = schema['properties']
-
-        # Check required arguments
-        for req_arg in required:
-            if req_arg not in arguments:
-                raise ValueError(f"Required argument '{req_arg}' is missing")
-
-        # Check argument types (basic validation)
-        for arg_name, arg_value in arguments.items():
-            if arg_name in properties:
-                expected_type = properties[arg_name].get('type')
-                if expected_type == 'string' and not isinstance(arg_value, str):
-                    raise ValueError(f"Argument '{arg_name}' should be a string")
-                elif expected_type == 'number' and not isinstance(arg_value, (int, float)):
-                    raise ValueError(f"Argument '{arg_name}' should be a number")
-                elif expected_type == 'boolean' and not isinstance(arg_value, bool):
-                    raise ValueError(f"Argument '{arg_name}' should be a boolean")
-
-    async def get_tool_description(self, tool_name: str) -> str:
-        """Get detailed description of a specific tool"""
-        if tool_name not in self.available_tools:
-            return f"Tool '{tool_name}' not available"
-
-        tool_info = self.available_tools[tool_name]
-
-        description = f"**{tool_name}**\n"
-        description += f"Description: {tool_info.get('description', 'No description available')}\n"
-
-        if 'input_schema' in tool_info and 'properties' in tool_info['input_schema']:
-            description += "\n**Parameters:**\n"
-            properties = tool_info['input_schema']['properties']
-            required = tool_info['input_schema'].get('required', [])
-
-            for param_name, param_info in properties.items():
-                param_type = param_info.get('type', 'unknown')
-                param_desc = param_info.get('description', 'No description')
-                is_required = param_name in required
-
-                description += f"- {param_name} ({param_type}) {'[Required]' if is_required else '[Optional]'}: {param_desc}\n"
-
-        return description
-
-    def get_available_tools(self) -> Dict[str, str]:
-        """Get list of available tools with descriptions"""
-        return {
-            name: info.get('description', 'No description available')
-            for name, info in self.available_tools.items()
-        }
-
-    async def disconnect(self):
-        """Close connection to MCP server"""
-        if self.client:
-            try:
-                await self.client.__aexit__(None, None, None)
-                logger.info("Disconnected from MCP server")
-            except Exception as e:
-                logger.error(f"Error during disconnect: {str(e)}")
-            finally:
-                self.client = None
-
-# Singleton instance for reuse
-_mcp_client = None
-
-async def get_mcp_client() -> MCPClient:
-    """Get or create MCP client instance"""
-    global _mcp_client
-
-    if _mcp_client is None:
-        _mcp_client = MCPClient()
-        await _mcp_client.connect()
-
-    return _mcp_client