mcp

MCP_INTEGRATION_README.md

@@ -0,0 +1,346 @@
+# MCP Integration with Minion Brain (Standalone Version)
+
+This is a **standalone** MCP (Model Context Protocol) integration solution for Minion Brain.step that **does not depend on huggingface_hub** package. It provides a clean, lightweight tool integration approach.
+
+## Features
+
+- **🔗 MCP Server Support**: Connect to stdio, SSE, and HTTP MCP servers
+- **🛠 Tool Adaptation**: Automatically converts MCP tools to brain.step compatible format
+- **🧠 Brain Integration**: Native support for tools in minion brain.step function
+- **🖥 Gradio UI**: Web interface to configure and test MCP tools
+- **⚙️ Environment Configuration**: Easy setup via environment variables
+- **🔒 Independence**: No dependency on huggingface_hub, completely self-contained
+
+## Architecture
+
+### Core Components
+
+1. **BrainTool**: Adapter class that wraps MCP tools for brain.step compatibility
+2. **MCPBrainClient**: Main client for managing MCP server connections
+3. **Local Tools**: Built-in local tools (calculator, final answer, etc.)
+
+### Tool Format Conversion
+
+MCP tools are automatically converted to the format expected by brain.step:
+
+```python
+# MCP Tool (from server)
+{
+    "name": "calculator",
+    "description": "Perform basic arithmetic operations",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "expression": {"type": "string"}
+        }
+    }
+}
+
+# Converted to BrainTool (for brain.step)
+BrainTool(
+    name="calculator",
+    description="Perform basic arithmetic operations", 
+    parameters={...},
+    session=mcp_session
+)
+```
+
+## Installation
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+**Note**: This version **does not require** `huggingface_hub`, fewer dependencies!
+
+### 2. Environment Configuration
+
+Create a `.env` file:
+
+```bash
+# LLM Configuration
+GPT_4O_API_TYPE=azure
+GPT_4O_API_KEY=your_api_key_here
+GPT_4O_BASE_URL=https://your-endpoint.openai.azure.com/
+GPT_4O_API_VERSION=2024-06-01
+GPT_4O_MODEL=gpt-4o
+
+# MCP Server Configuration (optional)
+MCP_SSE_URL=http://localhost:8080/sse
+MCP_STDIO_COMMAND=python example_mcp_server.py
+```
+
+### 3. Quick Test
+
+```bash
+# Test local tools and MCP integration
+python simple_mcp_test.py
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+from mcp_integration import MCPBrainClient, create_final_answer_tool, create_calculator_tool
+
+async def example_usage():
+    # Create local tools
+    local_tools = [
+        create_calculator_tool(),
+        create_final_answer_tool()
+    ]
+    
+    # Optional: Add MCP tools
+    mcp_tools = []
+    try:
+        async with MCPBrainClient() as mcp_client:
+            await mcp_client.add_mcp_server("sse", url="http://localhost:8080/sse")
+            mcp_tools = mcp_client.get_tools_for_brain()
+    except:
+        pass  # It's okay if there's no MCP server
+    
+    # Combine all tools
+    all_tools = local_tools + mcp_tools
+    
+    # Use in brain.step
+    obs, score, *_ = await brain.step(
+        query="Calculate 234*568",
+        route="raw",
+        check=False,
+        tools=all_tools
+    )
+    
+    print(f"Result: {obs}")
+```
+
+### Using Only Local Tools
+
+If you don't need to connect to external MCP servers:
+
+```python
+from mcp_integration import create_calculator_tool, create_final_answer_tool
+
+# Create local tools
+tools = [
+    create_calculator_tool(),
+    create_final_answer_tool()
+]
+
+# Use directly in brain.step
+obs, score, *_ = await brain.step(
+    query="Calculate 234*568",
+    tools=tools
+)
+```
+
+### Connecting to Different MCP Server Types
+
+#### SSE Server
+```python
+await mcp_client.add_mcp_server(
+    "sse", 
+    url="http://localhost:8080/sse",
+    headers={"Authorization": "Bearer token"},
+    timeout=30.0
+)
+```
+
+#### Stdio Server
+```python
+await mcp_client.add_mcp_server(
+    "stdio",
+    command="python",
+    args=["example_mcp_server.py"],
+    cwd="/path/to/server"
+)
+```
+
+#### HTTP Server
+```python
+await mcp_client.add_mcp_server(
+    "http",
+    url="http://localhost:8080/http",
+    timeout=timedelta(seconds=30)
+)
+```
+
+### Creating Custom Local Tools
+
+```python
+def create_custom_tool():
+    class CustomSession:
+        async def call_tool(self, name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+            # Your tool logic
+            result = f"Processed: {args}"
+            return {
+                "content": [{"type": "text", "text": result}]
+            }
+    
+    return BrainTool(
+        name="custom_tool",
+        description="A custom tool",
+        parameters={
+            "type": "object",
+            "properties": {
+                "input": {"type": "string"}
+            }
+        },
+        session=CustomSession()
+    )
+```
+
+## Built-in Tools
+
+### 1. Calculator Tool
+```python
+calculator_tool = create_calculator_tool()
+result = await calculator_tool(expression="234 * 568")
+# Output: "Calculation result: 234 * 568 = 132912"
+```
+
+### 2. Final Answer Tool
+```python
+final_tool = create_final_answer_tool()
+result = await final_tool(answer="Calculation completed, result is 132912")
+# Output: "Calculation completed, result is 132912"
+```
+
+### 3. Filesystem Tool (MCP)
+```python
+from mcp_integration import add_filesystem_tool
+
+async with MCPBrainClient() as mcp_client:
+    # Add filesystem tool, specify allowed access paths
+    await add_filesystem_tool(mcp_client, workspace_paths=[
+        "/Users/femtozheng/workspace",
+        "/Users/femtozheng/python-project/minion-agent"
+    ])
+    
+    # Get tools and use
+    tools = mcp_client.get_tools_for_brain()
+    # Filesystem tools typically include: read_file, write_file, list_directory, etc.
+```
+
+**Filesystem Tool Features**:
+- 📖 **read_file**: Read file contents
+- ✏️ **write_file**: Write to files
+- 📂 **list_directory**: List directory contents
+- 🔍 **search_files**: Search files
+- 🔒 **Security restriction**: Only access pre-configured paths
+
+## Run Complete Application
+
+```bash
+python app_with_mcp.py
+```
+
+Then open `http://localhost:7860` in your browser and enable the "MCP Tools" option.
+
+## Integration Patterns
+
+### 1. Tool Discovery
+The system automatically discovers and registers tools from connected MCP servers:
+
+```python
+tools = mcp_client.get_tools_for_brain()
+print([tool.name for tool in tools])
+```
+
+### 2. Error Handling
+Tools include built-in error handling:
+
+```python
+result = await tool(invalid_param="value")
+# Returns: "Error: <error_description>"
+```
+
+### 3. Tool Execution
+Tools execute asynchronously and return formatted results:
+
+```python
+result = await tool(expression="2+2")
+# Result is automatically formatted for brain.step use
+```
+
+## Advantages
+
+### Compared to huggingface_hub dependent version:
+
+1. **Lighter**: Reduced large dependency packages
+2. **Simpler**: Focus on core MCP integration functionality
+3. **More flexible**: Not restricted by huggingface_hub versions
+4. **Faster**: Less import and initialization time
+5. **More independent**: Can run in any environment
+
+## Troubleshooting
+
+### Common Issues
+
+1. **MCP Server Connection Failed**
+   - Check server URL and port
+   - Verify server is running
+   - Check network connectivity
+
+2. **Tool Not Found**
+   - Verify MCP server has tools
+   - Check tool name spelling
+   - Ensure server initialization completed
+
+3. **Import Errors**
+   - Install all required dependencies
+   - Check Python version compatibility
+   - Verify mcp package installation
+
+### Debug Mode
+
+Enable debug logging to troubleshoot issues:
+
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+## Advanced Configuration
+
+### Tool Filtering
+
+Filter tools by name or type:
+
+```python
+# Filter specific tools
+filtered_tools = [
+    tool for tool in tools 
+    if tool.name in ["calculator", "final_answer"]
+]
+```
+
+### Tool Prioritization
+
+Organize tools by priority:
+
+```python
+# High-priority tools first
+priority_tools = ["final_answer", "calculator"]
+other_tools = [t for t in tools if t.name not in priority_tools]
+ordered_tools = priority_tools + other_tools
+```
+
+## Example Projects
+
+Check `example_mcp_server.py` to learn how to create MCP servers, or run `simple_mcp_test.py` to see complete integration examples.
+
+## Contributing
+
+To extend the MCP integration:
+
+1. Implement new tool adapters in `BrainTool`
+2. Add server type support in `MCPBrainClient`
+3. Enhance error handling and logging
+4. Add new tool creation utilities
+
+## License
+
+MIT License - see LICENSE file for details. 

