nvidia-nat 1.1.0a20251020__py3-none-any.whl

nat/front_ends/mcp/tool_converter.py

@@ -0,0 +1,290 @@
+# 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 typing import TYPE_CHECKING
+
+from mcp.server.fastmcp import FastMCP
+from pydantic import BaseModel
+
+from nat.builder.context import ContextState
+from nat.builder.function import Function
+from nat.builder.function_base import FunctionBase
+
+if TYPE_CHECKING:
+    from nat.builder.workflow import Workflow
+    from nat.front_ends.mcp.memory_profiler import MemoryProfiler
+
+logger = logging.getLogger(__name__)
+
+
+def create_function_wrapper(
+    function_name: str,
+    function: FunctionBase,
+    schema: type[BaseModel],
+    is_workflow: bool = False,
+    workflow: 'Workflow | None' = None,
+    memory_profiler: 'MemoryProfiler | None' = None,
+):
+    """Create a wrapper function that exposes the actual parameters of a NAT Function as an MCP tool.
+
+    Args:
+        function_name (str): The name of the function/tool
+        function (FunctionBase): The NAT Function object
+        schema (type[BaseModel]): The input schema of the function
+        is_workflow (bool): Whether the function is a Workflow
+        workflow (Workflow | None): The parent workflow for observability context
+        memory_profiler: Optional memory profiler to track requests
+
+    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:
+                # Helper function to wrap function calls with observability
+                async def call_with_observability(func_call):
+                    # Use workflow's observability context (workflow should always be available)
+                    if not workflow:
+                        logger.error("Missing workflow context for function %s - observability will not be available",
+                                     function_name)
+                        raise RuntimeError("Workflow context is required for observability")
+
+                    logger.debug("Starting observability context for function %s", function_name)
+                    context_state = ContextState.get()
+                    async with workflow.exporter_manager.start(context_state=context_state):
+                        return await func_call()
+
+                # 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 call_with_observability(lambda: 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 field_type and 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 call_with_observability(lambda: function.acall_invoke(**kwargs))
+
+                # Report completion
+                if ctx:
+                    await ctx.report_progress(100, 100)
+
+                # Track request completion for memory profiling
+                if memory_profiler:
+                    memory_profiler.on_request_complete()
+
+                # 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))
+
+                # Track request completion even on error
+                if memory_profiler:
+                    memory_profiler.on_request_complete()
+
+                raise
+
+        return wrapper_with_ctx
+
+    # Create the wrapper function
+    wrapper = create_wrapper()
+
+    # Set the signature on the wrapper function (WITHOUT ctx)
+    wrapper.__signature__ = sig  # type: ignore
+    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 'description', use it.
+       3. If the Workflow's config has a 'topic', 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 = ""
+
+    # Import here to avoid circular imports
+    from nat.builder.workflow import Workflow
+
+    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
+        # Try to get description from the workflow config
+        elif hasattr(config, "workflow") and hasattr(config.workflow, "description") and config.workflow.description:
+            function_description = config.workflow.description
+
+    elif isinstance(function, Function):
+        function_description = function.description
+
+    return function_description
+
+
+def register_function_with_mcp(mcp: FastMCP,
+                               function_name: str,
+                               function: FunctionBase,
+                               workflow: 'Workflow | None' = None,
+                               memory_profiler: 'MemoryProfiler | None' = None) -> 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
+        workflow: The parent workflow for observability context (if available)
+        memory_profiler: Optional memory profiler to track requests
+    """
+    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
+    from nat.builder.workflow import 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,
+                                           workflow,
+                                           memory_profiler)
+    mcp.tool(name=function_name, description=function_description)(wrapper_func)

nat/front_ends/register.py

@@ -0,0 +1,21 @@
+# 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.
+
+# 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,56 @@
+# 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):
+
+        await self.pre_run()
+
+        # 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 = await 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,69 @@
+# 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.optimizable import OptimizableField
+from nat.data_models.optimizable import OptimizableMixin
+from nat.data_models.optimizable import SearchSpace
+from nat.data_models.retry_mixin import RetryMixin
+from nat.data_models.temperature_mixin import TemperatureMixin
+from nat.data_models.thinking_mixin import ThinkingMixin
+from nat.data_models.top_p_mixin import TopPMixin
+
+
+class AWSBedrockModelConfig(LLMBaseConfig,
+                            RetryMixin,
+                            OptimizableMixin,
+                            TemperatureMixin,
+                            TopPMixin,
+                            ThinkingMixin,
+                            name="aws_bedrock"):
+    """An AWS Bedrock llm provider to be used with an LLM client."""
+
+    model_config = ConfigDict(protected_namespaces=(), extra="allow")
+
+    # Completion parameters
+    model_name: str = Field(validation_alias=AliasChoices("model_name", "model"),
+                            serialization_alias="model",
+                            description="The model name for the hosted AWS Bedrock.")
+    max_tokens: int = OptimizableField(default=300,
+                                       description="Maximum number of tokens to generate.",
+                                       space=SearchSpace(high=2176, low=128, step=512))
+    context_size: int | None = Field(
+        default=1024,
+        gt=0,
+        description="The maximum number of tokens available for input. This is only required for LlamaIndex. "
+        "This field is ignored for LangChain/LangGraph.",
+    )
+
+    # 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/azure_openai_llm.py

