nvidia-nat-mcp 1.3.0a20250910__py3-none-any.whl → 1.5.0a20260117__py3-none-any.whl

nat/plugins/mcp/client_impl.py

@@ -1,229 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-from typing import Literal
-
-from pydantic import BaseModel
-from pydantic import Field
-from pydantic import HttpUrl
-from pydantic import model_validator
-
-from nat.builder.builder import Builder
-from nat.builder.function_info import FunctionInfo
-from nat.cli.register_workflow import register_function
-from nat.data_models.function import FunctionBaseConfig
-from nat.experimental.decorators.experimental_warning_decorator import experimental
-from nat.plugins.mcp.client_base import MCPBaseClient
-
-logger = logging.getLogger(__name__)
-
-
-class MCPToolOverrideConfig(BaseModel):
-    """
-    Configuration for overriding tool properties when exposing from MCP server.
-    """
-    alias: str | None = Field(default=None, description="Override the tool name (function name in the workflow)")
-    description: str | None = Field(default=None, description="Override the tool description")
-
-
-class MCPServerConfig(BaseModel):
-    """
-    Server connection details for MCP client.
-    Supports stdio, sse, and streamable-http transports.
-    streamable-http is the recommended default for HTTP-based connections.
-    """
-    transport: Literal["stdio", "sse", "streamable-http"] = Field(
-        ..., description="Transport type to connect to the MCP server (stdio, sse, or streamable-http)")
-    url: HttpUrl | None = Field(default=None,
-                                description="URL of the MCP server (for sse or streamable-http transport)")
-    command: str | None = Field(default=None,
-                                description="Command to run for stdio transport (e.g. 'python' or 'docker')")
-    args: list[str] | None = Field(default=None, description="Arguments for the stdio command")
-    env: dict[str, str] | None = Field(default=None, description="Environment variables for the stdio process")
-
-    @model_validator(mode="after")
-    def validate_model(self):
-        """Validate that stdio and SSE/Streamable HTTP properties are mutually exclusive."""
-        if self.transport == "stdio":
-            if self.url is not None:
-                raise ValueError("url should not be set when using stdio transport")
-            if not self.command:
-                raise ValueError("command is required when using stdio transport")
-        elif self.transport in ("sse", "streamable-http"):
-            if self.command is not None or self.args is not None or self.env is not None:
-                raise ValueError("command, args, and env should not be set when using sse or streamable-http transport")
-            if not self.url:
-                raise ValueError("url is required when using sse or streamable-http transport")
-        return self
-
-
-class MCPClientConfig(FunctionBaseConfig, name="mcp_client"):
-    """
-    Configuration for connecting to an MCP server as a client and exposing selected tools.
-    """
-    server: MCPServerConfig = Field(..., description="Server connection details (transport, url/command, etc.)")
-    tool_filter: dict[str, MCPToolOverrideConfig] | list[str] | None = Field(
-        default=None,
-        description="""Filter or map tools to expose from the server (list or dict).
-        Can be:
-        - A list of tool names to expose: ['tool1', 'tool2']
-        - A dict mapping tool names to override configs:
-          {'tool1': {'alias': 'new_name', 'description': 'New desc'}}
-          {'tool2': {'description': 'Override description only'}}  # alias defaults to 'tool2'
-        """)
-
-
-class MCPSingleToolConfig(FunctionBaseConfig, name="mcp_single_tool"):
-    """
-    Configuration for wrapping a single tool from an MCP server as a NeMo Agent toolkit function.
-    """
-    client: MCPBaseClient = Field(..., description="MCP client to use for the tool")
-    tool_name: str = Field(..., description="Name of the tool to use")
-    tool_description: str | None = Field(default=None, description="Description of the tool")
-
-    model_config = {"arbitrary_types_allowed": True}
-
-
-def _get_server_name_safe(client: MCPBaseClient) -> str:
-    # Avoid leaking env secrets from stdio client in logs.
-    if client.transport == "stdio":
-        safe_server = f"stdio: {client.command}"
-    else:
-        safe_server = f"{client.transport}: {client.url}"
-
-    return safe_server
-
-
-@register_function(config_type=MCPSingleToolConfig)
-async def mcp_single_tool(config: MCPSingleToolConfig, builder: Builder):
-    """
-    Wrap a single tool from an MCP server as a NeMo Agent toolkit function.
-    """
-    tool = await config.client.get_tool(config.tool_name)
-    if config.tool_description:
-        tool.set_description(description=config.tool_description)
-    input_schema = tool.input_schema
-
-    logger.info("Configured to use tool: %s from MCP server at %s", tool.name, _get_server_name_safe(config.client))
-
-    def _convert_from_str(input_str: str) -> BaseModel:
-        return input_schema.model_validate_json(input_str)
-
-    @experimental(feature_name="mcp_client")
-    async def _response_fn(tool_input: BaseModel | None = None, **kwargs) -> str:
-        try:
-            if tool_input:
-                return await tool.acall(tool_input.model_dump())
-            _ = input_schema.model_validate(kwargs)
-            return await tool.acall(kwargs)
-        except Exception as e:
-            return str(e)
-
-    fn = FunctionInfo.create(single_fn=_response_fn,
-                             description=tool.description,
-                             input_schema=input_schema,
-                             converters=[_convert_from_str])
-    yield fn
-
-
-@register_function(MCPClientConfig)
-async def mcp_client_function_handler(config: MCPClientConfig, builder: Builder):
-    """
-    Connect to an MCP server, discover tools, and register them as functions in the workflow.
-
-    Note:
-    - Uses builder's exit stack to manage client lifecycle
-    - Applies tool filters if provided
-    """
-    from nat.plugins.mcp.client_base import MCPSSEClient
-    from nat.plugins.mcp.client_base import MCPStdioClient
-    from nat.plugins.mcp.client_base import MCPStreamableHTTPClient
-
-    # Build the appropriate client
-    client_cls = {
-        "stdio": lambda: MCPStdioClient(config.server.command, config.server.args, config.server.env),
-        "sse": lambda: MCPSSEClient(str(config.server.url)),
-        "streamable-http": lambda: MCPStreamableHTTPClient(str(config.server.url)),
-    }.get(config.server.transport)
-
-    if not client_cls:
-        raise ValueError(f"Unsupported transport: {config.server.transport}")
-
-    client = client_cls()
-    logger.info("Configured to use MCP server at %s", _get_server_name_safe(client))
-
-    # client aenter connects to the server and stores the client in the exit stack
-    # so it's cleaned up when the workflow is done
-    async with client:
-        all_tools = await client.get_tools()
-        tool_configs = mcp_filter_tools(all_tools, config.tool_filter)
-
-        for tool_name, tool_cfg in tool_configs.items():
-            await builder.add_function(
-                tool_cfg["function_name"],
-                MCPSingleToolConfig(
-                    client=client,
-                    tool_name=tool_name,
-                    tool_description=tool_cfg["description"],
-                ))
-
-        @experimental(feature_name="mcp_client")
-        async def idle_fn(text: str) -> str:
-            # This function is a placeholder and will be removed when function groups are used
-            return f"MCP client connected: {text}"
-
-        yield FunctionInfo.create(single_fn=idle_fn, description="MCP client")
-
-
-def mcp_filter_tools(all_tools: dict, tool_filter) -> dict[str, dict]:
-    """
-    Apply tool filtering and optional aliasing/description overrides.
-
-    Returns:
-        Dict[str, dict] where each value has:
-            - function_name
-            - description
-    """
-    if tool_filter is None:
-        return {name: {"function_name": name, "description": tool.description} for name, tool in all_tools.items()}
-
-    if isinstance(tool_filter, list):
-        return {
-            name: {
-                "function_name": name, "description": all_tools[name].description
-            }
-            for name in tool_filter if name in all_tools
-        }
-
-    if isinstance(tool_filter, dict):
-        result = {}
-        for name, override in tool_filter.items():
-            tool = all_tools.get(name)
-            if not tool:
-                logger.warning("Tool '%s' specified in tool_filter not found in MCP server", name)
-                continue
-
-            if isinstance(override, MCPToolOverrideConfig):
-                result[name] = {
-                    "function_name": override.alias or name, "description": override.description or tool.description
-                }
-            else:
-                logger.warning("Unsupported override type for '%s': %s", name, type(override))
-                result[name] = {"function_name": name, "description": tool.description}
-        return result
-
-    # Fallback for unsupported tool_filter types
-    raise ValueError(f"Unsupported tool_filter type: {type(tool_filter)}")