README.md

@@ -5,7 +5,7 @@ colorFrom: yellow
 colorTo: purple
 sdk: gradio
 sdk_version: 5.32.0
-app_file: app1.py
+app_file: app_with_mcp.py
 pinned: false
 license: mit
 short_description: minion running in space

app_with_mcp.py

@@ -0,0 +1,461 @@
+import gradio as gr
+import asyncio
+import os
+from typing import Dict, Any, List, Optional
+from dotenv import load_dotenv
+
+from minion import config
+from minion.main import LocalPythonEnv
+from minion.main.rpyc_python_env import RpycPythonEnv
+from minion.main.brain import Brain
+from minion.providers import create_llm_provider
+
+# Import our MCP integration
+from mcp_integration import MCPBrainClient, create_final_answer_tool, BrainTool, add_filesystem_tool
+
+# Load .env file
+load_dotenv()
+
+class LLMConfig:
+    def __init__(self, api_type: str, api_key: str, base_url: str, api_version: str, 
+                 model: str, temperature: float = 0.7, max_tokens: int = 4000, 
+                 vision_enabled: bool = False):
+        self.api_type = api_type
+        self.api_key = api_key
+        self.base_url = base_url
+        self.api_version = api_version
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.vision_enabled = vision_enabled
+
+def get_preset_configs():
+    """Get preset configurations"""
+    presets = {
+        "gpt-4o": LLMConfig(
+            api_type=os.getenv("GPT_4O_API_TYPE", "azure"),
+            api_key=os.getenv("GPT_4O_API_KEY", ""),
+            base_url=os.getenv("GPT_4O_BASE_URL", ""),
+            api_version=os.getenv("GPT_4O_API_VERSION", "2024-06-01"),
+            model=os.getenv("GPT_4O_MODEL", "gpt-4o"),
+            temperature=float(os.getenv("GPT_4O_TEMPERATURE", "0")),
+            max_tokens=int(os.getenv("GPT_4O_MAX_TOKENS", "4000"))
+        ),
+        "gpt-4o-mini": LLMConfig(
+            api_type=os.getenv("GPT_4O_MINI_API_TYPE", "azure"),
+            api_key=os.getenv("GPT_4O_MINI_API_KEY", ""),
+            base_url=os.getenv("GPT_4O_MINI_BASE_URL", ""),
+            api_version=os.getenv("GPT_4O_MINI_API_VERSION", "2024-06-01"),
+            model=os.getenv("GPT_4O_MINI_MODEL", "gpt-4o-mini"),
+            temperature=float(os.getenv("GPT_4O_MINI_TEMPERATURE", "0.1")),
+            max_tokens=int(os.getenv("GPT_4O_MINI_MAX_TOKENS", "4000"))
+        ),
+        "gpt-4.1": LLMConfig(
+            api_type=os.getenv("GPT_41_API_TYPE", "azure"),
+            api_key=os.getenv("GPT_41_API_KEY", ""),
+            base_url=os.getenv("GPT_41_BASE_URL", ""),
+            api_version=os.getenv("GPT_41_API_VERSION", "2025-03-01-preview"),
+            model=os.getenv("GPT_41_MODEL", "gpt-4.1"),
+            temperature=float(os.getenv("GPT_41_TEMPERATURE", "0.7")),
+            max_tokens=int(os.getenv("GPT_41_MAX_TOKENS", "4000"))
+        ),
+        "o4-mini": LLMConfig(
+            api_type=os.getenv("O4_MINI_API_TYPE", "azure"),
+            api_key=os.getenv("O4_MINI_API_KEY", ""),
+            base_url=os.getenv("O4_MINI_BASE_URL", ""),
+            api_version=os.getenv("O4_MINI_API_VERSION", "2025-03-01-preview"),
+            model=os.getenv("O4_MINI_MODEL", "o4-mini"),
+            temperature=float(os.getenv("O4_MINI_TEMPERATURE", "0.7")),
+            max_tokens=int(os.getenv("O4_MINI_MAX_TOKENS", "4000"))
+        )
+    }
+    return presets
+
+def get_default_config():
+    """Get default configuration"""
+    return LLMConfig(
+        api_type=os.getenv("DEFAULT_API_TYPE", "azure"),
+        api_key=os.getenv("DEFAULT_API_KEY", ""),
+        base_url=os.getenv("DEFAULT_BASE_URL", ""),
+        api_version=os.getenv("DEFAULT_API_VERSION", "2024-06-01"),
+        model=os.getenv("DEFAULT_MODEL", "gpt-4o"),
+        temperature=float(os.getenv("DEFAULT_TEMPERATURE", "0.7")),
+        max_tokens=int(os.getenv("DEFAULT_MAX_TOKENS", "4000"))
+    )
+
+def get_available_routes():
+    """Get available route options for current minion system"""
+    return [
+        "",            # Auto route selection (empty for automatic)
+        "raw",         # Raw LLM output without processing
+        "native",      # Native minion processing
+        "cot",         # Chain of Thought reasoning
+        "dcot",        # Dynamic Chain of Thought
+        "plan",        # Planning-based approach
+        "python"       # Python code execution
+    ]
+
+def create_custom_llm_config(api_type: str, api_key: str, base_url: str, 
+                           api_version: str, model: str, temperature: float, 
+                           max_tokens: int) -> Dict[str, Any]:
+    """Create custom LLM configuration"""
+    return {
+        'api_type': api_type,
+        'api_key': api_key,
+        'base_url': base_url,
+        'api_version': api_version,
+        'model': model,
+        'temperature': temperature,
+        'max_tokens': max_tokens,
+        'vision_enabled': False
+    }
+
+def build_brain_with_config(llm_config_dict: Dict[str, Any]):
+    """Build brain with specified configuration"""
+    # Create a config object similar to LLMConfig
+    class Config:
+        def __init__(self, config_dict):
+            for key, value in config_dict.items():
+                setattr(self, key, value)
+    
+    config_obj = Config(llm_config_dict)
+    llm = create_llm_provider(config_obj)
+    python_env = LocalPythonEnv(verbose=False)
+    brain = Brain(
+        python_env=python_env,
+        llm=llm,
+    )
+    return brain
+
+# Global MCP client instance
+mcp_client: Optional[MCPBrainClient] = None
+
+async def setup_mcp_tools():
+    """Setup MCP tools and connections"""
+    global mcp_client
+    
+    if mcp_client is None:
+        mcp_client = MCPBrainClient()
+        await mcp_client.__aenter__()
+        
+        # Add filesystem tool (always try to add this)
+        try:
+            await add_filesystem_tool(mcp_client)
+            print("✓ Added filesystem tool")
+        except Exception as e:
+            print(f"⚠ Failed to add filesystem tool: {e}")
+        
+        # Add MCP servers from environment variables
+        # Example: SSE server
+        sse_url = os.getenv("MCP_SSE_URL")
+        if sse_url:
+            try:
+                await mcp_client.add_mcp_server("sse", url=sse_url)
+                print(f"✓ Added SSE server: {sse_url}")
+            except Exception as e:
+                print(f"⚠ Failed to add SSE server: {e}")
+        
+        # Example: Stdio server
+        stdio_command = os.getenv("MCP_STDIO_COMMAND")
+        if stdio_command:
+            try:
+                await mcp_client.add_mcp_server("stdio", command=stdio_command)
+                print(f"✓ Added stdio server: {stdio_command}")
+            except Exception as e:
+                print(f"⚠ Failed to add stdio server: {e}")
+    
+    return mcp_client
+
+async def get_available_tools() -> List[BrainTool]:
+    """Get all available tools including MCP tools and final answer tool"""
+    try:
+        mcp_client = await setup_mcp_tools()
+        mcp_tools = mcp_client.get_tools_for_brain()
+    except Exception as e:
+        print(f"Warning: Failed to setup MCP tools: {e}")
+        mcp_tools = []
+    
+    # Always add final answer tool
+    final_answer_tool = create_final_answer_tool()
+    
+    return mcp_tools + [final_answer_tool]
+
+# Get preset configurations and default configuration
+preset_configs = get_preset_configs()
+default_config = get_default_config()
+available_routes = get_available_routes()
+
+async def minion_respond_async(query: str, preset_model: str, api_type: str, 
+                             api_key: str, base_url: str, api_version: str, 
+                             model: str, temperature: float, max_tokens: int,
+                             route: str, query_type: str, check_enabled: bool,
+                             use_tools: bool):
+    """Respond to query using specified configuration with optional MCP tools"""
+    
+    # If a preset model is selected, use preset configuration
+    if preset_model != "Custom":
+        config_obj = preset_configs.get(preset_model, default_config)
+        llm_config_dict = {
+            'api_type': config_obj.api_type,
+            'api_key': config_obj.api_key,
+            'base_url': config_obj.base_url,
+            'api_version': config_obj.api_version,
+            'model': config_obj.model,
+            'temperature': config_obj.temperature,
+            'max_tokens': config_obj.max_tokens,
+            'vision_enabled': config_obj.vision_enabled
+        }
+    else:
+        # Use custom configuration
+        llm_config_dict = create_custom_llm_config(
+            api_type, api_key, base_url, api_version, model, temperature, max_tokens
+        )
+    
+    brain = build_brain_with_config(llm_config_dict)
+    # Handle empty route selection for auto route
+    route_param = route if route else None
+    
+    # Build kwargs for brain.step
+    kwargs = {'query': query, 'route': route_param, 'check': check_enabled}
+    
+    # Add query_type to kwargs if route is python
+    if route == "python" and query_type:
+        kwargs['query_type'] = query_type
+    
+    # Add tools if enabled
+    if use_tools:
+        try:
+            tools = await get_available_tools()
+            kwargs['tools'] = tools
+            print(f"Using {len(tools)} tools: {[tool.name for tool in tools]}")
+        except Exception as e:
+            print(f"Warning: Failed to get tools: {e}")
+    
+    obs, score, *_ = await brain.step(**kwargs)
+    return obs
+
+def minion_respond(query: str, preset_model: str, api_type: str, api_key: str, 
+                  base_url: str, api_version: str, model: str, temperature: float, 
+                  max_tokens: int, route: str, query_type: str, check_enabled: bool,
+                  use_tools: bool):
+    """Gradio sync interface, automatically schedules async"""
+    return asyncio.run(minion_respond_async(
+        query, preset_model, api_type, api_key, base_url, 
+        api_version, model, temperature, max_tokens, route, query_type, check_enabled,
+        use_tools
+    ))
+
+def update_fields(preset_model: str):
+    """Update other fields when preset model is selected"""
+    if preset_model == "Custom":
+        # Return default values, let user configure themselves
+        return (
+            default_config.api_type,
+            "",  # Don't display API key 
+            default_config.base_url,
+            default_config.api_version,
+            default_config.model,
+            default_config.temperature,
+            default_config.max_tokens
+        )
+    else:
+        config_obj = preset_configs.get(preset_model, default_config)
+        # Ensure API type is from valid choices
+        api_type = config_obj.api_type if config_obj.api_type in ["azure", "openai", "groq", "ollama", "anthropic", "gemini"] else "azure"
+        return (
+            api_type,
+            "***hidden***",  # Hide API key display
+            config_obj.base_url,
+            config_obj.api_version,
+            config_obj.model,
+            config_obj.temperature,
+            config_obj.max_tokens
+        )
+
+def update_query_type_visibility(route: str):
+    """Show query_type dropdown only when route is python"""
+    return gr.update(visible=(route == "python"))
+
+async def get_tool_status():
+    """Get status of available tools"""
+    try:
+        tools = await get_available_tools()
+        return f"Available tools: {', '.join([tool.name for tool in tools])}"
+    except Exception as e:
+        return f"Error getting tools: {str(e)}"
+
+def check_tools():
+    """Sync wrapper for tool status check"""
+    return asyncio.run(get_tool_status())
+
+# Create Gradio interface
+with gr.Blocks(title="Minion Brain Chat with MCP Tools") as demo:
+    gr.Markdown("# Minion Brain Chat with MCP Tools\nIntelligent Q&A powered by Minion1 Brain with MCP tool support")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            query_input = gr.Textbox(
+                label="Enter your question",
+                placeholder="Please enter your question...",
+                lines=3
+            )
+            submit_btn = gr.Button("Submit", variant="primary")
+            
+            # Tool status
+            with gr.Row():
+                tool_status_btn = gr.Button("Check Available Tools", size="sm")
+                tool_status_output = gr.Textbox(
+                    label="Tool Status",
+                    lines=2,
+                    interactive=False
+                )
+            
+            # Move Answer section to left column, closer to question input
+            output = gr.Textbox(
+                label="Answer",
+                lines=10,
+                show_copy_button=True
+            )
+            
+        with gr.Column(scale=1):
+            # Tool settings
+            use_tools_checkbox = gr.Checkbox(
+                label="Enable MCP Tools",
+                value=True,
+                info="Use Model Context Protocol tools"
+            )
+            
+            # Move route selection to the front
+            route_dropdown = gr.Dropdown(
+                label="Route",
+                choices=available_routes,
+                value="",
+                info="empty: auto select, raw: direct LLM, native: standard, cot: chain of thought, dcot: dynamic cot, plan: planning, python: code execution"
+            )
+            
+            # Add query_type option, visible only when route="python"
+            query_type_dropdown = gr.Dropdown(
+                label="Query Type",
+                choices=["calculate", "code_solution", "generate"],
+                value="calculate",
+                visible=False,
+                info="Type of query for python route"
+            )
+            
+            # Add check option
+            check_checkbox = gr.Checkbox(
+                label="Enable Check",
+                value=False,
+                info="Enable output verification and validation"
+            )
+            
+            preset_dropdown = gr.Dropdown(
+                label="Preset Model",
+                choices=["Custom"] + list(preset_configs.keys()),
+                value="gpt-4o",
+                info="Select preset configuration or custom"
+            )
+            
+            api_type_input = gr.Dropdown(
+                label="API Type",
+                choices=["azure", "openai", "groq", "ollama", "anthropic", "gemini"],
+                value=default_config.api_type,
+                info="Select API provider type"
+            )
+            
+            api_key_input = gr.Textbox(
+                label="API Key",
+                value="***hidden***",
+                type="password",
+                info="Your API key"
+            )
+            
+            base_url_input = gr.Textbox(
+                label="Base URL",
+                value=default_config.base_url,
+                info="API base URL"
+            )
+            
+            api_version_input = gr.Textbox(
+                label="API Version",
+                value=default_config.api_version,
+                info="API version (required for Azure)"
+            )
+            
+            model_input = gr.Textbox(
+                label="Model",
+                value=default_config.model,
+                info="Model name"
+            )
+            
+            temperature_input = gr.Slider(
+                label="Temperature",
+                minimum=0.0,
+                maximum=2.0,
+                value=default_config.temperature,
+                step=0.1,
+                info="Control output randomness"
+            )
+            
+            max_tokens_input = gr.Slider(
+                label="Max Tokens",
+                minimum=100,
+                maximum=8000,
+                value=default_config.max_tokens,
+                step=100,
+                info="Maximum number of tokens to generate"
+            )
+    
+    # Update other fields when preset model changes
+    preset_dropdown.change(
+        fn=update_fields,
+        inputs=[preset_dropdown],
+        outputs=[api_type_input, api_key_input, base_url_input, 
+                api_version_input, model_input, temperature_input, max_tokens_input]
+    )
+    
+    # Update query_type visibility when route changes
+    route_dropdown.change(
+        fn=update_query_type_visibility,
+        inputs=[route_dropdown],
+        outputs=[query_type_dropdown]
+    )
+    
+    # Tool status check
+    tool_status_btn.click(
+        fn=check_tools,
+        outputs=[tool_status_output]
+    )
+    
+    # Submit button event
+    submit_btn.click(
+        fn=minion_respond,
+        inputs=[query_input, preset_dropdown, api_type_input, api_key_input, 
+               base_url_input, api_version_input, model_input, temperature_input, 
+               max_tokens_input, route_dropdown, query_type_dropdown, check_checkbox,
+               use_tools_checkbox],
+        outputs=[output]
+    )
+    
+    # Enter key submit
+    query_input.submit(
+        fn=minion_respond,
+        inputs=[query_input, preset_dropdown, api_type_input, api_key_input, 
+               base_url_input, api_version_input, model_input, temperature_input, 
+               max_tokens_input, route_dropdown, query_type_dropdown, check_checkbox,
+               use_tools_checkbox],
+        outputs=[output]
+    )
+
+# Cleanup function
+async def cleanup_on_exit():
+    """Clean up MCP client on exit"""
+    global mcp_client
+    if mcp_client:
+        await mcp_client.cleanup()
+
+if __name__ == "__main__":
+    try:
+        demo.launch(mcp_server=True)
+    finally:
+        asyncio.run(cleanup_on_exit()) 

