mcp-use 1.0.1__tar.gz → 1.0.3__tar.gz

{mcp_use-1.0.1 → mcp_use-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.0.1
+Version: 1.0.3
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -346,25 +346,58 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-## Roadmap
+# Tool Access Control
+
+MCP-Use allows you to restrict which tools are available to the agent, providing better security and control over agent capabilities:
+
+```python
+import asyncio
+from mcp_use import MCPAgent, MCPClient
+from langchain_openai import ChatOpenAI
+
+async def main():
+    # Create client
+    client = MCPClient.from_config_file("config.json")
+
+    # Create agent with restricted tools
+    agent = MCPAgent(
+        llm=ChatOpenAI(model="gpt-4"),
+        client=client,
+        disallowed_tools=["file_system", "network"]  # Restrict potentially dangerous tools
+    )
+
+    # Run a query with restricted tool access
+    result = await agent.run(
+        "Find the best restaurant in San Francisco"
+    )
+    print(result)
+
+    # Clean up
+    await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+# Roadmap
 
 <ul>
 <li>[x] Multiple Servers at once </li>
-<li>[ ] Test remote connectors (http, ws)</li>
+<li>[x] Test remote connectors (http, ws)</li>
 <li>[ ] ... </li>
 </ul>
 
-## Contributing
+# Contributing
 
 We love contributions! Feel free to open issues for bugs or feature requests.
 
-## Requirements
+# Requirements
 
 - Python 3.11+
 - MCP implementation (like Playwright MCP)
 - LangChain and appropriate model libraries (OpenAI, Anthropic, etc.)
 
-## Citation
+# Citation
 
 If you use MCP-Use in your research or project, please cite:
 
@@ -378,6 +411,6 @@ If you use MCP-Use in your research or project, please cite:
 }
 ```
 
-## License
+# License
 
 MIT

{mcp_use-1.0.1 → mcp_use-1.0.3}/README.md

@@ -307,25 +307,58 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-## Roadmap
+# Tool Access Control
+
+MCP-Use allows you to restrict which tools are available to the agent, providing better security and control over agent capabilities:
+
+```python
+import asyncio
+from mcp_use import MCPAgent, MCPClient
+from langchain_openai import ChatOpenAI
+
+async def main():
+    # Create client
+    client = MCPClient.from_config_file("config.json")
+
+    # Create agent with restricted tools
+    agent = MCPAgent(
+        llm=ChatOpenAI(model="gpt-4"),
+        client=client,
+        disallowed_tools=["file_system", "network"]  # Restrict potentially dangerous tools
+    )
+
+    # Run a query with restricted tool access
+    result = await agent.run(
+        "Find the best restaurant in San Francisco"
+    )
+    print(result)
+
+    # Clean up
+    await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+# Roadmap
 
 <ul>
 <li>[x] Multiple Servers at once </li>
-<li>[ ] Test remote connectors (http, ws)</li>
+<li>[x] Test remote connectors (http, ws)</li>
 <li>[ ] ... </li>
 </ul>
 
-## Contributing
+# Contributing
 
 We love contributions! Feel free to open issues for bugs or feature requests.
 
-## Requirements
+# Requirements
 
 - Python 3.11+
 - MCP implementation (like Playwright MCP)
 - LangChain and appropriate model libraries (OpenAI, Anthropic, etc.)
 
-## Citation
+# Citation
 
 If you use MCP-Use in your research or project, please cite:
 
@@ -339,6 +372,6 @@ If you use MCP-Use in your research or project, please cite:
 }
 ```
 
-## License
+# License
 
 MIT

{mcp_use-1.0.1 → mcp_use-1.0.3}/docs/api-reference/introduction.mdx

@@ -127,24 +127,26 @@ agent = MCPAgent(
     memory_enabled=True,
     system_prompt=None,
     system_prompt_template=None,
-    additional_instructions=None
+    additional_instructions=None,
+    disallowed_tools=None
 )
 ```
 
-| Parameter                 | Type                | Required | Default | Description                                |
-| ------------------------- | ------------------- | -------- | ------- | ------------------------------------------ |
-| `llm`                     | BaseLanguageModel   | Yes      | -       | Any LangChain-compatible language model    |
-| `client`                  | MCPClient           | No       | None    | The MCPClient instance                     |
-| `connectors`              | list[BaseConnector] | No       | None    | List of connectors if not using client     |
-| `server_name`             | str                 | No       | None    | Name of the server to use                  |
-| `max_steps`               | int                 | No       | 5       | Maximum number of steps the agent can take |
-| `auto_initialize`         | bool                | No       | False   | Whether to initialize automatically        |
-| `memory_enabled`          | bool                | No       | True    | Whether to enable memory                   |
-| `system_prompt`           | str                 | No       | None    | Custom system prompt                       |
-| `system_prompt_template`  | str                 | No       | None    | Custom system prompt template              |
-| `additional_instructions` | str                 | No       | None    | Additional instructions for the agent      |
-| `session_options`         | dict                | No       | {}      | Additional options for session creation    |
-| `output_parser`           | OutputParser        | No       | None    | Custom output parser for LLM responses     |
+| Parameter                 | Type                | Required | Default | Description                                                  |
+| ------------------------- | ------------------- | -------- | ------- | ------------------------------------------------------------ |
+| `llm`                     | BaseLanguageModel   | Yes      | -       | Any LangChain-compatible language model                      |
+| `client`                  | MCPClient           | No       | None    | The MCPClient instance                                       |
+| `connectors`              | list[BaseConnector] | No       | None    | List of connectors if not using client                       |
+| `server_name`             | str                 | No       | None    | Name of the server to use                                    |
+| `max_steps`               | int                 | No       | 5       | Maximum number of steps the agent can take                   |
+| `auto_initialize`         | bool                | No       | False   | Whether to initialize automatically                          |
+| `memory_enabled`          | bool                | No       | True    | Whether to enable memory                                     |
+| `system_prompt`           | str                 | No       | None    | Custom system prompt                                         |
+| `system_prompt_template`  | str                 | No       | None    | Custom system prompt template                                |
+| `additional_instructions` | str                 | No       | None    | Additional instructions for the agent                        |
+| `session_options`         | dict                | No       | {}      | Additional options for session creation                      |
+| `output_parser`           | OutputParser        | No       | None    | Custom output parser for LLM responses                       |
+| `disallowed_tools`        | list[str]           | No       | None    | List of tool names that should not be available to the agent |
 
 **When to use different parameters**:
 
@@ -176,6 +178,11 @@ agent = MCPAgent(
 - **session_options**:
   - Customize timeout for long-running server operations
   - Set retry parameters for unstable connections
+- **disallowed_tools**:
+  - Use to restrict which tools the agent can access
+  - Helpful for security or to limit agent capabilities
+  - Useful when certain tools might be dangerous or unnecessary for a specific task
+  - Can be updated after initialization using `set_disallowed_tools()`
 
 ### Core Methods
 
@@ -234,6 +241,39 @@ history = agent.get_history()
 - When implementing custom logging
 - To provide context for follow-up queries
 
+#### set_disallowed_tools
+
+Sets the list of tools that should not be available to the agent.
+
+```python
+agent.set_disallowed_tools(["tool1", "tool2"])
+```
+
+| Parameter          | Type      | Required | Description                                     |
+| ------------------ | --------- | -------- | ----------------------------------------------- |
+| `disallowed_tools` | list[str] | Yes      | List of tool names that should not be available |
+
+**When to use**:
+
+- To restrict access to specific tools for security reasons
+- To limit agent capabilities for specific tasks
+- To prevent the agent from using potentially dangerous tools
+- Note: Changes take effect on next initialization
+
+#### get_disallowed_tools
+
+Gets the list of tools that are not available to the agent.
+
+```python
+disallowed = agent.get_disallowed_tools()
+```
+
+**When to use**:
+
+- To check which tools are currently restricted
+- For debugging or auditing purposes
+- To verify tool restrictions before running the agent
+
 ## Configuration Details
 
 ### MCP Server Configuration Schema
@@ -383,3 +423,34 @@ This approach is useful when:
 - The MCP server returns structured data that needs special handling
 - You need to extract specific information from responses
 - You're integrating with custom or specialized MCP servers
+
+### Restricting Tool Access
+
+Control which tools are available to the agent:
+
+```python
+from mcp_use import MCPAgent, MCPClient
+from langchain_openai import ChatOpenAI
+
+# Create agent with restricted tools
+agent = MCPAgent(
+    llm=ChatOpenAI(model="gpt-4o"),
+    client=client,
+    disallowed_tools=["file_system", "network", "shell"]  # Restrict potentially dangerous tools
+)
+
+# Update restrictions after initialization
+agent.set_disallowed_tools(["file_system", "network", "shell", "database"])
+await agent.initialize()  # Reinitialize to apply changes
+
+# Check current restrictions
+restricted_tools = agent.get_disallowed_tools()
+print(f"Restricted tools: {restricted_tools}")
+```
+
+This approach is useful when:
+
+- You need to restrict access to sensitive operations
+- You want to limit the agent's capabilities for specific tasks
+- You're concerned about security implications of certain tools
+- You want to focus the agent on specific functionality

{mcp_use-1.0.1 → mcp_use-1.0.3}/docs/essentials/configuration.mdx

@@ -96,28 +96,25 @@ Here's a basic example of how to configure an MCP server:
 ### Multiple Server Configuration
 
 You can configure multiple MCP servers in a single configuration file, allowing you to use different servers for different tasks or combine their capabilities (e.g.):
+
 ```json
 {
-        "mcpServers": {
-            "airbnb": {
-                "command": "npx",
-                "args": ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"],
-            },
-            "playwright": {
-                "command": "npx",
-                "args": ["@playwright/mcp@latest"],
-                "env": {"DISPLAY": ":1"},
-            },
-            "filesystem": {
-                "command": "npx",
-                "args": [
-                    "-y",
-                    "@modelcontextprotocol/server-filesystem",
-                    "/home/pietro/projects/mcp-use/",
-                ],
-            },
-        }
+  "mcpServers": {
+    "airbnb": {
+      "command": "npx",
+      "args": ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"]
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"],
+      "env": { "DISPLAY": ":1" }
+    },
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/pietro/projects/mcp-use/"]
     }
+  }
+}
 ```
 
 For a complete example of using multiple servers, see the [multi-server example](https://github.com/pietrozullo/mcp-use/blob/main/examples/multi_server_example.py) in our repository.
@@ -146,7 +143,8 @@ agent = MCPAgent(
     auto_initialize=True,
     memory_enabled=True,
     system_prompt="Custom instructions for the agent",
-    additional_instructions="Additional guidelines for specific tasks"
+    additional_instructions="Additional guidelines for specific tasks",
+    disallowed_tools=["file_system", "network", "shell"]  # Restrict potentially dangerous tools
 )
 ```
 
