mcp-use 0.1.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

mcp_use/task_managers/sse.py

@@ -0,0 +1,82 @@
+"""
+SSE connection management for MCP implementations.
+
+This module provides a connection manager for SSE-based MCP connections
+that ensures proper task isolation and resource cleanup.
+"""
+
+from typing import Any
+
+from mcp.client.sse import sse_client
+
+from ..logging import logger
+from .base import ConnectionManager
+
+
+class SseConnectionManager(ConnectionManager[tuple[Any, Any]]):
+    """Connection manager for SSE-based MCP connections.
+
+    This class handles the proper task isolation for sse_client context managers
+    to prevent the "cancel scope in different task" error. It runs the sse_client
+    in a dedicated task and manages its lifecycle.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        timeout: float = 5,
+        sse_read_timeout: float = 60 * 5,
+    ):
+        """Initialize a new SSE connection manager.
+
+        Args:
+            url: The SSE endpoint URL
+            headers: Optional HTTP headers
+            timeout: Timeout for HTTP operations in seconds
+            sse_read_timeout: Timeout for SSE read operations in seconds
+        """
+        super().__init__()
+        self.url = url
+        self.headers = headers or {}
+        self.timeout = timeout
+        self.sse_read_timeout = sse_read_timeout
+        self._sse_ctx = None
+
+    async def _establish_connection(self) -> tuple[Any, Any]:
+        """Establish an SSE connection.
+
+        Returns:
+            A tuple of (read_stream, write_stream)
+
+        Raises:
+            Exception: If connection cannot be established.
+        """
+        # Create the context manager
+        self._sse_ctx = sse_client(
+            url=self.url,
+            headers=self.headers,
+            timeout=self.timeout,
+            sse_read_timeout=self.sse_read_timeout,
+        )
+
+        # Enter the context manager
+        read_stream, write_stream = await self._sse_ctx.__aenter__()
+
+        # Return the streams
+        return (read_stream, write_stream)
+
+    async def _close_connection(self, connection: tuple[Any, Any]) -> None:
+        """Close the SSE connection.
+
+        Args:
+            connection: The connection to close (ignored, we use the context manager)
+        """
+        if self._sse_ctx:
+            # Exit the context manager
+            try:
+                await self._sse_ctx.__aexit__(None, None, None)
+            except Exception as e:
+                logger.warning(f"Error closing SSE context: {e}")
+            finally:
+                self._sse_ctx = None

mcp_use/task_managers/stdio.py

@@ -0,0 +1,73 @@
+"""
+StdIO connection management for MCP implementations.
+
+This module provides a connection manager for stdio-based MCP connections
+that ensures proper task isolation and resource cleanup.
+"""
+
+import sys
+from typing import Any, TextIO
+
+from mcp import StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from ..logging import logger
+from .base import ConnectionManager
+
+
+class StdioConnectionManager(ConnectionManager[tuple[Any, Any]]):
+    """Connection manager for stdio-based MCP connections.
+
+    This class handles the proper task isolation for stdio_client context managers
+    to prevent the "cancel scope in different task" error. It runs the stdio_client
+    in a dedicated task and manages its lifecycle.
+    """
+
+    def __init__(
+        self,
+        server_params: StdioServerParameters,
+        errlog: TextIO = sys.stderr,
+    ):
+        """Initialize a new stdio connection manager.
+
+        Args:
+            server_params: The parameters for the stdio server
+            errlog: The error log stream
+        """
+        super().__init__()
+        self.server_params = server_params
+        self.errlog = errlog
+        self._stdio_ctx = None
+
+    async def _establish_connection(self) -> tuple[Any, Any]:
+        """Establish a stdio connection.
+
+        Returns:
+            A tuple of (read_stream, write_stream)
+
+        Raises:
+            Exception: If connection cannot be established.
+        """
+        # Create the context manager
+        self._stdio_ctx = stdio_client(self.server_params, self.errlog)
+
+        # Enter the context manager
+        read_stream, write_stream = await self._stdio_ctx.__aenter__()
+
+        # Return the streams
+        return (read_stream, write_stream)
+
+    async def _close_connection(self, connection: tuple[Any, Any]) -> None:
+        """Close the stdio connection.
+
+        Args:
+            connection: The connection to close (ignored, we use the context manager)
+        """
+        if self._stdio_ctx:
+            # Exit the context manager
+            try:
+                await self._stdio_ctx.__aexit__(None, None, None)
+            except Exception as e:
+                logger.warning(f"Error closing stdio context: {e}")
+            finally:
+                self._stdio_ctx = None

mcp_use/task_managers/websocket.py

@@ -0,0 +1,63 @@
+"""
+WebSocket connection management for MCP implementations.
+
+This module provides a connection manager for WebSocket-based MCP connections.
+"""
+
+import websockets
+from websockets.client import ClientConnection
+
+from ..logging import logger
+from .base import ConnectionManager
+
+
+class WebSocketConnectionManager(ConnectionManager[ClientConnection]):
+    """Connection manager for WebSocket-based MCP connections.
+
+    This class handles the lifecycle of WebSocket connections, ensuring proper
+    connection establishment and cleanup.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+    ):
+        """Initialize a new WebSocket connection manager.
+
+        Args:
+            url: The WebSocket URL to connect to
+            headers: Optional headers to include in the WebSocket connection
+        """
+        super().__init__()
+        self.url = url
+        self.headers = headers or {}
+
+    async def _establish_connection(self) -> ClientConnection:
+        """Establish a WebSocket connection.
+
+        Returns:
+            The established WebSocket connection
+
+        Raises:
+            Exception: If connection cannot be established
+        """
+        logger.debug(f"Connecting to WebSocket: {self.url}")
+        try:
+            ws = await websockets.connect(self.url, extra_headers=self.headers)
+            return ws
+        except Exception as e:
+            logger.error(f"Failed to connect to WebSocket: {e}")
+            raise
+
+    async def _close_connection(self, connection: ClientConnection) -> None:
+        """Close the WebSocket connection.
+
+        Args:
+            connection: The WebSocket connection to close
+        """
+        try:
+            logger.debug("Closing WebSocket connection")
+            await connection.close()
+        except Exception as e:
+            logger.warning(f"Error closing WebSocket connection: {e}")

