langchain-mcp-tools 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

langchain_mcp_tools/__init__.py

@@ -3,4 +3,7 @@ from .langchain_mcp_tools import (
   convert_mcp_to_langchain_tools,
   McpServerCleanupFn,
   McpServersConfig,
+  McpServerCommandBasedConfig,
+  McpServerUrlBasedConfig,
+  SingleMcpServerConfig,
 )

langchain_mcp_tools/langchain_mcp_tools.py

@@ -32,12 +32,37 @@ try:
     from pydantic import BaseModel
     # from pydantic_core import to_json
 except ImportError as e:
-    print(f'\nError: Required package not found: {e}')
-    print('Please ensure all required packages are installed\n')
+    print(f"\nError: Required package not found: {e}")
+    print("Please ensure all required packages are installed\n")
     sys.exit(1)
 
 
 class McpServerCommandBasedConfig(TypedDict):
+    """Configuration for an MCP server launched via command line.
+
+    This configuration is used for local MCP servers that are started as child
+    processes using the stdio client. It defines the command to run, optional
+    arguments, environment variables, working directory, and error logging
+    options.
+
+    Attributes:
+        command: The executable command to run (e.g., "npx", "uvx", "python").
+        args: Optional list of command-line arguments to pass to the command.
+        env: Optional dictionary of environment variables to set for the
+                process.
+        cwd: Optional working directory where the command will be executed.
+        errlog: Optional file-like object for redirecting the server's stderr
+                output.
+
+    Example:
+        {
+            "command": "npx",
+            "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
+            "env": {"NODE_ENV": "production"},
+            "cwd": "/path/to/working/directory",
+            "errlog": open("server.log", "w")
+        }
+    """
     command: str
     args: NotRequired[list[str] | None]
     env: NotRequired[dict[str, str] | None]
@@ -46,21 +71,88 @@ class McpServerCommandBasedConfig(TypedDict):
 
 
 class McpServerUrlBasedConfig(TypedDict):
+    """Configuration for a remote MCP server accessed via URL.
+
+    This configuration is used for remote MCP servers that are accessed via
+    HTTP/HTTPS (Server-Sent Events) or WebSocket connections. It defines the
+    URL to connect to and optional HTTP headers for authentication.
+
+    Attributes:
+        url: The URL of the remote MCP server. For SSE servers,
+                use http:// or https:// prefix. For WebSocket servers,
+                use ws:// or wss:// prefix.
+        headers: Optional dictionary of HTTP headers to include in the request,
+                typically used for authentication (e.g., bearer tokens).
+
+    Example for SSE server:
+        {
+            "url": "https://example.com/mcp/sse",
+            "headers": {"Authorization": "Bearer token123"}
+        }
+
+    Example for WebSocket server:
+        {
+            "url": "wss://example.com/mcp/ws"
+        }
+    """
     url: str
     headers: NotRequired[dict[str, str] | None]
 
 
-McpServerConfig = McpServerCommandBasedConfig | McpServerUrlBasedConfig
-
-McpServersConfig = dict[str, McpServerConfig]
+# Type for a single MCP server configuration, which can be either
+# command-based or URL-based.
+SingleMcpServerConfig = McpServerCommandBasedConfig | McpServerUrlBasedConfig
+"""Configuration for a single MCP server, either command-based or URL-based.
+
+This type represents the configuration for a single MCP server, which can
+be either:
+1. A local server launched via command line (McpServerCommandBasedConfig)
+2. A remote server accessed via URL (McpServerUrlBasedConfig)
+
+The type is determined by the presence of either the "command" key
+(for command-based) or the "url" key (for URL-based).
+"""
+
+# Configuration dictionary for multiple MCP servers
+McpServersConfig = dict[str, SingleMcpServerConfig]
+"""Configuration dictionary for multiple MCP servers.
+
+A dictionary mapping server names (as strings) to their respective
+configurations. Each server name acts as a logical identifier used for logging
+and debugging. The configuration for each server can be either command-based
+or URL-based.
+
+Example:
+    {
+        "filesystem": {
+            "command": "npx",
+            "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
+        },
+        "fetch": {
+            "command": "uvx",
+            "args": ["mcp-server-fetch"]
+        },
+        "remote-server": {
+            "url": "https://example.com/mcp/sse",
+            "headers": {"Authorization": "Bearer token123"}
+        }
+    }
+"""
 
 
 def fix_schema(schema: dict) -> dict:
