nvidia-nat 1.2.0__py3-none-any.whl

nat/front_ends/mcp/mcp_front_end_plugin_worker.py

@@ -0,0 +1,143 @@
+# 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 abc import ABC
+from abc import abstractmethod
+
+from mcp.server.fastmcp import FastMCP
+from starlette.requests import Request
+
+from nat.builder.function import Function
+from nat.builder.workflow import Workflow
+from nat.builder.workflow_builder import WorkflowBuilder
+from nat.data_models.config import Config
+from nat.front_ends.mcp.mcp_front_end_config import MCPFrontEndConfig
+
+logger = logging.getLogger(__name__)
+
+
+class MCPFrontEndPluginWorkerBase(ABC):
+    """Base class for MCP front end plugin workers."""
+
+    def __init__(self, config: Config):
+        """Initialize the MCP worker with configuration.
+
+        Args:
+            config: The full NAT configuration
+        """
+        self.full_config = config
+        self.front_end_config: MCPFrontEndConfig = config.general.front_end
+
+    def _setup_health_endpoint(self, mcp: FastMCP):
+        """Set up the HTTP health endpoint that exercises MCP ping handler."""
+
+        @mcp.custom_route("/health", methods=["GET"])
+        async def health_check(_request: Request):
+            """HTTP health check using server's internal ping handler"""
+            from starlette.responses import JSONResponse
+
+            try:
+                from mcp.types import PingRequest
+
+                # Create a ping request
+                ping_request = PingRequest(method="ping")
+
+                # Call the ping handler directly (same one that responds to MCP pings)
+                await mcp._mcp_server.request_handlers[PingRequest](ping_request)
+
+                return JSONResponse({
+                    "status": "healthy",
+                    "error": None,
+                    "server_name": mcp.name,
+                })
+
+            except Exception as e:
+                return JSONResponse({
+                    "status": "unhealthy",
+                    "error": str(e),
+                    "server_name": mcp.name,
+                },
+                                    status_code=503)
+
+    @abstractmethod
+    async def add_routes(self, mcp: FastMCP, builder: WorkflowBuilder):
+        """Add routes to the MCP server.
+
+        Args:
+            mcp: The FastMCP server instance
+            builder (WorkflowBuilder): The workflow builder instance
+        """
+        pass
+
+    def _get_all_functions(self, workflow: Workflow) -> dict[str, Function]:
+        """Get all functions from the workflow.
+
+        Args:
+            workflow: The NAT workflow.
+
+        Returns:
+            Dict mapping function names to Function objects.
+        """
+        functions: dict[str, Function] = {}
+
+        # Extract all functions from the workflow
+        for function_name, function in workflow.functions.items():
+            functions[function_name] = function
+
+        functions[workflow.config.workflow.type] = workflow
+
+        return functions
+
+
+class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
+    """Default MCP front end plugin worker implementation."""
+
+    async def add_routes(self, mcp: FastMCP, builder: WorkflowBuilder):
+        """Add default routes to the MCP server.
+
+        Args:
+            mcp: The FastMCP server instance
+            builder (WorkflowBuilder): The workflow builder instance
+        """
+        from nat.front_ends.mcp.tool_converter import register_function_with_mcp
+
+        # Set up the health endpoint
+        self._setup_health_endpoint(mcp)
+
+        # Build the workflow and register all functions with MCP
+        workflow = builder.build()
+
+        # Get all functions from the workflow
+        functions = self._get_all_functions(workflow)
+
+        # Filter functions based on tool_names if provided
+        if self.front_end_config.tool_names:
+            logger.info("Filtering functions based on tool_names: %s", self.front_end_config.tool_names)
+            filtered_functions: dict[str, Function] = {}
+            for function_name, function in functions.items():
+                if function_name in self.front_end_config.tool_names:
+                    filtered_functions[function_name] = function
+                else:
+                    logger.debug("Skipping function %s as it's not in tool_names", function_name)
+            functions = filtered_functions
+
+        # Register each function with MCP
+        for function_name, function in functions.items():
+            register_function_with_mcp(mcp, function_name, function)
+
+        # Add a simple fallback function if no functions were found
+        if not functions:
+            raise RuntimeError("No functions found in workflow. Please check your configuration.")

nat/front_ends/mcp/register.py

@@ -0,0 +1,27 @@
+# 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.
+
+from collections.abc import AsyncIterator
+
+from nat.cli.register_workflow import register_front_end
+from nat.data_models.config import Config
+from nat.front_ends.mcp.mcp_front_end_config import MCPFrontEndConfig
+
+
+@register_front_end(config_type=MCPFrontEndConfig)
+async def register_mcp_front_end(config: MCPFrontEndConfig, full_config: Config) -> AsyncIterator:
+    from nat.front_ends.mcp.mcp_front_end_plugin import MCPFrontEndPlugin
+
+    yield MCPFrontEndPlugin(full_config=full_config)