nat/plugins/mcp/tool.py

@@ -1,133 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-from typing import Literal
-
-from pydantic import BaseModel
-from pydantic import Field
-from pydantic import HttpUrl
-from pydantic import model_validator
-
-from nat.builder.builder import Builder
-from nat.builder.function_info import FunctionInfo
-from nat.cli.register_workflow import register_function
-from nat.data_models.function import FunctionBaseConfig
-
-logger = logging.getLogger(__name__)
-
-
-class MCPToolConfig(FunctionBaseConfig, name="mcp_tool_wrapper"):
-    """
-    Function which connects to a Model Context Protocol (MCP) server and wraps the selected tool as a NeMo Agent toolkit
-    function.
-    """
-    # Add your custom configuration parameters here
-    url: HttpUrl | None = Field(default=None,
-                                description="The URL of the MCP server (for streamable-http or sse modes)")
-    mcp_tool_name: str = Field(description="The name of the tool served by the MCP Server that you want to use")
-    transport: Literal["sse", "stdio", "streamable-http"] = Field(
-        default="streamable-http",
-        description="The type of transport to use (default: streamable-http, backwards compatible with sse)")
-    command: str | None = Field(default=None,
-                                description="The command to run for stdio mode (e.g. 'docker' or 'python')")
-    args: list[str] | None = Field(default=None, description="Additional arguments for the stdio command")
-    env: dict[str, str] | None = Field(default=None, description="Environment variables to set for the stdio process")
-    description: str | None = Field(default=None,
-                                    description="""
-        Description for the tool that will override the description provided by the MCP server. Should only be used if
-        the description provided by the server is poor or nonexistent
-        """)
-    return_exception: bool = Field(default=True,
-                                   description="""
-        If true, the tool will return the exception message if the tool call fails.
-        If false, raise the exception.
-        """)
-
-    @model_validator(mode="after")
-    def validate_model(self):
-        """Validate that stdio and SSE/Streamable HTTP properties are mutually exclusive."""
-        if self.transport == 'stdio':
-            if self.url is not None:
-                raise ValueError("url should not be set when using stdio client type")
-            if not self.command:
-                raise ValueError("command is required when using stdio client type")
-        elif self.transport in ['streamable-http', 'sse']:
-            if self.command is not None or self.args is not None or self.env is not None:
-                raise ValueError(
-                    "command, args, and env should not be set when using streamable-http or sse client type")
-            if not self.url:
-                raise ValueError("url is required when using streamable-http or sse client type")
-        return self
-
-
-@register_function(config_type=MCPToolConfig)
-async def mcp_tool(config: MCPToolConfig, builder: Builder):
-    """
-    Generate a NeMo Agent Toolkit Function that wraps a tool provided by the MCP server.
-    """
-
-    from nat.plugins.mcp.client_base import MCPSSEClient
-    from nat.plugins.mcp.client_base import MCPStdioClient
-    from nat.plugins.mcp.client_base import MCPStreamableHTTPClient
-    from nat.plugins.mcp.client_base import MCPToolClient
-
-    # Initialize the client
-    if config.transport == 'stdio':
-        client = MCPStdioClient(command=config.command, args=config.args, env=config.env)
-    elif config.transport == 'streamable-http':
-        client = MCPStreamableHTTPClient(url=str(config.url))
-    elif config.transport == 'sse':
-        client = MCPSSEClient(url=str(config.url))
-    else:
-        raise ValueError(f"Invalid transport type: {config.transport}")
-
-    async with client:
-        # If the tool is found create a MCPToolClient object and set the description if provided
-        tool: MCPToolClient = await client.get_tool(config.mcp_tool_name)
-        if config.description:
-            tool.set_description(description=config.description)
-
-        logger.info("Configured to use tool: %s from MCP server at %s", tool.name, client.server_name)
-
-        def _convert_from_str(input_str: str) -> tool.input_schema:
-            return tool.input_schema.model_validate_json(input_str)
-
-        async def _response_fn(tool_input: BaseModel | None = None, **kwargs) -> str:
-            # Run the tool, catching any errors and sending to agent for correction
-            try:
-                if tool_input:
-                    args = tool_input.model_dump()
-                    return await tool.acall(args)
-
-                _ = tool.input_schema.model_validate(kwargs)
-                return await tool.acall(kwargs)
-            except Exception as e:
-                if config.return_exception:
-                    if tool_input:
-                        logger.warning("Error calling tool %s with serialized input: %s",
-                                       tool.name,
-                                       tool_input.model_dump(),
-                                       exc_info=True)
-                    else:
-                        logger.warning("Error calling tool %s with input: %s", tool.name, kwargs, exc_info=True)
-                    return str(e)
-                # If the tool call fails, raise the exception.
-                raise
-
-        yield FunctionInfo.create(single_fn=_response_fn,
-                                  description=tool.description,
-                                  input_schema=tool.input_schema,
-                                  converters=[_convert_from_str])