-    """Converts JSON Schema 'type': ['string', 'null'] to 'anyOf' format"""
+    """Converts JSON Schema "type": ["string", "null"] to "anyOf" format.
+
+    Args:
+        schema: A JSON schema dictionary
+
+    Returns:
+        Modified schema with converted type formats
+    """
     if isinstance(schema, dict):
-        if 'type' in schema and isinstance(schema['type'], list):
-            schema['anyOf'] = [{'type': t} for t in schema['type']]
-            del schema['type']  # Remove 'type' and standardize to 'anyOf'
+        if "type" in schema and isinstance(schema["type"], list):
+            schema["anyOf"] = [{"type": t} for t in schema["type"]]
+            del schema["type"]  # Remove "type" and standardize to "anyOf"
         for key, value in schema.items():
             schema[key] = fix_schema(value)  # Apply recursively
     return schema
@@ -76,12 +168,11 @@ Transport: TypeAlias = tuple[
 
 async def spawn_mcp_server_and_get_transport(
     server_name: str,
-    server_config: McpServerConfig,
+    server_config: SingleMcpServerConfig,
     exit_stack: AsyncExitStack,
     logger: logging.Logger = logging.getLogger(__name__)
 ) -> Transport:
-    """
-    Spawns an MCP server process and establishes communication channels.
+    """Spawns an MCP server process and establishes communication channels.
 
     Args:
         server_name: Server instance name to use for better logging
@@ -97,19 +188,20 @@ async def spawn_mcp_server_and_get_transport(
     """
     try:
         logger.info(f'MCP server "{server_name}": '
-                    f'initializing with: {server_config}')
+                    f"initializing with: {server_config}")
 
-        url_str = str(server_config.get('url'))  # None becomes 'None'
-        headers = server_config.get("headers", None)
+        url_str = str(server_config.get("url"))  # None becomes "None"
+        headers = (cast(McpServerUrlBasedConfig, server_config)
+                   .get("headers", None))
         # no exception thrown even for a malformed URL
         url_scheme = urlparse(url_str).scheme
 
-        if url_scheme in ('http', 'https'):
+        if url_scheme in ("http", "https"):
             transport = await exit_stack.enter_async_context(
                 sse_client(url_str, headers=headers)
             )
 
-        elif url_scheme in ('ws', 'wss'):
+        elif url_scheme in ("ws", "wss"):
             transport = await exit_stack.enter_async_context(
                 websocket_client(url_str)
             )
@@ -119,21 +211,21 @@ async def spawn_mcp_server_and_get_transport(
             # To avoid confusion, it was decided to automatically append it
             # to the env if not explicitly set by the config.
             config = cast(McpServerCommandBasedConfig, server_config)
-            # env = config.get('env', {}) does't work since it can yield None
-            env_val = config.get('env')
+            # env = config.get("env", {}) does't work since it can yield None
+            env_val = config.get("env")
             env = {} if env_val is None else dict(env_val)
-            if 'PATH' not in env:
-                env['PATH'] = os.environ.get('PATH', '')
+            if "PATH" not in env:
+                env["PATH"] = os.environ.get("PATH", "")
 
             # Use stdio client for commands
-            # args = config.get('args', []) does't work since it can yield None
-            args_val = config.get('args')
+            # args = config.get("args", []) does't work since it can yield None
+            args_val = config.get("args")
             args = [] if args_val is None else list(args_val)
             server_parameters = StdioServerParameters(
-                command=config.get('command', ''),
+                command=config.get("command", ""),
                 args=args,
                 env=env,
-                cwd=config.get('cwd', None)
+                cwd=config.get("cwd", None)
             )
 
             # Initialize stdio client and register it with exit stack for
@@ -145,13 +237,14 @@ async def spawn_mcp_server_and_get_transport(
             # `errlog: TextIO`.  I once included `stderr: int` for
             # compatibility with the TypeScript version, but decided to
             # follow the Python SDK more closely.
-            errlog_val = server_config.get('errlog')
-            kwargs = {'errlog': errlog_val} if errlog_val is not None else {}
+            errlog_val = (cast(McpServerCommandBasedConfig, server_config)
+                          .get("errlog"))
+            kwargs = {"errlog": errlog_val} if errlog_val is not None else {}
             transport = await exit_stack.enter_async_context(
                 stdio_client(server_parameters, **kwargs)
             )
     except Exception as e:
-        logger.error(f'Error spawning MCP server: {str(e)}')
+        logger.error(f"Error spawning MCP server: {str(e)}")
         raise
 
     return transport
@@ -163,8 +256,7 @@ async def get_mcp_server_tools(
     exit_stack: AsyncExitStack,
     logger: logging.Logger = logging.getLogger(__name__)
 ) -> list[BaseTool]:
-    """
-    Retrieves and converts MCP server tools to LangChain format.
+    """Retrieves and converts MCP server tools to LangChain format.
 
     Args:
         server_name: Server instance name to use for better logging
@@ -211,8 +303,8 @@ async def get_mcp_server_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 ''
+                name: str = tool.name or "NO NAME"
+                description: str = tool.description or ""
                 # Convert JSON schema to Pydantic model for argument validation
                 args_schema: type[BaseModel] = jsonschema_to_pydantic(
                     fix_schema(tool.inputSchema)  # Apply schema conversion
@@ -221,31 +313,40 @@ async def get_mcp_server_tools(
 
                 def _run(self, **kwargs: Any) -> NoReturn:
                     raise NotImplementedError(
-                        'MCP tools only support async operations'
+                        "MCP tools only support async operations"
                     )
 
                 async def _arun(self, **kwargs: Any) -> Any:
-                    """
-                    Asynchronously executes the tool with given arguments.
+                    """Asynchronously executes the tool with given arguments.
+
                     Logs input/output and handles errors.
+
+                    Args:
+                        **kwargs: Arguments to be passed to the MCP tool
+
+                    Returns:
+                        Formatted response from the MCP tool as a string
+
+                    Raises:
+                        ToolException: If the tool execution fails
                     """
                     logger.info(f'MCP tool "{server_name}"/"{tool.name}" '
-                                f'received input: {kwargs}')
+                                f"received input: {kwargs}")
 
                     try:
                         result = await session.call_tool(self.name, kwargs)
 
-                        if hasattr(result, 'isError') and result.isError:
+                        if hasattr(result, "isError") and result.isError:
                             raise ToolException(
-                                f'Tool execution failed: {result.content}'
+                                f"Tool execution failed: {result.content}"
                             )
 
-                        if not hasattr(result, 'content'):
+                        if not hasattr(result, "content"):
                             return str(result)
 
                         # The return type of `BaseTool`'s `arun` is `str`.
                         try:
-                            result_content_text = '\n\n'.join(
+                            result_content_text = "\n\n".join(
                                 item.text
                                 for item in result.content
                                 if isinstance(item, mcp_types.TextContent)
@@ -259,20 +360,20 @@ async def get_mcp_server_tools(
 
                         except KeyError as e:
                             result_content_text = (
-                                f'Error in parsing result.content: {str(e)}; '
-                                f'contents: {repr(result.content)}'
+                                f"Error in parsing result.content: {str(e)}; "
+                                f"contents: {repr(result.content)}"
                             )
 
                         # Log rough result size for monitoring
                         size = len(result_content_text.encode())
                         logger.info(f'MCP tool "{server_name}"/"{tool.name}" '
-                                    f'received result (size: {size})')
+                                    f"received result (size: {size})")
 
                         # If no text content, return a clear message
                         # describing the situation.
                         result_content_text = (
                             result_content_text or
-                            'No text content available in response'
+                            "No text content available in response"
                         )
 
                         return result_content_text
@@ -280,21 +381,21 @@ async def get_mcp_server_tools(
                     except Exception as e:
                         logger.warn(
                             f'MCP tool "{server_name}"/"{tool.name}" '
-                            f'caused error:  {str(e)}'
+                            f"caused error:  {str(e)}"
                         )
                         if self.handle_tool_error:
-                            return f'Error executing MCP tool: {str(e)}'
+                            return f"Error executing MCP tool: {str(e)}"
                         raise
 
             langchain_tools.append(McpToLangChainAdapter())
 
         # Log available tools for debugging
         logger.info(f'MCP server "{server_name}": {len(langchain_tools)} '
-                    f'tool(s) available:')
+                    f"tool(s) available:")
         for tool in langchain_tools:
-            logger.info(f'- {tool.name}')
+            logger.info(f"- {tool.name}")
     except Exception as e:
-        logger.error(f'Error getting MCP tools: {str(e)}')
+        logger.error(f"Error getting MCP tools: {str(e)}")
         raise
 
     return langchain_tools
@@ -302,19 +403,36 @@ async def get_mcp_server_tools(
 
 # A very simple pre-configured logger for fallback
 def init_logger() -> logging.Logger:
+    """Creates a simple pre-configured logger.
+
+    Returns:
+        A configured Logger instance
+    """
     logging.basicConfig(
         level=logging.INFO,  # logging.DEBUG,
-        format='\x1b[90m[%(levelname)s]\x1b[0m %(message)s'
+        format="\x1b[90m[%(levelname)s]\x1b[0m %(message)s"
     )
     return logging.getLogger()
 
 
 # Type hint for cleanup function
 McpServerCleanupFn = Callable[[], Awaitable[None]]
+"""Type for the async cleanup function returned by
+    convert_mcp_to_langchain_tools.
+
+This represents an asynchronous function that takes no arguments and returns
+nothing. It's used to properly shut down all MCP server connections and clean
+up resources when the tools are no longer needed.
+
+Example usage:
+    tools, cleanup = await convert_mcp_to_langchain_tools(server_configs)
+    # Use tools...
+    await cleanup()  # Clean up resources when done
+"""
 
 
 async def convert_mcp_to_langchain_tools(
-    server_configs: dict[str, McpServerConfig],
+    server_configs: McpServersConfig,
     logger: logging.Logger | None = None
 ) -> tuple[list[BaseTool], McpServerCleanupFn]:
     """Initialize multiple MCP servers and convert their tools to
@@ -329,26 +447,30 @@ async def convert_mcp_to_langchain_tools(
             configurations, where each configuration contains command, args,
             and env settings
         logger: Logger instance to use for logging events and errors.
-           If None, uses module logger with fallback to a pre-configured
-           logger when no root handlers exist.
+            If None, uses module logger with fallback to a pre-configured
+            logger when no root handlers exist.
 
     Returns:
         A tuple containing:
-            - List of converted LangChain tools from all servers
-            - Async cleanup function to properly shutdown all server
-                connections
+
+        * List of converted LangChain tools from all servers
+        * Async cleanup function to properly shutdown all server connections
 
     Example:
+
         server_configs = {
-            'fetch': {
-                'command': 'uvx', 'args': ['mcp-server-fetch']
+            "fetch": {
+                "command": "uvx", "args": ["mcp-server-fetch"]
             },
-            'weather': {
-                'command': 'npx', 'args': ['-y','@h1deya/mcp-server-weather']
+            "weather": {
+                "command": "npx", "args": ["-y","@h1deya/mcp-server-weather"]
             }
         }
+
         tools, cleanup = await convert_mcp_to_langchain_tools(server_configs)
+
         # Use tools...
+
         await cleanup()
     """
 
@@ -394,13 +516,13 @@ async def convert_mcp_to_langchain_tools(
 
     # Define a cleanup function to properly shut down all servers
     async def mcp_cleanup() -> None:
-        """Closes all server connections and cleans up resources"""
+        """Closes all server connections and cleans up resources."""
         await async_exit_stack.aclose()
 
     # Log summary of initialized tools
-    logger.info(f'MCP servers initialized: {len(langchain_tools)} tool(s) '
-                f'available in total')
+    logger.info(f"MCP servers initialized: {len(langchain_tools)} tool(s) "
+                f"available in total")
     for tool in langchain_tools:
-        logger.debug(f'- {tool.name}')
+        logger.debug(f"- {tool.name}")
 
     return langchain_tools, mcp_cleanup

{langchain_mcp_tools-0.2.2.dist-info → langchain_mcp_tools-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-mcp-tools
-Version: 0.2.2
+Version: 0.2.4
 Summary: Model Context Protocol (MCP) To LangChain Tools Conversion Utility
 Project-URL: Bug Tracker, https://github.com/hideya/langchain-mcp-tools-py/issues
 Project-URL: Source Code, https://github.com/hideya/langchain-mcp-tools-py
@@ -11,20 +11,31 @@ License-File: LICENSE
 Requires-Dist: jsonschema-pydantic>=0.6
 Requires-Dist: langchain>=0.3.14
 Requires-Dist: mcp>=1.6.0
-Requires-Dist: pyjson5>=1.6.8
-Requires-Dist: websockets>=15.0.1
 Provides-Extra: dev
 Requires-Dist: dotenv>=0.9.9; extra == "dev"
+Requires-Dist: fastapi>=0.115.12; extra == "dev"
+Requires-Dist: pyjwt>=2.10.1; extra == "dev"
 Requires-Dist: langchain-anthropic>=0.3.1; extra == "dev"
 Requires-Dist: langchain-groq>=0.2.3; extra == "dev"
 Requires-Dist: langchain-openai>=0.3.0; extra == "dev"
 Requires-Dist: langgraph>=0.2.62; extra == "dev"
 Requires-Dist: pytest>=8.3.4; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.25.2; extra == "dev"
+Requires-Dist: websockets>=15.0.1; extra == "dev"
 Dynamic: license-file
 
 # MCP To LangChain Tools Conversion Utility [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/hideya/langchain-mcp-tools-py/blob/main/LICENSE) [![pypi version](https://img.shields.io/pypi/v/langchain-mcp-tools.svg)](https://pypi.org/project/langchain-mcp-tools/)
 
+## NOTE
+
+LangChain's official **LangChain MCP Adapters** library has been released at:
+- pypi: https://pypi.org/project/langchain-mcp-adapters/
+- github: https://github.com/langchain-ai/langchain-mcp-adapters
+
+You may want to consider using the above if you don't have specific needs for using this library...
+
+## Introduction
+
 This package is intended to simplify the use of
 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)
 server tools with LangChain / Python.
@@ -67,6 +78,11 @@ A typescript equivalent of this utility is available
 pip install langchain-mcp-tools
 ```
 
+## API docs
+
+Can be found [here](https://hideya.github.io/langchain-mcp-tools-py/)
+
+
 ## Quick Start
 
 A minimal but complete working usage example can be found
@@ -145,9 +161,9 @@ Note that the key `"url"` may be changed in the future to match
 the MCP server configurations used by Claude for Desktop once
 it introduces remote server support.
 
-A usage example can be found [here](https://github.com/hideya/langchain-mcp-tools-py-usage/blob/cf96ddc43750708ef3b244bad95714f0f2fe1d28/src/example.py#L43-L54)
+A usage example can be found [here](https://github.com/hideya/langchain-mcp-tools-py-usage/blob/3bd35d9fb49f4b631fe3d0cc8491d43cbf69693b/src/example.py#L43-L54)
 
-### Passing HTTP Headers to SSE Connection
+### Authentication Support for SSE Connections
 
 A new key `"headers"` has been introduced to pass HTTP headers to the SSE (Server-Sent Events) connection.  
 It takes  `dict[str, str]` and is primarily intended to support SSE MCP servers
@@ -163,6 +179,11 @@ that require authentication via bearer tokens or other custom headers.
 The key name `header` is derived from the Python SDK
 [`sse_client()`](https://github.com/modelcontextprotocol/python-sdk/blob/babb477dffa33f46cdc886bc885eb1d521151430/src/mcp/client/sse.py#L24) argument name.
 
+A simple example showing how to implement MCP SSE server and client with authentication can be found
+in [sse-auth-test-client.py](https://github.com/hideya/langchain-mcp-tools-py-usage/tree/main/src/sse-auth-test-client.py)
+and in [sse-auth-test-server.py](https://github.com/hideya/langchain-mcp-tools-py-usage/tree/main/src/sse-auth-test-server.py)
+of [this usage examples repo](https://github.com/hideya/langchain-mcp-tools-py-usage).
+
 ### Working Directory Configuration for Local MCP Servers
 
 The working directory that is used when spawning a local (stdio) MCP server
@@ -179,7 +200,7 @@ can be specified with the `"cwd"` key as follows:
 The key name `cwd` is derived from
 Python SDK's [`StdioServerParameters`](https://github.com/modelcontextprotocol/python-sdk/blob/babb477dffa33f46cdc886bc885eb1d521151430/src/mcp/client/stdio/__init__.py#L76-L77).
 
-### Configuration for Local MCP Server `stderr` Redirection
+### stderr Redirection for Local MCP Server
 
 A new key `"errlog"` has been introduced to specify a file-like object
 to which local (stdio) MCP server's stderr is redirected.
@@ -190,8 +211,7 @@ to which local (stdio) MCP server's stderr is redirected.
     mcp_servers[server_name]["errlog"] = log_file
 ```
 
-A usage example can be found [here](
-https://github.com/hideya/langchain-mcp-tools-py-usage/blob/cf96ddc43750708ef3b244bad95714f0f2fe1d28/src/example.py#L91-L108)
+A usage example can be found [here](https://github.com/hideya/langchain-mcp-tools-py-usage/blob/3bd35d9fb49f4b631fe3d0cc8491d43cbf69693b/src/example.py#L88-L108)
 
 **NOTE: Why the key name `errlog` was chosen:**  
 Unlike TypeScript SDK's `StdioServerParameters`, the Python

langchain_mcp_tools-0.2.4.dist-info/RECORD

@@ -0,0 +1,8 @@
+langchain_mcp_tools/__init__.py,sha256=CYyhniRN10ktRD1z06JyBoeo_m72Q8OIbqHjh-OGoFA,197
+langchain_mcp_tools/langchain_mcp_tools.py,sha256=LximGy_0QYKuwsKFr5SvUwMZ7475CIJWxLtNDq68b-g,19377
+langchain_mcp_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_mcp_tools-0.2.4.dist-info/licenses/LICENSE,sha256=CRC91e8v116gCpnp7h49oIa6_zjhxqnHFTREeoZFJwA,1072
+langchain_mcp_tools-0.2.4.dist-info/METADATA,sha256=RJ00zZEh3UCSe6S6B_aaD4YZRiYd3SemWQrPrO9BM8M,9377
+langchain_mcp_tools-0.2.4.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+langchain_mcp_tools-0.2.4.dist-info/top_level.txt,sha256=aR_9V2A1Yt-Bca60KmndmGLUWb2wiM5IOG-Gkaf1dxY,20
+langchain_mcp_tools-0.2.4.dist-info/RECORD,,

{langchain_mcp_tools-0.2.2.dist-info → langchain_mcp_tools-0.2.4.dist-info}/WHEEL

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

langchain_mcp_tools-0.2.2.dist-info/RECORD

@@ -1,8 +0,0 @@
-langchain_mcp_tools/__init__.py,sha256=iatHG2fCpz143wgQUZpyFVilgri4yOh2P0vxr22gguE,114
-langchain_mcp_tools/langchain_mcp_tools.py,sha256=txbtjl7BAjZu1ccNUNhLkLd3HNdCSfKeyTCDX_0PUR0,15078
-langchain_mcp_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_mcp_tools-0.2.2.dist-info/licenses/LICENSE,sha256=CRC91e8v116gCpnp7h49oIa6_zjhxqnHFTREeoZFJwA,1072
-langchain_mcp_tools-0.2.2.dist-info/METADATA,sha256=hxlEr_nyHbnjLMzhxYOsT_rZQ8-j4rTi7EDDUxyvb-A,8458
-langchain_mcp_tools-0.2.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-langchain_mcp_tools-0.2.2.dist-info/top_level.txt,sha256=aR_9V2A1Yt-Bca60KmndmGLUWb2wiM5IOG-Gkaf1dxY,20
-langchain_mcp_tools-0.2.2.dist-info/RECORD,,