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

mcp_use-1.0.0.dist-info/METADATA

@@ -0,0 +1,382 @@
+Metadata-Version: 2.4
+Name: mcp-use
+Version: 1.0.0
+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/mcpusegrass.png"  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/)
+[![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.0.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=D9LuCuT1mFUSBiO2DUGa5Pnd-yjNcvM9u_v11N5UmK8,1624
+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=caUaTfsODUOik8JF9mPtcZDyZhoIz2X12I_BhAfZK10,1616
+mcp_use/connectors/http.py,sha256=KqVf0HXouFoeQ_bBUr6KQifiUjTo7K6EOCRkqVpFx4Q,7763
+mcp_use/connectors/stdio.py,sha256=aEeZ-OZS6yknFPEy-YpwvwFILGIaAsA48uB1I4j8wog,6752
+mcp_use/connectors/websocket.py,sha256=4xqxl9UncrfU6NitvKfB80Hk2g7o0Gc0G5sm6sY3RAk,9534
+mcp_use/task_managers/__init__.py,sha256=6VVe5ceSxXmQvBpjH-6aFud5dRJMNA6pu0qpAnfxpIA,460
+mcp_use/task_managers/base.py,sha256=ksNdxTwq8N-zqymxVoKGnWXq9iqkLYC61uB91o6Mh-4,4888
+mcp_use/task_managers/http.py,sha256=XhrF73RGRnVctBVW2FlFrFTJR2pIGXhtNvfJFiW0Olw,1881
+mcp_use/task_managers/stdio.py,sha256=DEISpXv4mo3d5a-WT8lkWbrXJwUh7QW0nMT_IM3fHGg,2269
+mcp_use/task_managers/websocket.py,sha256=SVgTLFogiynb48eyi6ZioWIKLLWiVBCNE59rXi6GrCM,1943
+mcp_use-1.0.0.dist-info/METADATA,sha256=SutQOwdz5oeqwsqGZJEgALeYG3evLZ8pNabca1lJppw,10113
+mcp_use-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.0.0.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.0.0.dist-info/RECORD,,

{mcp_use-0.1.0.dist-info → mcp_use-1.0.0.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"]

mcp_use/tools/converter.py

@@ -1,108 +0,0 @@
-"""
-Tool converter for different LLM providers.
-
-This module provides utilities for converting between MCP tool schemas
-and LLM-specific formats.
-"""
-
-from enum import Enum, auto
-from typing import Any
-
-from .formats import AnthropicToolFormat, OpenAIToolFormat, ToolFormat
-
-
-class ModelProvider(Enum):
-    """Enum for supported model providers."""
-
-    OPENAI = auto()
-    ANTHROPIC = auto()
-
-    @classmethod
-    def from_string(cls, value: str) -> "ModelProvider":
-        """Convert a string to a ModelProvider enum.
-
-        Args:
-            value: The string to convert.
-
-        Returns:
-            The corresponding ModelProvider enum value.
-
-        Raises:
-            ValueError: If the string is not a valid model provider.
-        """
-        value = value.lower()
-        if value in ("openai", "open_ai", "open-ai"):
-            return cls.OPENAI
-        elif value in ("anthropic", "claude"):
-            return cls.ANTHROPIC
-        else:
-            raise ValueError(f"Unsupported model provider: {value}")
-
-
-class ToolConverter:
-    """Converter for MCP tools to different LLM formats.
-
-    This class provides utilities for converting between MCP tool schemas
-    and LLM-specific formats.
-    """
-
-    _format_classes: dict[ModelProvider, type[ToolFormat]] = {
-        ModelProvider.OPENAI: OpenAIToolFormat,
-        ModelProvider.ANTHROPIC: AnthropicToolFormat,
-    }
-
-    def __init__(self, provider: str | ModelProvider) -> None:
-        """Initialize a new tool converter.
-
-        Args:
-            provider: The model provider to convert tools for.
-                Can be a string or a ModelProvider enum.
-
-        Raises:
-            ValueError: If the provider is not supported.
-        """
-        if isinstance(provider, str):
-            self.provider = ModelProvider.from_string(provider)
-        else:
-            self.provider = provider
-
-        # Create an instance of the appropriate format class
-        format_class = self._format_classes.get(self.provider)
-        if not format_class:
-            raise ValueError(f"Unsupported model provider: {provider}")
-
-        self._format = format_class()
-
-    def convert_tools(self, tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        """Convert a list of MCP tools to the LLM-specific format.
-
-        Args:
-            tools: The list of MCP tools to convert.
-
-        Returns:
-            The converted tools in the LLM-specific format.
-        """
-        return [self._format.convert_tool(tool) for tool in tools]
-
-    def convert_tool_call(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
-        """Convert a tool call to the MCP format.
-
-        Args:
-            name: The name of the tool being called.
-            arguments: The arguments for the tool call.
-
-        Returns:
-            The converted tool call in the MCP format.
-        """
-        return self._format.convert_tool_call(name, arguments)
-
-    def parse_tool_calls(self, response: dict[str, Any]) -> list[dict[str, Any]]:
-        """Parse tool calls from an LLM response.
-
-        Args:
-            response: The response from the LLM.
-
-        Returns:
-            A list of parsed tool calls, each containing 'name' and 'arguments' keys.
-        """
-        return self._format.parse_tool_call(response)