nat/front_ends/mcp/tool_converter.py

@@ -0,0 +1,241 @@
+# 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 json
+import logging
+from inspect import Parameter
+from inspect import Signature
+
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel
+
+from nat.builder.function import Function
+from nat.builder.function_base import FunctionBase
+from nat.builder.workflow import Workflow
+
+logger = logging.getLogger(__name__)
+
+
+def create_function_wrapper(
+    function_name: str,
+    function: FunctionBase,
+    schema: type[BaseModel],
+    is_workflow: bool = False,
+):
+    """Create a wrapper function that exposes the actual parameters of a NAT Function as an MCP tool.
+
+    Args:
+        function_name: The name of the function/tool
+        function: The NAT Function object
+        schema: The input schema of the function
+        is_workflow: Whether the function is a Workflow
+
+    Returns:
+        A wrapper function suitable for registration with MCP
+    """
+    # Check if we're dealing with ChatRequest - special case
+    is_chat_request = False
+
+    # Check if the schema name is ChatRequest
+    if schema.__name__ == "ChatRequest" or (hasattr(schema, "__qualname__") and "ChatRequest" in schema.__qualname__):
+        is_chat_request = True
+        logger.info("Function %s uses ChatRequest - creating simplified interface", function_name)
+
+        # For ChatRequest, we'll create a simple wrapper with just a query parameter
+        parameters = [Parameter(
+            name="query",
+            kind=Parameter.KEYWORD_ONLY,
+            default=Parameter.empty,
+            annotation=str,
+        )]
+    else:
+        # Regular case - extract parameter information from the input schema
+        # Extract parameter information from the input schema
+        param_fields = schema.model_fields
+
+        parameters = []
+        for name, field in param_fields.items():
+            # Get the field type and convert to appropriate Python type
+            field_type = field.annotation
+
+            # Add the parameter to our list
+            parameters.append(
+                Parameter(
+                    name=name,
+                    kind=Parameter.KEYWORD_ONLY,
+                    default=Parameter.empty if field.is_required else None,
+                    annotation=field_type,
+                ))
+
+    # Create the function signature WITHOUT the ctx parameter
+    # We'll handle this in the wrapper function internally
+    sig = Signature(parameters=parameters, return_annotation=str)
+
+    # Define the actual wrapper function that accepts ctx but doesn't expose it
+    def create_wrapper():
+
+        async def wrapper_with_ctx(**kwargs):
+            """Internal wrapper that will be called by MCP."""
+            # MCP will add a ctx parameter, extract it
+            ctx = kwargs.get("ctx")
+
+            # Remove ctx if present
+            if "ctx" in kwargs:
+                del kwargs["ctx"]
+
+            # Process the function call
+            if ctx:
+                ctx.info("Calling function %s with args: %s", function_name, json.dumps(kwargs, default=str))
+                await ctx.report_progress(0, 100)
+
+            try:
+                # Special handling for ChatRequest
+                if is_chat_request:
+                    from nat.data_models.api_server import ChatRequest
+
+                    # Create a chat request from the query string
+                    query = kwargs.get("query", "")
+                    chat_request = ChatRequest.from_string(query)
+
+                    # Special handling for Workflow objects
+                    if is_workflow:
+                        # Workflows have a run method that is an async context manager
+                        # that returns a Runner
+                        async with function.run(chat_request) as runner:
+                            # Get the result from the runner
+                            result = await runner.result(to_type=str)
+                    else:
+                        # Regular functions use ainvoke
+                        result = await function.ainvoke(chat_request, to_type=str)
+                else:
+                    # Regular handling
+                    # Handle complex input schema - if we extracted fields from a nested schema,
+                    # we need to reconstruct the input
+                    if len(schema.model_fields) == 1 and len(parameters) > 1:
+                        # Get the field name from the original schema
+                        field_name = next(iter(schema.model_fields.keys()))
+                        field_type = schema.model_fields[field_name].annotation
+
+                        # If it's a pydantic model, we need to create an instance
+                        if hasattr(field_type, "model_validate"):
+                            # Create the nested object
+                            nested_obj = field_type.model_validate(kwargs)
+                            # Call with the nested object
+                            kwargs = {field_name: nested_obj}
+
+                    # Call the NAT function with the parameters - special handling for Workflow
+                    if is_workflow:
+                        # For workflow with regular input, we'll assume the first parameter is the input
+                        input_value = list(kwargs.values())[0] if kwargs else ""
+
+                        # Workflows have a run method that is an async context manager
+                        # that returns a Runner
+                        async with function.run(input_value) as runner:
+                            # Get the result from the runner
+                            result = await runner.result(to_type=str)
+                    else:
+                        # Regular function call
+                        result = await function.acall_invoke(**kwargs)
+
+                # Report completion
+                if ctx:
+                    await ctx.report_progress(100, 100)
+
+                # Handle different result types for proper formatting
+                if isinstance(result, str):
+                    return result
+                if isinstance(result, (dict, list)):
+                    return json.dumps(result, default=str)
+                return str(result)
+            except Exception as e:
+                if ctx:
+                    ctx.error("Error calling function %s: %s", function_name, str(e))
+                raise
+
+        return wrapper_with_ctx
+
+    # Create the wrapper function
+    wrapper = create_wrapper()
+
+    # Set the signature on the wrapper function (WITHOUT ctx)
+    wrapper.__signature__ = sig
+    wrapper.__name__ = function_name
+
+    # Return the wrapper with proper signature
+    return wrapper
+
+
+def get_function_description(function: FunctionBase) -> str:
+    """
+    Retrieve a human-readable description for a NAT function or workflow.
+
+    The description is determined using the following precedence:
+       1. If the function is a Workflow and has a 'description' attribute, use it.
+       2. If the Workflow's config has a 'topic', use it.
+       3. If the Workflow's config has a 'description', use it.
+       4. If the function is a regular Function, use its 'description' attribute.
+
+    Args:
+        function: The NAT FunctionBase instance (Function or Workflow).
+
+    Returns:
+        The best available description string for the function.
+    """
+    function_description = ""
+
+    if isinstance(function, Workflow):
+        config = function.config
+
+        # Workflow doesn't have a description, but probably should
+        if hasattr(function, "description") and function.description:
+            function_description = function.description
+        # Try to get description from config
+        elif hasattr(config, "description") and config.description:
+            function_description = config.description
+        # Try to get anything that might be a description
+        elif hasattr(config, "topic") and config.topic:
+            function_description = config.topic
+
+    elif isinstance(function, Function):
+        function_description = function.description
+
+    return function_description
+
+
+def register_function_with_mcp(mcp: FastMCP, function_name: str, function: FunctionBase) -> None:
+    """Register a NAT Function as an MCP tool.
+
+    Args:
+        mcp: The FastMCP instance
+        function_name: The name to register the function under
+        function: The NAT Function to register
+    """
+    logger.info("Registering function %s with MCP", function_name)
+
+    # Get the input schema from the function
+    input_schema = function.input_schema
+    logger.info("Function %s has input schema: %s", function_name, input_schema)
+
+    # Check if we're dealing with a Workflow
+    is_workflow = isinstance(function, Workflow)
+    if is_workflow:
+        logger.info("Function %s is a Workflow", function_name)
+
+    # Get function description
+    function_description = get_function_description(function)
+
+    # Create and register the wrapper function with MCP
+    wrapper_func = create_function_wrapper(function_name, function, input_schema, is_workflow)
+    mcp.tool(name=function_name, description=function_description)(wrapper_func)