app1.py → app_without_mcp.py

@@ -132,7 +132,7 @@ available_routes = get_available_routes()
 async def minion_respond_async(query: str, preset_model: str, api_type: str, 
                              api_key: str, base_url: str, api_version: str, 
                              model: str, temperature: float, max_tokens: int,
-                             route: str, check_enabled: bool):
+                             route: str, query_type: str, check_enabled: bool):
     """Respond to query using specified configuration"""
     
     # If a preset model is selected, use preset configuration
@@ -157,16 +157,22 @@ async def minion_respond_async(query: str, preset_model: str, api_type: str,
     brain = build_brain_with_config(llm_config_dict)
     # Handle empty route selection for auto route
     route_param = route if route else None
-    obs, score, *_ = await brain.step(query=query, route=route_param, check=check_enabled)
+    
+    # Add query_type to kwargs if route is python
+    kwargs = {'query': query, 'route': route_param, 'check': check_enabled}
+    if route == "python" and query_type:
+        kwargs['query_type'] = query_type
+    
+    obs, score, *_ = await brain.step(**kwargs)
     return obs
 
 def minion_respond(query: str, preset_model: str, api_type: str, api_key: str, 
                   base_url: str, api_version: str, model: str, temperature: float, 
-                  max_tokens: int, route: str, check_enabled: bool):
+                  max_tokens: int, route: str, query_type: str, check_enabled: bool):
     """Gradio sync interface, automatically schedules async"""
     return asyncio.run(minion_respond_async(
         query, preset_model, api_type, api_key, base_url, 
-        api_version, model, temperature, max_tokens, route, check_enabled
+        api_version, model, temperature, max_tokens, route, query_type, check_enabled
     ))
 
 def update_fields(preset_model: str):
