nvidia-nat 1.3.0a20250828__py3-none-any.whl → 1.3.0a20250830__py3-none-any.whl

nat/tool/mcp/mcp_tool.py

@@ -14,10 +14,12 @@
 # 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
@@ -33,8 +35,16 @@ class MCPToolConfig(FunctionBaseConfig, name="mcp_tool_wrapper"):
     function.
     """
     # Add your custom configuration parameters here
-    url: HttpUrl = Field(description="The URL of the MCP server")
+    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
@@ -46,51 +56,78 @@ class MCPToolConfig(FunctionBaseConfig, name="mcp_tool_wrapper"):
         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 NAT Function that wraps a tool provided by the MCP server.
+    Generate a NeMo Agent Toolkit Function that wraps a tool provided by the MCP server.
     """
 
-    from nat.tool.mcp.mcp_client import MCPBuilder
-    from nat.tool.mcp.mcp_client import MCPToolClient
-
-    client = MCPBuilder(url=str(config.url))
-
-    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, str(config.url))
-
-    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)
-            filtered_kwargs = {k: v for k, v in kwargs.items() if v is not None}
-            return await tool.acall(filtered_kwargs)
-        except Exception as e:
-            if config.return_exception:
+    from nat.tool.mcp.mcp_client_base import MCPSSEClient
+    from nat.tool.mcp.mcp_client_base import MCPStdioClient
+    from nat.tool.mcp.mcp_client_base import MCPStreamableHTTPClient
+    from nat.tool.mcp.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:
-                    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])
+                    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])

nat/tool/nvidia_rag.py

@@ -86,7 +86,7 @@ async def nvidia_rag_tool(config: NVIDIARAGToolConfig, builder: Builder):
                     [await aformat_document(doc, document_prompt) for doc in docs])
                 return parsed_output
             except Exception as e:
-                logger.exception("Error while running the tool", exc_info=True)
+                logger.exception("Error while running the tool")
                 return f"Error while running the tool: {e}"
 
         yield FunctionInfo.from_fn(

nat/tool/register.py

@@ -31,6 +31,7 @@ from .github_tools import get_github_file
 from .github_tools import get_github_issue
 from .github_tools import get_github_pr
 from .github_tools import update_github_issue
+from .mcp import mcp_client_impl
 from .mcp import mcp_tool
 from .memory_tools import add_memory_tool
 from .memory_tools import delete_memory_tool

nat/tool/retriever.py

@@ -78,8 +78,9 @@ async def retriever_tool(config: RetrieverConfig, builder: Builder):
 
         except RetrieverError as e:
             if config.raise_errors:
-                raise e
-            logger.warning("Retriever threw an error: %s. Returning an empty response.", e)
+                logger.error("Retriever threw an error: %s.", e)
+                raise
+            logger.exception("Retriever threw an error: %s. Returning an empty response.", e)
             return RetrieverOutput(results=[])
 
     yield FunctionInfo.from_fn(

nat/utils/io/yaml_tools.py

@@ -85,7 +85,7 @@ def yaml_loads(config: str) -> dict:
     try:
         config_data = yaml.safe_load(stream)
     except yaml.YAMLError as e:
-        logger.error("Error loading YAML: %s", interpolated_config_str, exc_info=True)
+        logger.error("Error loading YAML: %s", interpolated_config_str)
         raise ValueError(f"Error loading YAML: {e}") from e
 
     assert isinstance(config_data, dict)

nat/utils/reactive/observer.py

@@ -64,7 +64,7 @@ class Observer(ObserverBase[_T_in_contra]):
                 try:
                     self._on_error(exc)
                 except Exception as e:
-                    logger.exception("Error in on_error callback: %s", e, exc_info=True)
+                    logger.exception("Error in on_error callback: %s", e)
 
     def on_complete(self) -> None:
         if not self._stopped:
@@ -73,4 +73,4 @@ class Observer(ObserverBase[_T_in_contra]):
                 try:
                     self._on_complete()
                 except Exception as e:
-                    logger.exception("Error in on_complete callback: %s", e, exc_info=True)
+                    logger.exception("Error in on_complete callback: %s", e)

nat/utils/settings/global_settings.py

@@ -55,7 +55,7 @@ def configure_registry_channel(config_type: RegistryHandlerBaseConfig, channel_n
                 channel_registry_pre[field] = getattr(validated_field_model, field)
                 break
             except Exception as e:
-                logger.exception(e, exc_info=True)
+                logger.exception(e)
                 logger.warning("Invalid '%s' input, input must be of type %s.", field, info.annotation)
 
     validated_model = config_type(**channel_registry_pre)
@@ -78,7 +78,7 @@ def add_channel_interative(channel_type: str) -> None:
     try:
         ChannelConfigType = registry.get_registered_channel_info_by_channel_type(channel_type=channel_type).config_type
     except Exception as e:
-        logger.exception("Invalid channel type: %s", e, exc_info=True)
+        logger.exception("Invalid channel type: %s", e)
         return
 
     while (True):

{nvidia_nat-1.3.0a20250828.dist-info → nvidia_nat-1.3.0a20250830.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.3.0a20250828
+Version: 1.3.0a20250830
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -221,7 +221,7 @@ Requires-Dist: fastapi~=0.115.5
 Requires-Dist: httpx~=0.27
 Requires-Dist: jinja2~=3.1
 Requires-Dist: jsonpath-ng~=1.7
-Requires-Dist: mcp~=1.10
+Requires-Dist: mcp~=1.13
 Requires-Dist: networkx~=3.4
 Requires-Dist: numpy~=1.26
 Requires-Dist: openinference-semantic-conventions~=0.1.14
@@ -229,7 +229,7 @@ Requires-Dist: openpyxl~=3.1
 Requires-Dist: pkce==1.0.3
 Requires-Dist: pkginfo~=1.12
 Requires-Dist: platformdirs~=4.3
-Requires-Dist: pydantic==2.10.*
+Requires-Dist: pydantic~=2.11
 Requires-Dist: pymilvus~=2.4
 Requires-Dist: PyYAML~=6.0
 Requires-Dist: ragas~=0.2.14