nat/front_ends/register.py

@@ -0,0 +1,22 @@
+# 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.
+
+# pylint: disable=unused-import
+# flake8: noqa
+# isort:skip_file
+
+from .console import register as console_register
+from .fastapi import register as fastapi_register
+from .mcp import register as mcp_register

nat/front_ends/simple_base/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-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.

nat/front_ends/simple_base/simple_front_end_plugin_base.py

@@ -0,0 +1,54 @@
+# 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 abc import ABC
+from abc import abstractmethod
+from io import StringIO
+
+import click
+
+from nat.builder.front_end import FrontEndBase
+from nat.builder.workflow_builder import WorkflowBuilder
+from nat.data_models.front_end import FrontEndConfigT
+from nat.runtime.session import SessionManager
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleFrontEndPluginBase(FrontEndBase[FrontEndConfigT], ABC):
+
+    async def pre_run(self):
+        pass
+
+    async def run(self):
+
+        # Must yield the workflow function otherwise it cleans up
+        async with WorkflowBuilder.from_config(config=self.full_config) as builder:
+
+            if logger.isEnabledFor(logging.INFO):
+                stream = StringIO()
+
+                self.full_config.print_summary(stream=stream)
+
+                click.echo(stream.getvalue())
+
+            workflow = builder.build()
+            session_manager = SessionManager(workflow)
+            await self.run_workflow(session_manager)
+
+    @abstractmethod
+    async def run_workflow(self, session_manager: SessionManager):
+        pass

nat/llm/aws_bedrock_llm.py