@@ -184,8 +190,10 @@ def update_fields(preset_model: str):
         )
     else:
         config_obj = preset_configs.get(preset_model, default_config)
+        # Ensure API type is from valid choices
+        api_type = config_obj.api_type if config_obj.api_type in ["azure", "openai", "groq", "ollama", "anthropic", "gemini"] else "azure"
         return (
-            config_obj.api_type,
+            api_type,
             "***hidden***",  # Hide API key display
             config_obj.base_url,
             config_obj.api_version,
@@ -194,6 +202,10 @@ def update_fields(preset_model: str):
             config_obj.max_tokens
         )
 
+def update_query_type_visibility(route: str):
+    """Show query_type dropdown only when route is python"""
+    return gr.update(visible=(route == "python"))
+
 # Create Gradio interface
 with gr.Blocks(title="Minion Brain Chat") as demo:
     gr.Markdown("# Minion Brain Chat\nIntelligent Q&A powered by Minion1 Brain")
@@ -207,6 +219,13 @@ with gr.Blocks(title="Minion Brain Chat") as demo:
             )
             submit_btn = gr.Button("Submit", variant="primary")
             
+            # Move Answer section to left column, closer to question input
+            output = gr.Textbox(
+                label="Answer",
+                lines=10,
+                show_copy_button=True
+            )
+            
         with gr.Column(scale=1):
             # Move route selection to the front
             route_dropdown = gr.Dropdown(
@@ -216,6 +235,15 @@ with gr.Blocks(title="Minion Brain Chat") as demo:
                 info="empty: auto select, raw: direct LLM, native: standard, cot: chain of thought, dcot: dynamic cot, plan: planning, python: code execution"
             )
             
+            # Add query_type option, visible only when route="python"
+            query_type_dropdown = gr.Dropdown(
+                label="Query Type",
+                choices=["calculate", "code_solution", "generate"],
+                value="calculate",
+                visible=False,
+                info="Type of query for python route"
+            )
+            
             # Add check option
             check_checkbox = gr.Checkbox(
                 label="Enable Check",
@@ -230,10 +258,11 @@ with gr.Blocks(title="Minion Brain Chat") as demo:
                 info="Select preset configuration or custom"
             )
             
