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

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)

mcp_use/tools/formats.py

@@ -1,181 +0,0 @@
-"""
-Tool format definitions for different LLM providers.
-
-This module provides type definitions and interfaces for converting
-MCP tool schemas to formats required by different LLM providers.
-"""
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-
-class ToolFormat(ABC):
-    """Base class for LLM tool formats.
-
-    This abstract class defines the interface for converting MCP tool schemas
-    to the format required by a specific LLM provider.
-    """
-
-    @abstractmethod
-    def convert_tool(self, tool: dict[str, Any]) -> dict[str, Any]:
-        """Convert an MCP tool schema to the LLM-specific format.
-
-        Args:
-            tool: The MCP tool schema to convert.
-
-        Returns:
-            The converted tool in the LLM-specific format.
-        """
-        pass
-
-    @abstractmethod
-    def convert_tool_call(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
-        """Convert a tool call from the LLM format 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.
-        """
-        pass
-
-    @abstractmethod
-    def parse_tool_call(self, response: dict[str, Any]) -> list[dict[str, Any]]:
-        """Parse tool calls from the LLM response.
-
-        Args:
-            response: The response from the LLM.
-
-        Returns:
-            A list of parsed tool calls, each containing 'name' and 'arguments' keys.
-        """
-        pass
-
-
-class OpenAIToolFormat(ToolFormat):
-    """Tool format for OpenAI models.
-
-    This class converts between MCP tool schemas and the format required by
-    OpenAI's function calling API.
-    """
-
-    def convert_tool(self, tool: dict[str, Any]) -> dict[str, Any]:
-        """Convert an MCP tool schema to the OpenAI function format.
-
-        Args:
-            tool: The MCP tool schema to convert.
-
-        Returns:
-            The converted tool in the OpenAI function format.
-        """
-        return {
-            "type": "function",
-            "function": {
-                "name": tool["name"],
-                "description": tool.get("description", ""),
-                "parameters": tool.get("inputSchema", {}),
-            },
-        }
-
-    def convert_tool_call(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
-        """Convert a tool call from the OpenAI format 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 {"name": name, "arguments": arguments}
-
-    def parse_tool_call(self, response: dict[str, Any]) -> list[dict[str, Any]]:
-        """Parse tool calls from the OpenAI response.
-
-        Args:
-            response: The response from OpenAI.
-
-        Returns:
-            A list of parsed tool calls, each containing 'name' and 'arguments' keys.
-        """
-        tool_calls = []
-
-        # Navigate through the response structure to find tool calls
-        for message in response.get("choices", [{}])[0].get("message", {}).get("tool_calls", []):
-            if message.get("type") == "function":
-                function = message.get("function", {})
-                name = function.get("name", "")
-
-                # Parse the arguments
-                arguments = {}
-                args_str = function.get("arguments", "{}")
-                try:
-                    import json
-
-                    arguments = json.loads(args_str)
-                except Exception:
-                    pass
-
-                tool_calls.append({"name": name, "arguments": arguments})
-
-        return tool_calls
-
-
-class AnthropicToolFormat(ToolFormat):
-    """Tool format for Anthropic models.
-
-    This class converts between MCP tool schemas and the format required by
-    Anthropic's tool use API.
-    """
-
-    def convert_tool(self, tool: dict[str, Any]) -> dict[str, Any]:
-        """Convert an MCP tool schema to the Anthropic tool format.
-
-        Args:
-            tool: The MCP tool schema to convert.
-
-        Returns:
-            The converted tool in the Anthropic tool format.
-        """
-        return {
-            "name": tool["name"],
-            "description": tool.get("description", ""),
-            "input_schema": tool.get("inputSchema", {}),
-        }
-
-    def convert_tool_call(self, name: str, arguments: dict[str, Any]) -> dict[str, Any]:
-        """Convert a tool call from the Anthropic format 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 {"name": name, "arguments": arguments}
-
-    def parse_tool_call(self, response: dict[str, Any]) -> list[dict[str, Any]]:
-        """Parse tool calls from the Anthropic response.
-
-        Args:
-            response: The response from Anthropic.
-
-        Returns:
-            A list of parsed tool calls, each containing 'name' and 'arguments' keys.
-        """
-        tool_calls = []
-
-        # Navigate through the response structure to find tool calls
-        content_blocks = response.get("content", [])
-        for block in content_blocks:
-            if block.get("type") == "tool_use":
-                tool_use = block.get("tool_use", {})
-                name = tool_use.get("name", "")
-                arguments = tool_use.get("input", {})
-
-                tool_calls.append({"name": name, "arguments": arguments})
-
-        return tool_calls

mcp_use/types.py

@@ -1,33 +0,0 @@
-"""
-Type definitions for the mcp_use package.
-
-This module provides type definitions used throughout the mcp_use package.
-"""
-
-from typing import Any
-
-from pydantic import BaseModel
-
-
-class Tool(BaseModel):
-    """MCP Tool definition."""
-
-    name: str
-    description: str | None = None
-    inputSchema: dict[str, Any] = {}
-    outputSchema: dict[str, Any] | None = None
-
-
-class TextContent(BaseModel):
-    """Text content returned by an MCP tool."""
-
-    type: str = "text"
-    text: str
-    mime_type: str | None = "text/plain"
-
-
-class ToolResult(BaseModel):
-    """Result of a tool execution."""
-
-    content: list[TextContent | dict[str, Any]]
-    isError: bool = False

mcp_use-0.1.0.dist-info/METADATA

@@ -1,287 +0,0 @@
-Metadata-Version: 2.4
-Name: mcp_use
-Version: 0.1.0
-Summary: Model-Agnostic MCP Library for LLMs
-Home-page: https://github.com/pietrozullo/mcp_use
-Author: Pietro Zullo
-Author-email: pietro.zullo@gmail.com
-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
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: mcp
-Requires-Dist: langchain>=0.1.0
-Requires-Dist: langchain-community>=0.0.10
-Requires-Dist: websockets>=12.0
-Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: typing-extensions>=4.8.0
-Requires-Dist: jsonschema-pydantic>=0.1.0
-Requires-Dist: python-dotenv>=1.0.0
-Provides-Extra: dev
-Requires-Dist: pytest>=7.4.0; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: pytest-cov>=4.1.0; 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: ruff>=0.1.0; extra == "dev"
-Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.15.0; extra == "anthropic"
-Provides-Extra: openai
-Requires-Dist: openai>=1.10.0; extra == "openai"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Model-Agnostic MCP Library for LLMs
-
-A Python library that lets any LLM (Language Learning Model) use MCP (Multi-Channel Platform) tools through a unified interface. The goal is to let developers easily connect any LLM to tools like web browsing, file operations, etc.
-
-## Core Concept
-
-- Leverage existing LangChain adapters rather than reinventing them
-- Focus on bridging MCPs and LangChain's tool ecosystem
-
-## Key Components
-
-### Connectors
-
-Bridge to MCP implementations:
-
-- `stdio.py`: For local MCP processes
-- `websocket.py`: For remote WebSocket MCPs
-- `http.py`: For HTTP API MCPs
-
-### Tool Conversion
-
-Convert between MCP and LangChain formats:
-
-- Convert MCP tool schemas to formats needed by different LLMs
-- Support OpenAI function calling, Anthropic tool format, etc.
-
-### Session Management
-
-Handle connection lifecycle:
-
-- Authenticate and initialize MCP connections
-- Discover and register available tools
-- Handle tool calling with proper error management
-
-### Agent Integration
-
-Ready-to-use agent implementations:
-
-- Pre-configured for MCP tool usage
-- Optimized prompts for tool selection
-
-## Installation
-
-```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 .
-```
-
-## Quick Start
-
-Here's a simple example to get you started:
-
-```python
-import asyncio
-from mcp import StdioServerParameters
-from mcp_use import MCPAgent
-
-async def main():
-    # Create server parameters for stdio connection
-    server_params = StdioServerParameters(
-        command="npx",
-        args=["@playwright/mcp@latest"],
-    )
-
-    # Create a model-agnostic MCP client
-    mcp_client = MCPAgent(
-        server_params=server_params,
-        model_provider="anthropic",  # Or "openai"
-        model_name="claude-3-7-sonnet-20250219",  # Or "gpt-4o" for OpenAI
-        temperature=0.7
-    )
-
-    # Initialize the client
-    await mcp_client.initialize()
-
-    # Run a query using the agent with tools
-    result = await mcp_client.run_query(
-        "Using internet tell me how many people work at OpenAI"
-    )
-
-    print("Result:")
-    print(result)
-
-    # Close the client
-    await mcp_client.close()
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## Simplified Usage
-
-You can also use the simplified interface that handles connector lifecycle management automatically:
-
-```python
-import asyncio
-from langchain_openai import ChatOpenAI
-from mcp_use import MCPAgent
-from mcp_use.connectors.stdio import StdioConnector
-
-async def main():
-    # Create the connector
-    connector = StdioConnector(
-        command="npx",
-        args=["@playwright/mcp@latest"],
-    )
-
-    # Create the LLM
-    llm = ChatOpenAI(model="gpt-4o-mini")
-
-    # Create MCP client
-    mcp_client = MCPAgent(connector=connector, llm=llm, max_steps=30)
-
-    # Run a query - MCPAgent handles connector lifecycle internally
-    result = await mcp_client.run(
-        "Using internet tell me how many people work at OpenAI",
-        # manage_connector=True is the default
-    )
-
-    print("Result:")
-    print(result)
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## 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())
-```
-
-Example configuration file (`mcp-config.json`):
-
-```json
-{
-  "mcpServers": {
-    "playwright": {
-      "command": "npx",
-      "args": ["@playwright/mcp@latest", "headless"],
-      "env": {
-        "PLAYWRIGHT_WS_ENDPOINT": "ws://localhost:41965/"
-      }
-    }
-  }
-}
-```
-
-## MCPClient for Managing Multiple Servers
-
-The `MCPClient` class provides a higher-level abstraction for managing multiple MCP servers from a single client:
-
-```python
-import asyncio
-from langchain_anthropic import ChatAnthropic
-from mcp_use import MCPAgent, MCPClient
-
-async def main():
-    # Create a client from a config file
-    client = MCPClient.from_config_file("mcp-config.json")
-
-    # Or initialize with a config file path
-    # client = MCPClient("mcp-config.json")
-
-    # Or programmatically add servers
-    client.add_server(
-        "local-ws",
-        {
-            "command": "npx",
-            "args": ["@playwright/mcp@latest", "headless"]
-        }
-    )
-
-    # Create an LLM
-    llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")
-
-    # Create an agent using the client
-    agent = MCPAgent(
-        llm=llm,
-        client=client,
-        server_name="playwright",  # Optional, uses first server if not specified
-        max_steps=30
-    )
-
-    # Run a query
-    result = await agent.run("Your query here")
-
-    # Close all sessions
-    await client.close_all_sessions()
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-This approach simplifies working with multiple MCP servers and allows for more dynamic configuration management.
-
-## Advanced Usage
-
-See the `examples` directory for more advanced usage examples:
-
-- `browser_use.py`: Shows how to use MCPClient with configuration files for browser automation
-
-## Requirements
-
-- Python 3.11+
-- MCP implementation (like Playwright MCP)
-- LangChain and appropriate model libraries (OpenAI, Anthropic, etc.)
-
-## License
-
-MIT

mcp_use-0.1.0.dist-info/RECORD

@@ -1,23 +0,0 @@
-mcp_use/__init__.py,sha256=k_D8e8BbU7OEzXlbkGgKayfgoSU1frQhWd2RxoLOT6E,838
-mcp_use/client.py,sha256=nu_SXM_WNHaV8354uZN8ZtV9iL0p9Gnloh56Zof44vk,7162
-mcp_use/config.py,sha256=Q-ItKT-gzFN2NiHhss1S7MKVu4cHj2nOshd_mjJ0upY,3232
-mcp_use/logging.py,sha256=2-hSB7ZWcHEx_OFHNg8GIbSGCZx3MW4mZGGWxi2Ew3E,2690
-mcp_use/session.py,sha256=-Zz6EMliZ10ZJdFY-jFa3xFCdSJetN0BoQVJ3eAAfc4,5343
-mcp_use/types.py,sha256=_HajP_FjhUzw9y9_cHWL20dVP5555oyESS_T717fDUI,675
-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=Tmsu1N5RIsLqLJzjlxODG6zMYFoCshZ7iwGpxAIIBL8,8904
-mcp_use/agents/mcpagent.py,sha256=R1cjgx2sjbCrr0lHJSOEnoA8UIH_aTk1xyuf6z_RGFU,5434
-mcp_use/connectors/__init__.py,sha256=jnd-7pPPJMb0UNJ6aD9lInj5Tlamc8lA_mFyG8RWJpo,385
-mcp_use/connectors/base.py,sha256=bTFxtejKhFFqhBetj1yAdkn1EXjP3YtHUdQDYOxA4uU,1642
-mcp_use/connectors/http.py,sha256=ryNOJFof98rAKkIzccMQNLYtzu1V2KC9s8R2PKP4EFY,4702
-mcp_use/connectors/stdio.py,sha256=LjbrPu8FtB1FLMLBdK7NpRQrYMhx_QITdZWH3e47fW8,4483
-mcp_use/connectors/websocket.py,sha256=nRMaURCP1d1dGTAHCn49RFOWKLtKAqdWot04STgtodg,5301
-mcp_use/tools/__init__.py,sha256=-fOvmDVWd3LAga1VNoQsZ5Fm7b4DtMvR1Wi8RtUnYMs,333
-mcp_use/tools/converter.py,sha256=4KuRTEPIFN-babh_mK7ltXwnlDu-c4XsjZiL3b2x_M0,3294
-mcp_use/tools/formats.py,sha256=PDWbmMLkxLftDo5EHAMAKYTBhOmrHpi73w1ee5xJhtw,5666
-mcp_use-0.1.0.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-0.1.0.dist-info/METADATA,sha256=3_ud5LMbAqJbvEwwPa23BcFLBhie7ypZKyRvhRaRqJg,7340
-mcp_use-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-mcp_use-0.1.0.dist-info/top_level.txt,sha256=xK9hG-ab5BJu7z6yGSxpeT3eVVTyzbpFiwJ0h8oknBM,8
-mcp_use-0.1.0.dist-info/RECORD,,

mcp_use-0.1.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-mcp_use