@@ -0,0 +1,57 @@
+# 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 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
+from nat.data_models.temperature_mixin import TemperatureMixin
+from nat.data_models.thinking_mixin import ThinkingMixin
+from nat.data_models.top_p_mixin import TopPMixin
+
+
+class AzureOpenAIModelConfig(
+        LLMBaseConfig,
+        RetryMixin,
+        TemperatureMixin,
+        TopPMixin,
+        ThinkingMixin,
+        name="azure_openai",
+):
+    """An Azure 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="Azure OpenAI API key to interact with hosted model.")
+    api_version: str = Field(default="2025-04-01-preview", description="Azure OpenAI API version.")
+    azure_endpoint: str | None = Field(validation_alias=AliasChoices("azure_endpoint", "base_url"),
+                                       serialization_alias="azure_endpoint",
+                                       default=None,
+                                       description="Base URL for the hosted model.")
+    azure_deployment: str = Field(validation_alias=AliasChoices("azure_deployment", "model_name", "model"),
+                                  serialization_alias="azure_deployment",
+                                  description="The Azure OpenAI hosted model/deployment name.")
+    seed: int | None = Field(default=None, description="Random seed to set for generation.")
+
+
+@register_llm_provider(config_type=AzureOpenAIModelConfig)
+async def azure_openai_llm(config: AzureOpenAIModelConfig, _builder: Builder):
+
+    yield LLMProviderInfo(config=config, description="An Azure OpenAI model for use with an LLM client.")

nat/llm/litellm_llm.py

@@ -0,0 +1,69 @@
+# 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 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
+from nat.data_models.temperature_mixin import TemperatureMixin
+from nat.data_models.thinking_mixin import ThinkingMixin
+from nat.data_models.top_p_mixin import TopPMixin
+
+
+class LiteLlmModelConfig(
+        LLMBaseConfig,
+        RetryMixin,
+        TemperatureMixin,
+        TopPMixin,
+        ThinkingMixin,
+        name="litellm",
+):
+    """A LiteLlm provider to be used with an LLM client."""
+
+    model_config = ConfigDict(protected_namespaces=(), extra="allow")
+
+    api_key: str | None = Field(default=None, description="API key to interact with hosted model.")
+    base_url: str | None = Field(default=None,
+                                 description="Base url to the hosted model.",
+                                 validation_alias=AliasChoices("base_url", "api_base"),
+                                 serialization_alias="api_base")
+    model_name: str = Field(validation_alias=AliasChoices("model_name", "model"),
+                            serialization_alias="model",
+                            description="The LiteLlm hosted model name.")
+    seed: int | None = Field(default=None, description="Random seed to set for generation.")
+
+
+@register_llm_provider(config_type=LiteLlmModelConfig)
+async def litellm_model(
+    config: LiteLlmModelConfig,
+    _builder: Builder,
+) -> AsyncIterator[LLMProviderInfo]:
+    """Litellm model provider.
+
+    Args:
+        config (LiteLlmModelConfig): The LiteLlm model configuration.
+        _builder (Builder): The NAT builder instance.
+
+    Returns:
+        AsyncIterator[LLMProviderInfo]: An async iterator that yields an LLMProviderInfo object.
+    """
+    yield LLMProviderInfo(config=config, description="A LiteLlm model for use with an LLM client.")

nat/llm/nim_llm.py

@@ -0,0 +1,58 @@
+# 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.optimizable import OptimizableField
+from nat.data_models.optimizable import OptimizableMixin
+from nat.data_models.optimizable import SearchSpace
+from nat.data_models.retry_mixin import RetryMixin
+from nat.data_models.temperature_mixin import TemperatureMixin
+from nat.data_models.thinking_mixin import ThinkingMixin
+from nat.data_models.top_p_mixin import TopPMixin
+
+
+class NIMModelConfig(LLMBaseConfig,
+                     RetryMixin,
+                     OptimizableMixin,
+                     TemperatureMixin,
+                     TopPMixin,
+                     ThinkingMixin,
+                     name="nim"):
+    """An NVIDIA Inference Microservice (NIM) llm provider to be used with an LLM client."""
+
+    model_config = ConfigDict(protected_namespaces=(), extra="allow")
+
+    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.")
+    max_tokens: PositiveInt = OptimizableField(default=300,
+                                               description="Maximum number of tokens to generate.",
+                                               space=SearchSpace(high=2176, low=128, step=512))
+
+
+@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.")