-            api_type_input = gr.Textbox(
+            api_type_input = gr.Dropdown(
                 label="API Type",
+                choices=["azure", "openai", "groq", "ollama", "anthropic", "gemini"],
                 value=default_config.api_type,
-                info="openai, azure, ollama, groq etc."
+                info="Select API provider type"
             )
             
             api_key_input = gr.Textbox(
@@ -279,13 +308,6 @@ with gr.Blocks(title="Minion Brain Chat") as demo:
                 info="Maximum number of tokens to generate"
             )
     
-    # Move Answer section up
-    output = gr.Textbox(
-        label="Answer",
-        lines=10,
-        show_copy_button=True
-    )
-    
     # Update other fields when preset model changes
     preset_dropdown.change(
         fn=update_fields,
@@ -294,12 +316,19 @@ with gr.Blocks(title="Minion Brain Chat") as demo:
                 api_version_input, model_input, temperature_input, max_tokens_input]
     )
     
+    # Update query_type visibility when route changes
+    route_dropdown.change(
+        fn=update_query_type_visibility,
+        inputs=[route_dropdown],
+        outputs=[query_type_dropdown]
+    )
+    
     # Submit button event
     submit_btn.click(
         fn=minion_respond,
         inputs=[query_input, preset_dropdown, api_type_input, api_key_input, 
                base_url_input, api_version_input, model_input, temperature_input, 
-               max_tokens_input, route_dropdown, check_checkbox],
+               max_tokens_input, route_dropdown, query_type_dropdown, check_checkbox],
         outputs=[output]
     )
     
@@ -308,7 +337,7 @@ with gr.Blocks(title="Minion Brain Chat") as demo:
         fn=minion_respond,
         inputs=[query_input, preset_dropdown, api_type_input, api_key_input, 
                base_url_input, api_version_input, model_input, temperature_input, 
-               max_tokens_input, route_dropdown, check_checkbox],
+               max_tokens_input, route_dropdown, query_type_dropdown, check_checkbox],
         outputs=[output]
     )
 