mcp_use-1.0.1.dist-info/METADATA

@@ -0,0 +1,383 @@
+Metadata-Version: 2.4
+Name: mcp-use
+Version: 1.0.1
+Summary: MCP Library for LLMs
+Author-email: Pietro Zullo <pietro.zullo@gmail.com>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: jsonschema-pydantic>=0.1.0
+Requires-Dist: langchain-community>=0.0.10
+Requires-Dist: langchain>=0.1.0
+Requires-Dist: mcp
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: typing-extensions>=4.8.0
+Requires-Dist: websockets>=12.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.15.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: black>=23.9.0; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: mypy>=1.5.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.10.0; extra == 'openai'
+Description-Content-Type: text/markdown
+
+<picture>
+  <img alt="" src="./static/image.jpg"  width="full">
+</picture>
+
+<h1 align="center">Open Source MCP CLient Library </h1>
+
+[![](https://img.shields.io/pypi/dd/mcp_use.svg)](https://pypi.org/project/mcp_use/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/mcp_use.svg)](https://pypi.org/project/mcp_use/)
+[![PyPI Version](https://img.shields.io/pypi/v/mcp_use.svg)](https://pypi.org/project/mcp_use/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/mcp_use.svg)](https://pypi.org/project/mcp_use/)
+[![Documentation](https://img.shields.io/badge/docs-mcp--use.io-blue)](https://docs.mcp-use.io)
+[![License](https://img.shields.io/github/license/pietrozullo/mcp-use)](https://github.com/pietrozullo/mcp-use/blob/main/LICENSE)
+[![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
+[![GitHub stars](https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social)](https://github.com/pietrozullo/mcp-use/stargazers)
+
+🌐 MCP-Use is the open source way to connect any LLM to MCP tools and build custom agents that have tool access, without using closed source or application clients.
+
+💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.
+
+# Quick start
+
+With pip:
+
+```bash
+pip install mcp-use
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/pietrozullo/mcp-use.git
+cd mcp-use
+pip install -e .
+```
+
+Spin up your 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 the client
+    agent = MCPAgent(llm=llm, client=client, max_steps=30)
+
+    # 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())
+```
+
+Example configuration file (`browser_mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"],
+      "env": {
+        "DISPLAY": ":1"
+      }
+    }
+  }
+}
+```
+
+Add your API keys for the provider you want to use to your `.env` file.
+
+```bash
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=
+```
+
+For other settings, models, and more, check out the documentation.
+
+# Example Use Cases
+
+## Web Browsing with Playwright
+
+```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(
+        os.path.join(os.path.dirname(__file__), "browser_mcp.json")
+    )
+
+    # Create LLM
+    llm = ChatOpenAI(model="gpt-4o")
+    # Alternative models:
+    # llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")
+    # llm = ChatGroq(model="llama3-8b-8192")
+
+    # Create agent with the client
+    agent = MCPAgent(llm=llm, client=client, max_steps=30)
+
+    # Run the query
+    result = await agent.run(
+        "Find the best restaurant in San Francisco USING GOOGLE SEARCH",
+        max_steps=30,
+    )
+    print(f"\nResult: {result}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Airbnb Search
+
+```python
+import asyncio
+import os
+from dotenv import load_dotenv
+from langchain_anthropic import ChatAnthropic
+from mcp_use import MCPAgent, MCPClient
+
+async def run_airbnb_example():
+    # Load environment variables
+    load_dotenv()
+
+    # Create MCPClient with Airbnb configuration
+    client = MCPClient.from_config_file(
+        os.path.join(os.path.dirname(__file__), "airbnb_mcp.json")
+    )
+
+    # Create LLM - you can choose between different models
+    llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")
+
+    # Create agent with the client
+    agent = MCPAgent(llm=llm, client=client, max_steps=30)
+
+    try:
+        # Run a query to search for accommodations
+        result = await agent.run(
+            "Find me a nice place to stay in Barcelona for 2 adults "
+            "for a week in August. I prefer places with a pool and "
+            "good reviews. Show me the top 3 options.",
+            max_steps=30,
+        )
+        print(f"\nResult: {result}")
+    finally:
+        # Ensure we clean up resources properly
+        if client.sessions:
+            await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(run_airbnb_example())
+```
+
+Example configuration file (`airbnb_mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "airbnb": {
+      "command": "npx",
+      "args": ["-y", "@openbnb/mcp-server-airbnb"]
+    }
+  }
+}
+```
+
+## Blender 3D Creation
+
+```python
+import asyncio
+from dotenv import load_dotenv
+from langchain_anthropic import ChatAnthropic
+from mcp_use import MCPAgent, MCPClient
+
+async def run_blender_example():
+    # Load environment variables
+    load_dotenv()
+
+    # Create MCPClient with Blender MCP configuration
+    config = {"mcpServers": {"blender": {"command": "uvx", "args": ["blender-mcp"]}}}
+    client = MCPClient.from_dict(config)
+
+    # Create LLM
+    llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")
+
+    # Create agent with the client
+    agent = MCPAgent(llm=llm, client=client, max_steps=30)
+
+    try:
+        # Run the query
+        result = await agent.run(
+            "Create an inflatable cube with soft material and a plane as ground.",
+            max_steps=30,
+        )
+        print(f"\nResult: {result}")
+    finally:
+        # Ensure we clean up resources properly
+        if client.sessions:
+            await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(run_blender_example())
+```
+
+# Configuration File Support
+
+MCP-Use supports initialization from configuration files, making it easy to manage and switch between different MCP server setups:
+
+```python
+import asyncio
+from mcp_use import create_session_from_config
+
+async def main():
+    # Create an MCP session from a config file
+    session = create_session_from_config("mcp-config.json")
+
+    # Initialize the session
+    await session.initialize()
+
+    # Use the session...
+
+    # Disconnect when done
+    await session.disconnect()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+# Multi-Server Support
+
+MCP-Use supports working with multiple MCP servers simultaneously, allowing you to combine tools from different servers in a single agent. This is useful for complex tasks that require multiple capabilities, such as web browsing combined with file operations or 3D modeling.
+
+## Configuration
+
+You can configure multiple servers in your configuration file:
+
+```json
+{
+  "mcpServers": {
+    "airbnb": {
+      "command": "npx",
+      "args": ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"]
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"],
+      "env": {
+        "DISPLAY": ":1"
+      }
+    }
+  }
+}
+```
+
+## Usage
+
+The `MCPClient` class provides several methods for managing multiple servers:
+
+```python
+import asyncio
+from mcp_use import MCPClient, MCPAgent
+from langchain_anthropic import ChatAnthropic
+
+async def main():
+    # Create client with multiple servers
+    client = MCPClient.from_config_file("multi_server_config.json")
+
+    # Create agent with the client
+    agent = MCPAgent(
+        llm=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+        client=client
+    )
+
+    try:
+        # Run a query that uses tools from multiple servers
+        result = await agent.run(
+            "Search for a nice place to stay in Barcelona on Airbnb, "
+            "then use Google to find nearby restaurants and attractions."
+        )
+        print(result)
+    finally:
+        # Clean up all sessions
+        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>[ ] ... </li>
+</ul>
+
+## Contributing
+
+We love contributions! Feel free to open issues for bugs or feature requests.
+
+## Requirements
+
+- Python 3.11+
+- MCP implementation (like Playwright MCP)
+- LangChain and appropriate model libraries (OpenAI, Anthropic, etc.)
+
+## Citation
+
+If you use MCP-Use in your research or project, please cite:
+
+```bibtex
+@software{mcp_use2025,
+  author = {Zullo, Pietro},
+  title = {MCP-Use: MCP Library for Python},
+  year = {2025},
+  publisher = {GitHub},
+  url = {https://github.com/pietrozullo/mcp-use}
+}
+```
+
+## License
+
+MIT

mcp_use-1.0.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+mcp_use/__init__.py,sha256=PSoxLAu1GPjfIDPcZiJyI3k66MMS3lcfx5kERUgFb1o,723
+mcp_use/client.py,sha256=0rvlJBwvPD19sjDRtXfnp15-F1VHJlXWxLQNt9cHwPA,8275
+mcp_use/config.py,sha256=O9V4pa-shZ2mPokRTrd7KZQ2GpuTcYBGUslefl1fosw,1653
+mcp_use/logging.py,sha256=2-hSB7ZWcHEx_OFHNg8GIbSGCZx3MW4mZGGWxi2Ew3E,2690
+mcp_use/session.py,sha256=Z4EZTUnQUX0QyGMzkJIrMRTX4SDk6qQUoBld408LIJE,3449
+mcp_use/agents/__init__.py,sha256=ukchMTqCOID6ikvLmJ-6sldWTVFIzztGQo4BX6QeQr8,312
+mcp_use/agents/base.py,sha256=bfuldi_89AbSbNc8KeTiCArRT9V62CNxHOWYkLHWjyA,1605
+mcp_use/agents/langchain_agent.py,sha256=q6zIb9J9fc15HRGDjPAhmPdM_8UOqQToy8ESeyry1kc,10035
+mcp_use/agents/mcpagent.py,sha256=lTRutdT1QIMiTbMSKfSbqlqNq_Y6uDPfkjAzJAKb6H0,12727
+mcp_use/agents/prompts/default.py,sha256=tnwt9vOiVBhdpu-lIHhwEJo3rvE6EobPfUgS9JURBzg,941
+mcp_use/connectors/__init__.py,sha256=jnd-7pPPJMb0UNJ6aD9lInj5Tlamc8lA_mFyG8RWJpo,385
+mcp_use/connectors/base.py,sha256=TCLVNJdt6qrflmphgXOZhD6xPKQQegbGqe5REmcLYg0,4813
+mcp_use/connectors/http.py,sha256=vNrVOjO_7SLJv_G6Gio3moRu11omKY6nM3_34yUMpew,2839
+mcp_use/connectors/stdio.py,sha256=36yEY7hbFXgM7zju5BtLJl4cKAZNCXVRrTaU6YOttBI,2606
+mcp_use/connectors/websocket.py,sha256=4xqxl9UncrfU6NitvKfB80Hk2g7o0Gc0G5sm6sY3RAk,9534
+mcp_use/task_managers/__init__.py,sha256=4dgW5N61iiPLpwjU2rrn_uqrL8mmDJFDaF9Lukzk65A,486
+mcp_use/task_managers/base.py,sha256=ksNdxTwq8N-zqymxVoKGnWXq9iqkLYC61uB91o6Mh-4,4888
+mcp_use/task_managers/sse.py,sha256=WysmjwqRI3meXMZY_F4y9tSBMvSiUZfTJQfitM5l6jQ,2529
+mcp_use/task_managers/stdio.py,sha256=DEISpXv4mo3d5a-WT8lkWbrXJwUh7QW0nMT_IM3fHGg,2269
+mcp_use/task_managers/websocket.py,sha256=ZbCqdGgzCRtsXzRGFws-f2OzH8cPAkN4sJNDwEpRmCc,1915
+mcp_use-1.0.1.dist-info/METADATA,sha256=BZm7Zn7K33DKE2fLzRgDPl-oTpQRAuKW3ssxNkpEsxA,10203
+mcp_use-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.0.1.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.0.1.dist-info/RECORD,,

{mcp_use-0.1.0.dist-info → mcp_use-1.0.1.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

mcp_use/tools/__init__.py

@@ -1,11 +0,0 @@
-"""
-Tool conversion utilities.
-
-This module provides utilities for converting between MCP tool schemas
-and LLM-specific tool formats.
-"""
-
-from .converter import ToolConverter
-from .formats import AnthropicToolFormat, OpenAIToolFormat, ToolFormat
-
-__all__ = ["ToolConverter", "ToolFormat", "OpenAIToolFormat", "AnthropicToolFormat"]