langchain-mcp-tools 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

langchain_mcp_tools/langchain_mcp_tools.py

@@ -32,25 +32,22 @@ 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):
     command: str
     args: NotRequired[list[str] | None]
-    env:  NotRequired[dict[str, str] | None]
+    env: NotRequired[dict[str, str] | None]
     cwd: NotRequired[str | None]
     errlog: NotRequired[TextIO | None]
 
 
 class McpServerUrlBasedConfig(TypedDict):
     url: str
-    args: NotRequired[list[str] | None]
-    env:  NotRequired[dict[str, str] | None]
-    cwd: NotRequired[str | None]
-    errlog: NotRequired[TextIO | None]
+    headers: NotRequired[dict[str, str] | None]
 
 
 McpServerConfig = McpServerCommandBasedConfig | McpServerUrlBasedConfig
@@ -59,11 +56,18 @@ McpServersConfig = dict[str, McpServerConfig]
 
 
 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
@@ -83,8 +87,7 @@ async def spawn_mcp_server_and_get_transport(
     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
@@ -100,18 +103,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'
+        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)
+                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)
             )
@@ -121,21 +126,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
@@ -147,13 +152,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
@@ -165,8 +171,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
@@ -213,8 +218,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
@@ -223,31 +228,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)
@@ -261,20 +275,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
@@ -282,21 +296,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
@@ -304,9 +318,14 @@ 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()
 
@@ -331,26 +350,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()
     """
 
@@ -396,13 +419,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.1.dist-info → langchain_mcp_tools-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-mcp-tools
-Version: 0.2.1
+Version: 0.2.3
 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,16 +11,17 @@ 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/)
@@ -30,11 +31,14 @@ This package is intended to simplify the use of
 server tools with LangChain / Python.
 
 [Model Context Protocol (MCP)](https://modelcontextprotocol.io/),
-an open source technology
+an open standard
 [announced by Anthropic](https://www.anthropic.com/news/model-context-protocol),
 dramatically expands LLM’s scope
 by enabling external tool and resource integration, including
-Google Drive, Slack, Notion, Spotify, Docker, PostgreSQL, and more…
+GitHub, Google Drive, Slack, Notion, Spotify, Docker, PostgreSQL, and more…
+
+MCP is likely to become the de facto industry standard as 
+[OpenAI has announced its adoption](https://techcrunch.com/2025/03/26/openai-adopts-rival-anthropics-standard-for-connecting-ai-models-to-data).
 
 Over 2000 functional components available as MCP servers:
 
@@ -64,6 +68,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
@@ -142,8 +151,28 @@ 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/e759edf886bdaef7c162e7f228e32fbb43993e37/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)
+
+### 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
+that require authentication via bearer tokens or other custom headers.
+
+```python
+    "sse-server-name": {
+        "url": f"http://{sse_server_host}:{sse_server_port}/..."
+        "headers": {"Authorization": f"Bearer {bearer_token}"}
+    },
+```
+
+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
 
@@ -158,11 +187,12 @@ can be specified with the `"cwd"` key as follows:
     },
 ```
 
-The key name `cwd` is derived from Python SDK's `StdioServerParameters`.
+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 in to specify a file-like object
+A new key `"errlog"` has been introduced to specify a file-like object
 to which local (stdio) MCP server's stderr is redirected.
 
 ```python
@@ -171,14 +201,14 @@ 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/e759edf886bdaef7c162e7f228e32fbb43993e37/src/example.py#L88-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
-SDK's `StdioServerParameters` doesn't include `stderr: int`.
-Instead, it calls `stdio_client()` with a separate argument
-`errlog: TextIO`.  I once included `stderr: int` for
+SDK's `StdioServerParameters` doesn't include `stderr: int`.  
+Instead, it calls [`stdio_client()` with a separate argument
+`errlog: TextIO`](https://github.com/modelcontextprotocol/python-sdk/blob/babb477dffa33f46cdc886bc885eb1d521151430/src/mcp/client/stdio/__init__.py#L96).  
+I once included `stderr: int` for
 compatibility with the TypeScript version, but decided to
 follow the Python SDK more closely.
 

langchain_mcp_tools-0.2.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+langchain_mcp_tools/__init__.py,sha256=iatHG2fCpz143wgQUZpyFVilgri4yOh2P0vxr22gguE,114
+langchain_mcp_tools/langchain_mcp_tools.py,sha256=3XfJUW98usqrWmn1RqbVzVr_Z4piv8PLzAm29YVj6z4,15806
+langchain_mcp_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_mcp_tools-0.2.3.dist-info/licenses/LICENSE,sha256=CRC91e8v116gCpnp7h49oIa6_zjhxqnHFTREeoZFJwA,1072
+langchain_mcp_tools-0.2.3.dist-info/METADATA,sha256=PPZz0kgmD2JQfUntk4D9R1gcm5DZZ_utV6L0YRo3b-M,9049
+langchain_mcp_tools-0.2.3.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+langchain_mcp_tools-0.2.3.dist-info/top_level.txt,sha256=aR_9V2A1Yt-Bca60KmndmGLUWb2wiM5IOG-Gkaf1dxY,20
+langchain_mcp_tools-0.2.3.dist-info/RECORD,,

{langchain_mcp_tools-0.2.1.dist-info → langchain_mcp_tools-0.2.3.dist-info}/WHEEL

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

langchain_mcp_tools-0.2.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-langchain_mcp_tools/__init__.py,sha256=iatHG2fCpz143wgQUZpyFVilgri4yOh2P0vxr22gguE,114
-langchain_mcp_tools/langchain_mcp_tools.py,sha256=n4u9fN3_sVMG1CmSKk8FrlXrBt79Ly1tz0TLhmDUaic,15118
-langchain_mcp_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_mcp_tools-0.2.1.dist-info/licenses/LICENSE,sha256=CRC91e8v116gCpnp7h49oIa6_zjhxqnHFTREeoZFJwA,1072
-langchain_mcp_tools-0.2.1.dist-info/METADATA,sha256=6_d5jxaN8KqL6ZyJHwVDI0YQLe30xy0-7sgyRs85Zlc,7287
-langchain_mcp_tools-0.2.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-langchain_mcp_tools-0.2.1.dist-info/top_level.txt,sha256=aR_9V2A1Yt-Bca60KmndmGLUWb2wiM5IOG-Gkaf1dxY,20
-langchain_mcp_tools-0.2.1.dist-info/RECORD,,