example_mcp_server.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""
+Example MCP Server for testing with Minion Brain integration
+
+This server provides simple tools for demonstration purposes:
+- calculator: Basic arithmetic operations  
+- echo: Simple echo/repeat functionality
+- timestamp: Get current timestamp
+"""
+
+import asyncio
+import json
+import math
+from datetime import datetime
+from typing import Any, Dict
+
+import mcp.types as types
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+import mcp.server.stdio
+
+
+# Create server instance
+server = Server("example-tools-server")
+
+
+@server.list_tools()
+async def handle_list_tools() -> list[types.Tool]:
+    """List available tools."""
+    return [
+        types.Tool(
+            name="calculator",
+            description="Perform basic arithmetic calculations",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "expression": {
+                        "type": "string",
+                        "description": "Mathematical expression to evaluate (e.g., '2 + 3 * 4')"
+                    }
+                },
+                "required": ["expression"]
+            }
+        ),
+        types.Tool(
+            name="echo",
+            description="Echo back the provided text",
+            inputSchema={
+                "type": "object", 
+                "properties": {
+                    "text": {
+                        "type": "string",
+                        "description": "Text to echo back"
+                    }
+                },
+                "required": ["text"]
+            }
+        ),
+        types.Tool(
+            name="timestamp",
+            description="Get current timestamp",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "format": {
+                        "type": "string",
+                        "description": "Timestamp format ('iso', 'unix', or 'readable')",
+                        "default": "iso"
+                    }
+                }
+            }
+        ),
+        types.Tool(
+            name="math_functions",
+            description="Advanced mathematical functions",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "function": {
+                        "type": "string", 
+                        "description": "Math function to use",
+                        "enum": ["sin", "cos", "tan", "log", "sqrt", "factorial"]
+                    },
+                    "value": {
+                        "type": "number",
+                        "description": "Input value for the function"
+                    }
+                },
+                "required": ["function", "value"]
+            }
+        )
+    ]
+
+
+@server.call_tool()
+async def handle_call_tool(name: str, arguments: dict) -> list[types.TextContent]:
+    """Handle tool execution."""
+    
+    if name == "calculator":
+        expression = arguments.get("expression", "")
+        try:
+            # Simple and safe evaluation for basic arithmetic
+            # Note: In production, use a proper math parser for security
+            allowed_chars = set("0123456789+-*/()., ")
+            if not all(c in allowed_chars for c in expression):
+                raise ValueError("Invalid characters in expression")
+            
+            result = eval(expression)
+            return [types.TextContent(
+                type="text",
+                text=f"Result: {expression} = {result}"
+            )]
+        except Exception as e:
+            return [types.TextContent(
+                type="text", 
+                text=f"Error: Unable to calculate '{expression}': {str(e)}"
+            )]
+    
+    elif name == "echo":
+        text = arguments.get("text", "")
+        return [types.TextContent(
+            type="text",
+            text=f"Echo: {text}"
+        )]
+    
+    elif name == "timestamp":
+        format_type = arguments.get("format", "iso")
+        now = datetime.now()
+        
+        if format_type == "unix":
+            timestamp = str(int(now.timestamp()))
+        elif format_type == "readable":
+            timestamp = now.strftime("%Y-%m-%d %H:%M:%S")
+        else:  # iso format
+            timestamp = now.isoformat()
+        
+        return [types.TextContent(
+            type="text",
+            text=f"Current timestamp ({format_type}): {timestamp}"
+        )]
+    
+    elif name == "math_functions":
+        function = arguments.get("function")
+        value = arguments.get("value")
+        
+        try:
+            if function == "sin":
+                result = math.sin(math.radians(value))
+            elif function == "cos":
+                result = math.cos(math.radians(value))
+            elif function == "tan":
+                result = math.tan(math.radians(value))
+            elif function == "log":
+                result = math.log(value)
+            elif function == "sqrt":
+                result = math.sqrt(value)
+            elif function == "factorial":
+                result = math.factorial(int(value))
+            else:
+                raise ValueError(f"Unknown function: {function}")
+            
+            return [types.TextContent(
+                type="text",
+                text=f"{function}({value}) = {result}"
+            )]
+        except Exception as e:
+            return [types.TextContent(
+                type="text",
+                text=f"Error: Unable to calculate {function}({value}): {str(e)}"
+            )]
+    
+    else:
+        raise ValueError(f"Unknown tool: {name}")
+
+
+async def main():
+    """Main function to run the MCP server."""
+    # Run the server using stdio transport
+    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="example-tools-server",
+                server_version="1.0.0",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

filesystem_tool_example.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+# Add current directory to path for imports
+sys.path.append(str(Path(__file__).parent))
+
+from mcp_integration import MCPBrainClient, create_final_answer_tool, add_filesystem_tool
+
+
+async def demo_filesystem_tool():
+    """演示文件系统工具的基本功能"""
+    print("🔍 文件系统工具演示")
+    print("=" * 50)
+    
+    try:
+        async with MCPBrainClient() as client:
+            print("✓ 初始化 MCP 客户端")
+            
+            # 添加文件系统工具
+            try:
+                await add_filesystem_tool(client, workspace_paths=[
+                    "/Users/femtozheng/workspace",
+                    "/Users/femtozheng/python-project/minion-agent"
+                ])
+                print("✓ 文件系统工具添加成功")
+                
+                # 获取所有工具
+                tools = client.get_tools_for_brain()
+                print(f"✓ 总共可用工具: {len(tools)}")
+                
+                # 筛选文件系统相关工具
+                fs_tools = [t for t in tools if any(keyword in t.name.lower() 
+                           for keyword in ['file', 'read', 'write', 'list', 'directory'])]
+                
+                if fs_tools:
+                    print(f"\n📁 发现 {len(fs_tools)} 个文件系统工具:")
+                    for i, tool in enumerate(fs_tools, 1):
+                        print(f"  {i}. {tool.name}")
+                        print(f"     描述: {tool.description}")
+                        if hasattr(tool, 'parameters') and tool.parameters:
+                            props = tool.parameters.get('properties', {})
+                            if props:
+                                print(f"     参数: {', '.join(props.keys())}")
+                        print()
+                    
+                    # 演示如何在 brain.step 中使用
+                    print("💡 在 brain.step 中使用示例:")
+                    print("```python")
+                    print("# 添加最终答案工具")
+                    print("final_tool = create_final_answer_tool()")
+                    print("all_tools = fs_tools + [final_tool]")
+                    print()
+                    print("# 在 brain.step 中使用")
+                    print("obs, score, *_ = await brain.step(")
+                    print("    query='请读取 README.md 文件的内容',")
+                    print("    route='raw',")
+                    print("    check=False,")
+                    print("    tools=all_tools")
+                    print(")")
+                    print("```")
+                    
+                    # 模拟 brain.step 调用
+                    print("\n🧠 模拟 brain.step 集成:")
+                    final_tool = create_final_answer_tool()
+                    all_tools = fs_tools + [final_tool]
+                    
+                    tool_specs = [tool.to_function_spec() for tool in all_tools]
+                    print(f"✓ 生成了 {len(tool_specs)} 个工具规格")
+                    print("✓ 工具已准备好供 brain.step 使用")
+                    
+                    # 展示工具规格格式
+                    if fs_tools:
+                        sample_tool = fs_tools[0]
+                        print(f"\n📋 示例工具规格 ({sample_tool.name}):")
+                        spec = sample_tool.to_function_spec()
+                        print(f"  类型: {spec.get('type', 'N/A')}")
+                        print(f"  函数名: {spec.get('function', {}).get('name', 'N/A')}")
+                        print(f"  描述: {spec.get('function', {}).get('description', 'N/A')}")
+                        
+                else:
+                    print("⚠ 没有发现文件系统相关工具")
+                    print("可能的原因:")
+                    print("- @modelcontextprotocol/server-filesystem 未正确安装")
+                    print("- Node.js/npx 环境问题")
+                    print("- 工具名称不包含预期的关键词")
+                    
+            except Exception as e:
+                print(f"❌ 添加文件系统工具失败: {e}")
+                print("\n故障排除:")
+                print("1. 确保安装了 Node.js 和 npx")
+                print("2. 运行: npx @modelcontextprotocol/server-filesystem --help")
+                print("3. 检查网络连接")
+                print("4. 确保指定的路径存在且可访问")
+                
+    except Exception as e:
+        print(f"❌ 演示失败: {e}")
+
+
+async def test_filesystem_paths():
+    """测试不同的文件系统路径配置"""
+    print("\n🛠 测试自定义路径配置")
+    print("=" * 50)
+    
+    # 测试不同的路径组合
+    test_paths = [
+        ["/Users/femtozheng/workspace"],
+        ["/Users/femtozheng/python-project/minion-agent"],
+        ["/Users/femtozheng/workspace", "/Users/femtozheng/python-project/minion-agent"],
+        [".", str(Path.home() / "Documents")]  # 相对路径和绝对路径混合
+    ]
+    
+    for i, paths in enumerate(test_paths, 1):
+        print(f"\n📁 测试配置 {i}: {paths}")
+        try:
+            # 检查路径是否存在
+            existing_paths = []
+            for path in paths:
+                if Path(path).exists():
+                    existing_paths.append(path)
+                    print(f"  ✓ 路径存在: {path}")
+                else:
+                    print(f"  ⚠ 路径不存在: {path}")
+            
+            if existing_paths:
+                async with MCPBrainClient() as client:
+                    await add_filesystem_tool(client, workspace_paths=existing_paths)
+                    tools = client.get_tools_for_brain()
+                    fs_tools = [t for t in tools if any(keyword in t.name.lower() 
+                               for keyword in ['file', 'read', 'write', 'list'])]
+                    print(f"  ✓ 配置成功，发现 {len(fs_tools)} 个文件系统工具")
+            else:
+                print("  ⚠ 跳过测试（没有有效路径）")
+                
+        except Exception as e:
+            print(f"  ❌ 配置失败: {e}")
+
+
+async def show_integration_example():
+    """展示完整的集成示例"""
+    print("\n🚀 完整集成示例")
+    print("=" * 50)
+    
+    print("""
+这里是如何在实际项目中使用文件系统工具的示例:
+
+```python
+from mcp_integration import MCPBrainClient, add_filesystem_tool, create_final_answer_tool
+from minion.main.brain import Brain
+from minion.main import LocalPythonEnv  
+from minion.providers import create_llm_provider
+
+async def use_filesystem_in_brain():
+    # 1. 设置 MCP 客户端和文件系统工具
+    async with MCPBrainClient() as mcp_client:
+        await add_filesystem_tool(mcp_client, workspace_paths=[
+            "/Users/femtozheng/workspace",
+            "/Users/femtozheng/python-project/minion-agent"
+        ])
+        
+        # 2. 获取所有工具
+        mcp_tools = mcp_client.get_tools_for_brain()
+        final_tool = create_final_answer_tool()
+        all_tools = mcp_tools + [final_tool]
+        
+        # 3. 创建 brain 实例
+        llm = create_llm_provider(your_config)
+        python_env = LocalPythonEnv(verbose=False)
+        brain = Brain(python_env=python_env, llm=llm)
+        
+        # 4. 使用 brain.step 处理文件操作
+        obs, score, *_ = await brain.step(
+            query="请读取项目根目录的 README.md 文件并总结其内容",
+            route="raw",
+            check=False,
+            tools=all_tools
+        )
+        
+        print(f"Brain 响应: {obs}")
+
+# 其他用例:
+# - "列出 workspace 目录下的所有 Python 文件"
+# - "读取 config.json 文件并解析其配置"
+# - "在指定目录创建一个新的文档文件"
+# - "搜索包含特定关键词的文件"
+```
+
+🎯 主要优势:
+- 🔒 安全: 只能访问预先配置的路径
+- 🔄 异步: 所有文件操作都是异步的
+- 🧠 智能: AI 可以理解文件内容并进行推理
+- 🛠 灵活: 支持读取、写入、列表等多种操作
+""")
+
+
+async def main():
+    """运行所有演示"""
+    print("📁 MCP 文件系统工具集成演示")
+    print("=" * 80)
+    
+    await demo_filesystem_tool()
+    await test_filesystem_paths()
+    await show_integration_example()
+    
+    print("\n✅ 演示完成!")
+    print("\n📝 下一步:")
+    print("1. 运行: python app_with_mcp.py")
+    print("2. 在界面中启用 'MCP Tools'")
+    print("3. 测试文件相关查询，如: '读取当前目录的文件列表'")
+    print("4. 或者直接在代码中使用文件系统工具")
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

mcp_integration.py

@@ -0,0 +1,466 @@
+import json
+import logging
+from contextlib import AsyncExitStack
+from datetime import timedelta
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union, overload, Callable
+
+from typing_extensions import NotRequired, TypeAlias, TypedDict, Unpack
+
+if TYPE_CHECKING:
+    from mcp import ClientSession
+
+logger = logging.getLogger(__name__)
+
+# Type alias for tool names
+ToolName: TypeAlias = str
+
+ServerType: TypeAlias = Literal["stdio", "sse", "http"]
+
+
+class StdioServerParameters_T(TypedDict):
+    command: str
+    args: NotRequired[List[str]]
+    env: NotRequired[Dict[str, str]]
+    cwd: NotRequired[Union[str, Path, None]]
+
+
+class SSEServerParameters_T(TypedDict):
+    url: str
+    headers: NotRequired[Dict[str, Any]]
+    timeout: NotRequired[float]
+    sse_read_timeout: NotRequired[float]
+
+
+class StreamableHTTPParameters_T(TypedDict):
+    url: str
+    headers: NotRequired[dict[str, Any]]
+    timeout: NotRequired[timedelta]
+    sse_read_timeout: NotRequired[timedelta]
+    terminate_on_close: NotRequired[bool]
+
+
+def format_mcp_result(result: Any) -> str:
+    #should we format mcp.types result to some result format handled by our framework?
+    return str(result)
+    """Format MCP tool result for minion brain.step"""
+    # if isinstance(result, dict):
+    #     # Handle MCP result format
+    #     if "content" in result:
+    #         content_items = result["content"]
+    #         if isinstance(content_items, list):
+    #             texts = []
+    #             for item in content_items:
+    #                 if isinstance(item, dict) and item.get("type") == "text":
+    #                     texts.append(item.get("text", ""))
+    #             return "\n".join(texts)
+    #         elif isinstance(content_items, str):
+    #             return content_items
+    #
+    #     # Handle other dict formats
+    #     if "text" in result:
+    #         return result["text"]
+    #
+    #     # Fallback to JSON string
+    #     return json.dumps(result, indent=2)
+    #
+    # elif isinstance(result, str):
+    #     return result
+    # else:
+    #     return str(result)
+
+
+class BrainTool:
+    """
+    Adapter class to convert MCP tools to brain.step compatible format
+    """
+    def __init__(self, name: str, description: str, parameters: Dict[str, Any], session: "ClientSession"):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.session = session
+        
+        # Add attributes expected by minion framework
+        self.__name__ = name
+        self.__doc__ = description
+        self.__input_schema__ = parameters
+        
+    async def __call__(self, **kwargs) -> str:
+        """Execute the tool with given parameters"""
+        try:
+            result = await self.session.call_tool(self.name, kwargs)
+            return format_mcp_result(result)
+        except Exception as e:
+            logger.error(f"Error executing tool {self.name}: {e}")
+            return f"Error: {str(e)}"
+    
+    def to_function_spec(self) -> Dict[str, Any]:
+        """Convert to function specification format for brain.step"""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters,
+            }
+        }
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format"""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters
+        }
+
+
+class MCPBrainClient:
+    """
+    Client for connecting to MCP servers and providing tools to minion brain.step
+    """
+    
+    def __init__(self):
+        # Initialize MCP sessions as a dictionary of ClientSession objects
+        self.sessions: Dict[ToolName, "ClientSession"] = {}
+        self.exit_stack = AsyncExitStack()
+        self.available_tools: List[BrainTool] = []
+
+    async def __aenter__(self):
+        """Enter the context manager"""
+        await self.exit_stack.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit the context manager"""
+        await self.cleanup()
+
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.exit_stack.aclose()
+
+    @overload
+    async def add_mcp_server(self, type: Literal["stdio"], **params: Unpack[StdioServerParameters_T]): ...
+
+    @overload
+    async def add_mcp_server(self, type: Literal["sse"], **params: Unpack[SSEServerParameters_T]): ...
+
+    @overload
+    async def add_mcp_server(self, type: Literal["http"], **params: Unpack[StreamableHTTPParameters_T]): ...
+
+    async def add_mcp_server(self, type: ServerType, **params: Any):
+        """Connect to an MCP server and add its tools to available tools
+
+        Args:
+            type (`str`):
+                Type of the server to connect to. Can be one of:
+                - "stdio": Standard input/output server (local)
+                - "sse": Server-sent events (SSE) server
+                - "http": StreamableHTTP server
+            **params (`Dict[str, Any]`):
+                Server parameters that can be either:
+                    - For stdio servers:
+                        - command (str): The command to run the MCP server
+                        - args (List[str], optional): Arguments for the command
+                        - env (Dict[str, str], optional): Environment variables for the command
+                        - cwd (Union[str, Path, None], optional): Working directory for the command
+                    - For SSE servers:
+                        - url (str): The URL of the SSE server
+                        - headers (Dict[str, Any], optional): Headers for the SSE connection
+                        - timeout (float, optional): Connection timeout
+                        - sse_read_timeout (float, optional): SSE read timeout
+                    - For StreamableHTTP servers:
+                        - url (str): The URL of the StreamableHTTP server
+                        - headers (Dict[str, Any], optional): Headers for the StreamableHTTP connection
+                        - timeout (timedelta, optional): Connection timeout
+                        - sse_read_timeout (timedelta, optional): SSE read timeout
+                        - terminate_on_close (bool, optional): Whether to terminate on close
+        """
+        from mcp import ClientSession, StdioServerParameters
+        from mcp import types as mcp_types
+
+        # Determine server type and create appropriate parameters
+        if type == "stdio":
+            # Handle stdio server
+            from mcp.client.stdio import stdio_client
+
+            logger.info(f"Connecting to stdio MCP server with command: {params['command']} {params.get('args', [])}")
+
+            client_kwargs = {"command": params["command"]}
+            for key in ["args", "env", "cwd"]:
+                if params.get(key) is not None:
+                    client_kwargs[key] = params[key]
+            server_params = StdioServerParameters(**client_kwargs)
+            read, write = await self.exit_stack.enter_async_context(stdio_client(server_params))
+        elif type == "sse":
+            # Handle SSE server
+            from mcp.client.sse import sse_client
+
+            logger.info(f"Connecting to SSE MCP server at: {params['url']}")
+
+            client_kwargs = {"url": params["url"]}
+            for key in ["headers", "timeout", "sse_read_timeout"]:
+                if params.get(key) is not None:
+                    client_kwargs[key] = params[key]
+            read, write = await self.exit_stack.enter_async_context(sse_client(**client_kwargs))
+        elif type == "http":
+            # Handle StreamableHTTP server
+            from mcp.client.streamable_http import streamablehttp_client
+
+            logger.info(f"Connecting to StreamableHTTP MCP server at: {params['url']}")
+
+            client_kwargs = {"url": params["url"]}
+            for key in ["headers", "timeout", "sse_read_timeout", "terminate_on_close"]:
+                if params.get(key) is not None:
+                    client_kwargs[key] = params[key]
+            read, write, _ = await self.exit_stack.enter_async_context(streamablehttp_client(**client_kwargs))
+        else:
+            raise ValueError(f"Unsupported server type: {type}")
+
+        session = await self.exit_stack.enter_async_context(
+            ClientSession(
+                read_stream=read,
+                write_stream=write,
+                client_info=mcp_types.Implementation(
+                    name="minion.MCPBrainClient",
+                    version="1.0.0",
+                ),
+            )
+        )
+
+        logger.debug("Initializing session...")
+        await session.initialize()
+
+        # List available tools
+        response = await session.list_tools()
+        logger.debug("Connected to server with tools:", [tool.name for tool in response.tools])
+
+        for tool in response.tools:
+            if tool.name in self.sessions:
+                logger.warning(f"Tool '{tool.name}' already defined by another server. Skipping.")
+                continue
+
+            # Map tool names to their server for later lookup
+            self.sessions[tool.name] = session
+
+            # Create BrainTool wrapper
+            brain_tool = BrainTool(
+                name=tool.name,
+                description=tool.description,
+                parameters=tool.inputSchema,
+                session=session
+            )
+            
+            # Add tool to the list of available tools
+            self.available_tools.append(brain_tool)
+
+    def get_tools_for_brain(self) -> List[BrainTool]:
+        """Get list of tools in the format expected by brain.step"""
+        return self.available_tools
+
+    def get_tool_functions(self) -> Dict[str, Callable]:
+        """Get dictionary of tool functions for direct execution"""
+        return {tool.name: tool for tool in self.available_tools}
+
+    def get_tool_specs(self) -> List[Dict[str, Any]]:
+        """Get list of tool specifications in ChatCompletion format"""
+        return [tool.to_function_spec() for tool in self.available_tools]
+
+    def get_tools_dict(self) -> List[Dict[str, Any]]:
+        """Get list of tools as dictionaries"""
+        return [tool.to_dict() for tool in self.available_tools]
+
+
+# Helper function to create final answer tool (example implementation)
+def create_final_answer_tool() -> BrainTool:
+    """
+    Create a final answer tool that can be used with brain.step
+    This is an example of how to create a local tool without MCP
+    """
+    class FinalAnswerSession:
+        async def call_tool(self, name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": args.get("answer", "No answer provided")
+                    }
+                ]
+            }
+    
+    session = FinalAnswerSession()
+    
+    tool = BrainTool(
+        name="final_answer",
+        description="Provide the final answer to the user's question",
+        parameters={
+            "type": "object",
+            "properties": {
+                "answer": {
+                    "type": "string",
+                    "description": "The final answer to provide to the user"
+                }
+            },
+            "required": ["answer"]
+        },
+        session=session
+    )
+    
+    return tool
+
+
+def create_calculator_tool() -> BrainTool:
+    """
+    Create a local calculator tool for basic arithmetic
+    """
+    class CalculatorSession:
+        async def call_tool(self, name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+            expression = args.get("expression", "")
+            try:
+                # Simple and safe evaluation for basic arithmetic
+                allowed_chars = set("0123456789+-*/()., ")
+                if not all(c in allowed_chars for c in expression):
+                    raise ValueError("Invalid characters in expression")
+                
+                result = eval(expression)
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"Calculation result: {expression} = {result}"
+                        }
+                    ]
+                }
+            except Exception as e:
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"Error: Unable to calculate '{expression}': {str(e)}"
+                        }
+                    ]
+                }
+    
+    session = CalculatorSession()
+    
+    tool = BrainTool(
+        name="calculator",
+        description="Perform basic arithmetic calculations",
+        parameters={
+            "type": "object",
+            "properties": {
+                "expression": {
+                    "type": "string",
+                    "description": "Mathematical expression to evaluate (e.g., '2 + 3 * 4')"
+                }
+            },
+            "required": ["expression"]
+        },
+        session=session
+    )
+    
+    return tool
+
+
+async def add_filesystem_tool(mcp_client: MCPBrainClient, workspace_paths: List[str] = None) -> None:
+    """
+    Add filesystem MCP tool to the client
+    
+    Args:
+        mcp_client: The MCP client to add the tool to
+        workspace_paths: List of paths to allow access to. Defaults to common workspace paths.
+    """
+    if workspace_paths is None:
+        workspace_paths = [
+            "/Users/femtozheng/workspace",
+            "/Users/femtozheng/python-project/minion-agent"
+        ]
+    
+    try:
+        await mcp_client.add_mcp_server(
+            "stdio",
+            command="npx",
+            args=["-y", "@modelcontextprotocol/server-filesystem"] + workspace_paths
+        )
+        logger.info(f"✓ Added filesystem tool with paths: {workspace_paths}")
+    except Exception as e:
+        logger.error(f"Failed to add filesystem tool: {e}")
+        raise
+
+
+def create_filesystem_tool_factory(workspace_paths: List[str] = None):
+    """
+    Create a factory function for the filesystem tool
+    
+    Args:
+        workspace_paths: List of paths to allow access to
+        
+    Returns:
+        Async function that adds filesystem tool to an MCP client
+    """
+    if workspace_paths is None:
+        workspace_paths = [
+            "/Users/femtozheng/workspace", 
+            "/Users/femtozheng/python-project/minion-agent"
+        ]
+    
+    async def add_to_client(mcp_client: MCPBrainClient):
+        return await add_filesystem_tool(mcp_client, workspace_paths)
+    
+    return add_to_client
+
+
+class MCPToolConfig:
+    """Configuration for different MCP tools"""
+    
+    FILESYSTEM_DEFAULT = {
+        "type": "stdio",
+        "command": "npx",
+        "args": ["-y", "@modelcontextprotocol/server-filesystem"],
+        "workspace_paths": [
+            "/Users/femtozheng/workspace",
+            "/Users/femtozheng/python-project/minion-agent"
+        ]
+    }
+    
+    @staticmethod
+    def get_filesystem_config(workspace_paths: List[str] = None) -> Dict[str, Any]:
+        """Get filesystem tool configuration"""
+        config = MCPToolConfig.FILESYSTEM_DEFAULT.copy()
+        if workspace_paths:
+            config["workspace_paths"] = workspace_paths
+            config["args"] = ["-y", "@modelcontextprotocol/server-filesystem"] + workspace_paths
+        else:
+            config["args"] = ["-y", "@modelcontextprotocol/server-filesystem"] + config["workspace_paths"]
+        return config
+
+
+# Example usage:
+"""
+# Initialize MCP client
+async def example_usage():
+    async with MCPBrainClient() as mcp_client:
+        # Add MCP servers
+        await mcp_client.add_mcp_server("sse", url="http://localhost:8080/sse")
+        
+        # Get tools for brain.step
+        mcp_tools = mcp_client.get_tools_for_brain()
+        
+        # Add final answer tool
+        final_answer_tool = create_final_answer_tool()
+        all_tools = mcp_tools + [final_answer_tool]
+        
+        # Use with brain.step
+        from minion.main.brain import Brain
+        from minion.main import LocalPythonEnv
+        from minion.providers import create_llm_provider
+        
+        # Create brain instance (you'll need to configure this)
+        # brain = Brain(...)
+        
+        # obs, score, *_ = await brain.step(
+        #     query="what's the solution 234*568",
+        #     route="raw",
+        #     check=False,
+        #     tools=all_tools
+        # )
+""" 

requirements.txt

@@ -1,4 +1,4 @@
 gradio[mcp]==5.32.0
-huggingface_hub>=0.28.1
 minionx>=0.1.2
-python-dotenv>=1.0.0
+python-dotenv>=1.0.0
+mcp>=1.0.0