nvidia_nat_mcp-1.3.0a20250910.dist-info/RECORD

@@ -1,13 +0,0 @@
-nat/meta/pypi.md,sha256=GyV4DI1d9ThgEhnYTQ0vh40Q9hPC8jN-goLnRiFDmZ8,1498
-nat/plugins/mcp/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
-nat/plugins/mcp/client_base.py,sha256=4vFOBFoSpLpkq7r2iXDMbi6tDj02JBidZo5RiBR167w,13424
-nat/plugins/mcp/client_impl.py,sha256=6rG3LcCX4TFsiST5O0_C8eOpY9LdnoSMarfAWeR76XA,9724
-nat/plugins/mcp/exception_handler.py,sha256=JdPdZG1NgWpdRnIz7JTGHiJASS5wot9nJiD3SRWV4Kw,7649
-nat/plugins/mcp/exceptions.py,sha256=EGVOnYlui8xufm8dhJyPL1SUqBLnCGOTvRoeyNcmcWE,5980
-nat/plugins/mcp/register.py,sha256=HOT2Wl2isGuyFc7BUTi58-BbjI5-EtZMZo7stsv5pN4,831
-nat/plugins/mcp/tool.py,sha256=MSRnnr1a6OjfqVkt2SYPkfLi9lU0JqovIZuTOL1cgHQ,6378
-nvidia_nat_mcp-1.3.0a20250910.dist-info/METADATA,sha256=nZU24irAcgdYvg6UOdvSSgh1NHt8-iShmC-7O_sJGpQ,1997
-nvidia_nat_mcp-1.3.0a20250910.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat_mcp-1.3.0a20250910.dist-info/entry_points.txt,sha256=x7dQTqek3GEdU-y9GslnygxMu0BSbEeUiOOMa2gvaaQ,52
-nvidia_nat_mcp-1.3.0a20250910.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
-nvidia_nat_mcp-1.3.0a20250910.dist-info/RECORD,,

nvidia_nat_mcp-1.3.0a20250910.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[nat.components]
-nat_mcp = nat.plugins.mcp.register