@@ -0,0 +1,57 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-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.
+
+from pydantic import AliasChoices
+from pydantic import ConfigDict
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.llm import LLMProviderInfo
+from nat.cli.register_workflow import register_llm_provider
+from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.retry_mixin import RetryMixin
+
+
+class AWSBedrockModelConfig(LLMBaseConfig, RetryMixin, name="aws_bedrock"):
+    """An AWS Bedrock llm provider to be used with an LLM client."""
+
+    model_config = ConfigDict(protected_namespaces=())
+
+    # Completion parameters
+    model_name: str = Field(validation_alias=AliasChoices("model_name", "model"),
+                            serialization_alias="model",
+                            description="The model name for the hosted AWS Bedrock.")
+    temperature: float = Field(default=0.0, ge=0.0, le=1.0, description="Sampling temperature in [0, 1].")
+    max_tokens: int | None = Field(default=1024,
+                                   gt=0,
+                                   description="Maximum number of tokens to generate."
+                                   "This field is ONLY required when using AWS Bedrock with Langchain.")
+    context_size: int | None = Field(default=1024,
+                                     gt=0,
+                                     description="Maximum number of tokens to generate."
+                                     "This field is ONLY required when using AWS Bedrock with LlamaIndex.")
+
+    # Client parameters
+    region_name: str | None = Field(default="None", description="AWS region to use.")
+    base_url: str | None = Field(
+        default=None, description="Bedrock endpoint to use. Needed if you don't want to default to us-east-1 endpoint.")
+    credentials_profile_name: str | None = Field(
+        default=None, description="The name of the profile in the ~/.aws/credentials or ~/.aws/config files.")
+
+
+@register_llm_provider(config_type=AWSBedrockModelConfig)
+async def aws_bedrock_model(llm_config: AWSBedrockModelConfig, builder: Builder):
+
+    yield LLMProviderInfo(config=llm_config, description="A AWS Bedrock model for use with an LLM client.")

nat/llm/nim_llm.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-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.
+
+from pydantic import AliasChoices
+from pydantic import ConfigDict
+from pydantic import Field
+from pydantic import PositiveInt
+
+from nat.builder.builder import Builder
+from nat.builder.llm import LLMProviderInfo
+from nat.cli.register_workflow import register_llm_provider
+from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.retry_mixin import RetryMixin
+
+
+class NIMModelConfig(LLMBaseConfig, RetryMixin, name="nim"):
+    """An NVIDIA Inference Microservice (NIM) llm provider to be used with an LLM client."""
+
+    model_config = ConfigDict(protected_namespaces=())
+
+    api_key: str | None = Field(default=None, description="NVIDIA API key to interact with hosted NIM.")
+    base_url: str | None = Field(default=None, description="Base url to the hosted NIM.")
+    model_name: str = Field(validation_alias=AliasChoices("model_name", "model"),
+                            serialization_alias="model",
+                            description="The model name for the hosted NIM.")
+    temperature: float = Field(default=0.0, description="Sampling temperature in [0, 1].")
+    top_p: float = Field(default=1.0, description="Top-p for distribution sampling.")
+    max_tokens: PositiveInt = Field(default=300, description="Maximum number of tokens to generate.")
+
+
+@register_llm_provider(config_type=NIMModelConfig)
+async def nim_model(llm_config: NIMModelConfig, builder: Builder):
+
+    yield LLMProviderInfo(config=llm_config, description="A NIM model for use with an LLM client.")

nat/llm/openai_llm.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-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.
+
+from pydantic import AliasChoices
+from pydantic import ConfigDict
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.llm import LLMProviderInfo
+from nat.cli.register_workflow import register_llm_provider
+from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.retry_mixin import RetryMixin
+
+
+class OpenAIModelConfig(LLMBaseConfig, RetryMixin, name="openai"):
+    """An OpenAI LLM provider to be used with an LLM client."""
+
+    model_config = ConfigDict(protected_namespaces=(), extra="allow")
+
+    api_key: str | None = Field(default=None, description="OpenAI API key to interact with hosted model.")
+    base_url: str | None = Field(default=None, description="Base url to the hosted model.")
+    model_name: str = Field(validation_alias=AliasChoices("model_name", "model"),
+                            serialization_alias="model",
+                            description="The OpenAI hosted model name.")
+    temperature: float = Field(default=0.0, description="Sampling temperature in [0, 1].")
+    top_p: float = Field(default=1.0, description="Top-p for distribution sampling.")
+    seed: int | None = Field(default=None, description="Random seed to set for generation.")
+    max_retries: int = Field(default=10, description="The max number of retries for the request.")
+
+
+@register_llm_provider(config_type=OpenAIModelConfig)
+async def openai_llm(config: OpenAIModelConfig, builder: Builder):
+
+    yield LLMProviderInfo(config=config, description="An OpenAI model for use with an LLM client.")

nat/llm/register.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-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.
+
+# pylint: disable=unused-import
+# flake8: noqa
+# isort:skip_file
+
+# Import any providers which need to be automatically registered here
+from . import aws_bedrock_llm
+from . import nim_llm
+from . import openai_llm