feat: mcp tool callable

Author: edis-uipath

src/uipath_langchain/agent/tools/mcp_tool.py

@@ -3,11 +3,18 @@
 from collections import Counter, defaultdict
 from contextlib import AsyncExitStack, asynccontextmanager
 from itertools import chain
+from typing import Any, AsyncGenerator
 
 import httpx
-from langchain_core.tools import BaseTool
+from langchain_core.tools import BaseTool, StructuredTool
 from uipath._utils._ssl_context import get_httpx_client_kwargs
 from uipath.agent.models.agent import AgentMcpResourceConfig
+from uipath.platform import UiPath
+from uipath.platform.orchestrator.mcp import McpServer
+
+from uipath_langchain.agent.react.jsonschema_pydantic_converter import create_model
+
+from .utils import sanitize_tool_name
 
 
 def _deduplicate_tools(tools: list[BaseTool]) -> list[BaseTool]:
@@ -33,7 +40,7 @@ def _filter_tools(tools: list[BaseTool], cfg: AgentMcpResourceConfig) -> list[Ba
 async def create_mcp_tools(
     config: AgentMcpResourceConfig | list[AgentMcpResourceConfig],
     max_concurrency: int = 5,
-):
+) -> AsyncGenerator[list[BaseTool], None]:
     """Connect to UiPath MCP server(s) and yield LangChain-compatible tools."""
     if not (base_url := os.getenv("UIPATH_URL")):
         raise ValueError("UIPATH_URL environment variable is not set")
@@ -88,3 +95,79 @@ async def create_session(
         sessions = [(await create_session(stack, cfg), cfg) for cfg in enabled]
         results = await asyncio.gather(*[init_session(s, cfg) for s, cfg in sessions])
         yield _deduplicate_tools(list(chain.from_iterable(results)))
+
+
+async def create_mcp_tools_from_metadata(
+    config: AgentMcpResourceConfig,
+) -> list[BaseTool]:
+    """Create individual StructuredTool instances for each MCP tool in the resource config.
+
+    Each tool manages its own session lifecycle - creating, using, and cleaning up
+    the MCP connection within the tool invocation.
+    """
+
+    if config.is_enabled is False:
+        return []
+
+    sdk = UiPath()
+    mcpServer: McpServer = await sdk.mcp.retrieve_async(
+        slug=config.slug, folder_path=config.folder_path
+    )
+
+    default_client_kwargs = get_httpx_client_kwargs()
+    client_kwargs = {
+        **default_client_kwargs,
+        "headers": {"Authorization": f"Bearer {sdk._config.secret}"},
+        "timeout": httpx.Timeout(600),
+    }
+
+    tools: list[BaseTool] = []
+
+    for mcp_tool in config.available_tools:
+        tool_name = sanitize_tool_name(mcp_tool.name)
+        input_model: Any = create_model(mcp_tool.input_schema)
+
+        def get_tool_coroutine(mcp_tool: Any) -> Any:
+            async def tool_fn(**kwargs: Any) -> Any:
+                """Execute MCP tool call with ephemeral session."""
+                async with AsyncExitStack() as stack:
+                    # Create HTTP client
+                    http_client = await stack.enter_async_context(
+                        httpx.AsyncClient(**client_kwargs)
+                    )
+
+                    # Create streamable connection
+                    read, write, _ = await stack.enter_async_context(
+                        streamable_http_client(
+                            url=f"{mcpServer.mcp_url}", http_client=http_client
+                        )
+                    )
+
+                    # Create and initialize session
+                    session = await stack.enter_async_context(
+                        ClientSession(read, write)
+                    )
+                    await session.initialize()
+
+                    # Call the tool
+                    result = await session.call_tool(mcp_tool.name, arguments=kwargs)
+                    return result.content if hasattr(result, "content") else result
+
+            return tool_fn
+
+        tool = StructuredTool(
+            name=tool_name,
+            description=mcp_tool.description,
+            args_schema=input_model,
+            coroutine=get_tool_coroutine(mcp_tool),
+            metadata={
+                "tool_type": "mcp",
+                "display_name": mcp_tool.name,
+                "folder_path": config.folder_path,
+                "slug": config.slug,
+            },
+        )
+
+        tools.append(tool)
+
+    return tools

src/uipath_langchain/agent/tools/tool_factory.py

@@ -1,5 +1,7 @@
 """Factory functions for creating tools from agent resources."""
 
+from logging import getLogger
+
 from langchain_core.language_models import BaseChatModel
 from langchain_core.tools import BaseTool
 from uipath.agent.models.agent import (
@@ -8,6 +10,7 @@
     AgentIntegrationToolResourceConfig,
     AgentInternalToolResourceConfig,
     AgentIxpExtractionResourceConfig,
+    AgentMcpResourceConfig,
     AgentProcessToolResourceConfig,
     BaseAgentResourceConfig,
     LowCodeAgentDefinition,
@@ -18,25 +21,37 @@
 from .extraction_tool import create_ixp_extraction_tool
 from .integration_tool import create_integration_tool
 from .internal_tools import create_internal_tool
+from .mcp_tool import create_mcp_tools_from_metadata
 from .process_tool import create_process_tool
 
+logger = getLogger(__name__)
+
 
 async def create_tools_from_resources(
     agent: LowCodeAgentDefinition, llm: BaseChatModel
 ) -> list[BaseTool]:
     tools: list[BaseTool] = []
 
+    logger.info("Creating tools for agent '%s' from resources", agent.name)
     for resource in agent.resources:
+        logger.info(
+            "Creating tool for resource '%s' of type '%s'",
+            resource.name,
+            type(resource).__name__,
+        )
         tool = await _build_tool_for_resource(resource, llm)
         if tool is not None:
-            tools.append(tool)
+            if isinstance(tool, list):
+                tools.extend(tool)
+            else:
+                tools.append(tool)
 
     return tools
 
 
 async def _build_tool_for_resource(
     resource: BaseAgentResourceConfig, llm: BaseChatModel
-) -> BaseTool | None:
+) -> BaseTool | list[BaseTool] | None:
     if isinstance(resource, AgentProcessToolResourceConfig):
         return create_process_tool(resource)
 
@@ -55,4 +70,14 @@ async def _build_tool_for_resource(
     elif isinstance(resource, AgentIxpExtractionResourceConfig):
         return create_ixp_extraction_tool(resource)
 
+    elif isinstance(resource, AgentMcpResourceConfig):
+        logger.info(
+            f"Creating MCP tools for MCP server with slug '{resource.slug}' in folder '{resource.folder_path}'"
+        )
+        import json
+
+        logger.info(json.dumps(resource.model_dump()))
+
+        return await create_mcp_tools_from_metadata(resource)
+
     return None