langchain-mcp-tools 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

{langchain_mcp_tools-0.0.13.dist-info → langchain_mcp_tools-0.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: langchain-mcp-tools
-Version: 0.0.13
+Version: 0.0.15
 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
@@ -108,7 +108,7 @@ Currently, only text results of tool calls are supported.
 ## Technical Details
 
 It was very tricky (for me) to get the parallel MCP server initialization
-to work successfully...
+to work, including successful final resource cleanup...
 
 I'm new to Python, so it is very possible that my ignorance is playing
 a big role here...  
@@ -119,23 +119,24 @@ Any comments pointing out something I am missing would be greatly appreciated!
 [(comment here)](https://github.com/hideya/langchain-mcp-tools-ts/issues)
 
 1. Core Challenge:
-   - Async resources management for `stdio_client` and `ClientSession` seems
+
+   A key requirement for parallel initialization is that each server must be
+   initialized in its own dedicated task - there's no way around this as far as
+   I know. However, this poses a challenge when combined with
+   `asynccontextmanager`.
+
+   - Resources management for `stdio_client` and `ClientSession` seems
      to require relying exclusively on `asynccontextmanager` for cleanup,
      with no manual cleanup options
      (based on [the mcp python-sdk impl as of Jan 14, 2025](https://github.com/modelcontextprotocol/python-sdk/tree/99727a9/src/mcp/client))
    - Initializing multiple MCP servers in parallel requires a dedicated
      `asyncio.Task` per server
-   - Necessity of keeping sessions alive for later use by different tasks
+   - Need to keep sessions alive for later use by different tasks
      after initialization
-   - Ensuring proper cleanup later in the same task that created them
+   - Need to ensure proper cleanup later in the same task that created them
 
 2. Solution Strategy:
 
-   A key requirement for parallel initialization is that each server must be
-   initialized in its own dedicated task - there's no way around this as far
-   as I understand. However, this creates a challenge since we also need to
-   maintain long-lived sessions and handle cleanup properly.
-
    The key insight is to keep the initialization tasks alive throughout the
    session lifetime, rather than letting them complete after initialization.
 
@@ -156,7 +157,7 @@ Any comments pointing out something I am missing would be greatly appreciated!
 
 3. Task Lifecycle:
 
-   To allow the initialization task to stay alive waiting for cleanup:
+   The following illustrates how to implement the above-mentioned strategy:
    ```
    [Task starts]
      ↓

langchain_mcp_tools-0.0.15.dist-info/RECORD

@@ -0,0 +1,10 @@
+src/langchain_mcp_tools/__init__.py,sha256=Xtv2VphhrWB_KlxTIofHZqtCIGtNEl0MxugnrNXTERA,94
+src/langchain_mcp_tools/langchain_mcp_tools.py,sha256=EJgm28o2M3mBsFkeDtpw6hooSE1oWwjFJYhRfirxCgE,10511
+src/langchain_mcp_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/tests/__init__.py,sha256=1tFqfPgsnrucXkBKUZ5LMAJ1lk5pdnHAFlUNqR_w21E,31
+src/tests/test_langchain_mcp_tools.py,sha256=oy5fpsvf-p5YV6zPORau_Wz8rmkF-mNWR3T2r03XzjI,4464
+langchain_mcp_tools-0.0.15.dist-info/LICENSE,sha256=CRC91e8v116gCpnp7h49oIa6_zjhxqnHFTREeoZFJwA,1072
+langchain_mcp_tools-0.0.15.dist-info/METADATA,sha256=v-caB8b65upCaAni4N6ChUSjr6rGCAV4fwlH-Uy0S5M,6943
+langchain_mcp_tools-0.0.15.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+langchain_mcp_tools-0.0.15.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+langchain_mcp_tools-0.0.15.dist-info/RECORD,,

langchain_mcp_tools-0.0.15.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

{langchain_mcp_tools → src/langchain_mcp_tools}/langchain_mcp_tools.py

@@ -37,21 +37,23 @@ require context managers while enabling parallel initialization.
 The key aspects are:
 
 1. Core Challenge:
-   - Async resources management for `stdio_client` and `ClientSession` seems
+
+   A key requirement for parallel initialization is that each server must be
+   initialized in its own dedicated task - there's no way around this as far as
+   I know. However, this poses a challenge when combined with
+   `asynccontextmanager`.
+
+   - Resources management for `stdio_client` and `ClientSession` seems
      to require relying exclusively on `asynccontextmanager` for cleanup,
      with no manual cleanup options
      (based on [the mcp python-sdk impl as of Jan 14, 2025](https://github.com/modelcontextprotocol/python-sdk/tree/99727a9/src/mcp/client))
    - Initializing multiple MCP servers in parallel requires a dedicated
      `asyncio.Task` per server
-   - Necessity of keeping sessions alive for later use by different tasks
+   - Need to keep sessions alive for later use by different tasks
      after initialization
-   - Ensuring proper cleanup later in the same task that created them
+   - Need to ensure proper cleanup later in the same task that created them
 
 2. Solution Strategy:
-   A key requirement for parallel initialization is that each server must be
-   initialized in its own dedicated task - there's no way around this as far
-   as I understand. However, this creates a challenge since we also need to
-   maintain long-lived sessions and handle cleanup properly.
 
    The key insight is to keep the initialization tasks alive throughout the
    session lifetime, rather than letting them complete after initialization.
@@ -73,7 +75,7 @@ The key aspects are:
 
 3. Task Lifecycle:
 
-   To allow the initialization task to stay alive waiting for cleanup:
+   The following illustrates how to implement the above-mentioned strategy:
    ```
    [Task starts]
      ↓

src/tests/__init__.py

@@ -0,0 +1,2 @@
+
+# Test package initialization

src/tests/test_langchain_mcp_tools.py

@@ -0,0 +1,163 @@
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from langchain_core.tools import BaseTool
+from langchain_mcp_tools.langchain_mcp_tools import (
+    convert_mcp_to_langchain_tools,
+)
+
+# Fix the asyncio mark warning by installing pytest-asyncio
+pytest_plugins = ('pytest_asyncio',)
+
+
+@pytest.fixture
+def mock_stdio_client():
+    with patch('langchain_mcp_tools.langchain_mcp_tools.stdio_client') as mock:
+        mock.return_value.__aenter__.return_value = (AsyncMock(), AsyncMock())
+        yield mock
+
+
+@pytest.fixture
+def mock_client_session():
+    with patch('langchain_mcp_tools.langchain_mcp_tools.ClientSession') as mock:
+        session = AsyncMock()
+        # Mock the list_tools response
+        session.list_tools.return_value = MagicMock(
+            tools=[
+                MagicMock(
+                    name="tool1",
+                    description="Test tool",
+                    inputSchema={"type": "object", "properties": {}}
+                )
+            ]
+        )
+        mock.return_value.__aenter__.return_value = session
+        yield mock
+
+
+@pytest.mark.asyncio
+async def test_convert_mcp_to_langchain_tools_empty():
+    server_configs = {}
+    tools, cleanup = await convert_mcp_to_langchain_tools(server_configs)
+    assert isinstance(tools, list)
+    assert len(tools) == 0
+    await cleanup()
+
+
+"""
+@pytest.mark.asyncio
+async def test_convert_mcp_to_langchain_tools_invalid_config():
+    server_configs = {"invalid": {"command": "nonexistent"}}
+    with pytest.raises(Exception):
+        await convert_mcp_to_langchain_tools(server_configs)
+"""
+
+
+"""
+@pytest.mark.asyncio
+async def test_convert_single_mcp_success(
+    mock_stdio_client,
+    mock_client_session
+):
+    # Test data
+    server_name = "test_server"
+    server_config = {
+        "command": "test_command",
+        "args": ["--test"],
+        "env": {"TEST_ENV": "value"}
+    }
+    langchain_tools = []
+    ready_event = asyncio.Event()
+    cleanup_event = asyncio.Event()
+
+    # Create task
+    task = asyncio.create_task(
+        convert_single_mcp_to_langchain_tools(
+            server_name,
+            server_config,
+            langchain_tools,
+            ready_event,
+            cleanup_event
+        )
+    )
+
+    # Wait for ready event
+    await asyncio.wait_for(ready_event.wait(), timeout=1.0)
+
+    # Verify tools were created
+    assert len(langchain_tools) == 1
+    assert isinstance(langchain_tools[0], BaseTool)
+    assert langchain_tools[0].name == "tool1"
+
+    # Trigger cleanup
+    cleanup_event.set()
+    await task
+"""
+
+
+@pytest.mark.asyncio
+async def test_convert_mcp_to_langchain_tools_multiple_servers(
+    mock_stdio_client,
+    mock_client_session
+):
+    server_configs = {
+        "server1": {"command": "cmd1", "args": []},
+        "server2": {"command": "cmd2", "args": []}
+    }
+
+    tools, cleanup = await convert_mcp_to_langchain_tools(server_configs)
+
+    # Verify correct number of tools created
+    assert len(tools) == 2  # One tool per server
+    assert all(isinstance(tool, BaseTool) for tool in tools)
+
+    # Test cleanup
+    await cleanup()
+
+
+"""
+@pytest.mark.asyncio
+async def test_tool_execution(mock_stdio_client, mock_client_session):
+    server_configs = {
+        "test_server": {"command": "test", "args": []}
+    }
+
+    # Mock the tool execution response
+    session = mock_client_session.return_value.__aenter__.return_value
+    session.call_tool.return_value = MagicMock(
+        isError=False,
+        content={"result": "success"}
+    )
+
+    tools, cleanup = await convert_mcp_to_langchain_tools(server_configs)
+
+    # Test tool execution
+    result = await tools[0]._arun(test_param="value")
+    assert result == {"result": "success"}
+
+    # Verify tool was called with correct parameters
+    session.call_tool.assert_called_once_with("tool1", {"test_param": "value"})
+
+    await cleanup()
+"""
+
+
+@pytest.mark.asyncio
+async def test_tool_execution_error(mock_stdio_client, mock_client_session):
+    server_configs = {
+        "test_server": {"command": "test", "args": []}
+    }
+
+    # Mock error response
+    session = mock_client_session.return_value.__aenter__.return_value
+    session.call_tool.return_value = MagicMock(
+        isError=True,
+        content="Error message"
+    )
+
+    tools, cleanup = await convert_mcp_to_langchain_tools(server_configs)
+
+    # Test tool execution error
+    with pytest.raises(Exception):
+        await tools[0]._arun(test_param="value")
+
+    await cleanup()

langchain_mcp_tools-0.0.13.dist-info/RECORD

@@ -1,8 +0,0 @@
-langchain_mcp_tools/__init__.py,sha256=Xtv2VphhrWB_KlxTIofHZqtCIGtNEl0MxugnrNXTERA,94
-langchain_mcp_tools/langchain_mcp_tools.py,sha256=5OKa6xeS54vB-mqH1BTZSB6E8Ykh5Cfu9rXqfCqESOg,10558
-langchain_mcp_tools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_mcp_tools-0.0.13.dist-info/LICENSE,sha256=CRC91e8v116gCpnp7h49oIa6_zjhxqnHFTREeoZFJwA,1072
-langchain_mcp_tools-0.0.13.dist-info/METADATA,sha256=tJx9mGu94T09xAYPSCB14V1cIp7w31cM1ndNbUev1vQ,6959
-langchain_mcp_tools-0.0.13.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-langchain_mcp_tools-0.0.13.dist-info/top_level.txt,sha256=aR_9V2A1Yt-Bca60KmndmGLUWb2wiM5IOG-Gkaf1dxY,20
-langchain_mcp_tools-0.0.13.dist-info/RECORD,,

langchain_mcp_tools-0.0.13.dist-info/top_level.txt

@@ -1 +0,0 @@
-langchain_mcp_tools