@@ -162,6 +160,35 @@ agent = MCPAgent(
 - `system_prompt`: Custom system prompt (optional)
 - `system_prompt_template`: Custom system prompt template (optional)
 - `additional_instructions`: Additional instructions for the agent (optional)
+- `disallowed_tools`: List of tool names that should not be available to the agent (optional)
+
+### Tool Access Control
+
+You can restrict which tools are available to the agent for security or to limit its capabilities:
+
+```python
+# Create agent with restricted tools
+agent = MCPAgent(
+    llm=ChatOpenAI(model="gpt-4o"),
+    client=client,
+    disallowed_tools=["file_system", "network", "shell"]  # Restrict potentially dangerous tools
+)
+
+# Update restrictions after initialization
+agent.set_disallowed_tools(["file_system", "network", "shell", "database"])
+await agent.initialize()  # Reinitialize to apply changes
+
+# Check current restrictions
+restricted_tools = agent.get_disallowed_tools()
+print(f"Restricted tools: {restricted_tools}")
+```
+
+This feature is useful for:
+
+- Restricting access to sensitive operations
+- Limiting agent capabilities for specific tasks
+- Preventing the agent from using potentially dangerous tools
+- Focusing the agent on specific functionality
 
 ## Error Handling
 

{mcp_use-1.0.1 → mcp_use-1.0.3}/docs/quickstart.mdx

@@ -82,6 +82,45 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+## Restricting Tool Access
+
+You can control which tools are available to the agent:
+
+```python
+import asyncio
+import os
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from mcp_use import MCPAgent, MCPClient
+
+async def main():
+    # Load environment variables
+    load_dotenv()
+
+    # Create MCPClient from config file
+    client = MCPClient.from_config_file("browser_mcp.json")
+
+    # Create LLM
+    llm = ChatOpenAI(model="gpt-4o")
+
+    # Create agent with restricted tools
+    agent = MCPAgent(
+        llm=llm,
+        client=client,
+        max_steps=30,
+        disallowed_tools=["file_system", "network"]  # Restrict potentially dangerous tools
+    )
+
+    # Run the query
+    result = await agent.run(
+        "Find the best restaurant in San Francisco USING GOOGLE SEARCH",
+    )
+    print(f"\nResult: {result}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
 ## Available MCP Servers
 
 mcp_use supports various MCP servers:

{mcp_use-1.0.1 → mcp_use-1.0.3}/mcp_use/agents/langchain_agent.py

@@ -82,6 +82,7 @@ class LangChainAgent:
         llm: BaseLanguageModel,
         max_steps: int = 5,
         system_message: str | None = None,
+        disallowed_tools: list[str] | None = None,
     ) -> None:
         """Initialize a new LangChain agent.
 
@@ -90,11 +91,13 @@ class LangChainAgent:
             llm: The LangChain LLM to use.
             max_steps: The maximum number of steps to take.
             system_message: Optional custom system message to use.
+            disallowed_tools: List of tool names that should not be available to the agent.
         """
         self.connectors = connectors
         self.llm = llm
         self.max_steps = max_steps
         self.system_message = system_message or self.DEFAULT_SYSTEM_MESSAGE
+        self.disallowed_tools = disallowed_tools or []
         self.tools: list[BaseTool] = []
         self.agent: AgentExecutor | None = None
 
@@ -137,17 +140,16 @@ class LangChainAgent:
         """Create LangChain tools from MCP tools.
 
         Returns:
-            A list of LangChain tools created from MCP tools.
+            A list of LangChain tools that wrap MCP tools.
         """
-        langchain_tools: list[BaseTool] = []
-
+        tools = []
         for connector in self.connectors:
-            tools = connector.tools
-            local_connector = connector
+            local_connector = connector  # Capture for closure
+            for tool in connector.tools:
+                # Skip disallowed tools
+                if tool.name in self.disallowed_tools:
+                    continue
 
-            # Wrap MCP tools into LangChain tools
-            for tool in tools:
-                # Define adapter class to convert MCP tool to LangChain format
                 class McpToLangChainAdapter(BaseTool):
                     name: str = tool.name or "NO NAME"
                     description: str = tool.description or ""
@@ -202,11 +204,11 @@ class LangChainAgent:
                                 return f"Error executing MCP tool: {str(e)}"
                             raise
 
-                langchain_tools.append(McpToLangChainAdapter())
+                tools.append(McpToLangChainAdapter())
 
         # Log available tools for debugging
-        logger.info(f"Available tools: {[tool.name for tool in langchain_tools]}")
-        return langchain_tools
+        logger.info(f"Available tools: {[tool.name for tool in tools]}")
+        return tools
 
     def _create_agent(self) -> AgentExecutor:
         """Create the LangChain agent with the configured system message.

{mcp_use-1.0.1 → mcp_use-1.0.3}/mcp_use/agents/mcpagent.py

@@ -39,6 +39,7 @@ class MCPAgent:
         system_prompt: str | None = None,
         system_prompt_template: str | None = None,
         additional_instructions: str | None = None,
+        disallowed_tools: list[str] | None = None,
     ):
         """Initialize a new MCPAgent instance.
 
@@ -53,6 +54,7 @@ class MCPAgent:
             system_prompt: Complete system prompt to use (overrides template if provided).
             system_prompt_template: Template for system prompt with {tool_descriptions} placeholder.
             additional_instructions: Extra instructions to append to the system prompt.
+            disallowed_tools: List of tool names that should not be available to the agent.
         """
         self.llm = llm
         self.client = client
@@ -63,6 +65,7 @@ class MCPAgent:
         self.memory_enabled = memory_enabled
         self._initialized = False
         self._conversation_history: list[BaseMessage] = []
+        self.disallowed_tools = disallowed_tools or []
 
         # System prompt configuration
         self.system_prompt = system_prompt
@@ -102,6 +105,7 @@ class MCPAgent:
             llm=self.llm,
             max_steps=self.max_steps,
             system_message=(self._system_message.content if self._system_message else None),
+            disallowed_tools=self.disallowed_tools,
         )
 
         # Initialize the agent
@@ -125,6 +129,10 @@ class MCPAgent:
             tools = connector.tools
             # Generate tool descriptions
             for tool in tools:
+                # Skip disallowed tools
+                if tool.name in self.disallowed_tools:
+                    continue
+
                 # Escape curly braces in the description by doubling them
                 # (sometimes e.g. blender mcp they are used in the description)
                 description = (
@@ -188,6 +196,33 @@ class MCPAgent:
         if self._agent:
             self._agent.set_system_message(message)
 
+    def set_disallowed_tools(self, disallowed_tools: list[str]) -> None:
+        """Set the list of tools that should not be available to the agent.
+
+        This will take effect the next time the agent is initialized.
+
+        Args:
+            disallowed_tools: List of tool names that should not be available.
+        """
+        self.disallowed_tools = disallowed_tools
+
+        # If the agent is already initialized, we need to reinitialize it
+        # to apply the changes to the available tools
+        if self._initialized:
+            logger.info(
+                "Agent already initialized. Changes will take effect on next initialization."
+            )
+            # We don't automatically reinitialize here as it could be disruptive
+            # to ongoing operations. The user can call initialize() explicitly if needed.
+
+    def get_disallowed_tools(self) -> list[str]:
+        """Get the list of tools that are not available to the agent.
+
+        Returns:
+            List of tool names that are not available.
+        """
+        return self.disallowed_tools
+
     async def run(
         self,
         query: str,

{mcp_use-1.0.1 → mcp_use-1.0.3}/mcp_use/connectors/http.py

@@ -54,7 +54,7 @@ class HttpConnector(BaseConnector):
         logger.info(f"Connecting to MCP implementation via HTTP/SSE: {self.base_url}")
         try:
             # Create the SSE connection URL
-            sse_url = f"{self.base_url}/sse"
+            sse_url = f"{self.base_url}"
 
             # Create and start the connection manager
             self._connection_manager = SseConnectionManager(

{mcp_use-1.0.1 → mcp_use-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-use"
-version = "1.0.1"
+version = "1.0.3"
 description = "MCP Library for LLMs"
 authors = [
     {name = "Pietro Zullo", email = "pietro.zullo@gmail.com"}

{mcp_use-1.0.1 → mcp_use-1.0.3}/tests/unit/test_http_connector.py

@@ -111,7 +111,7 @@ class TestHttpConnectorConnection(IsolatedAsyncioTestCase):
         await self.connector.connect()
 
         # Verify connection manager was created and started
-        mock_cm_class.assert_called_once_with("http://localhost:8000/sse", {}, 5, 300)
+        mock_cm_class.assert_called_once_with("http://localhost:8000", {}, 5, 300)
         mock_cm_instance.start.assert_called_once()
 
         # Verify client session was created