> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/guardrails/llms.txt.
> For full documentation content, see https://docs.nvidia.com/nemo/guardrails/llms-full.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/guardrails/_mcp/server.

# nemoguardrails.integrations.langchain.langchain_initializer

Module for initializing LangChain models with proper error handling.

## Module Contents

### Classes

| Name                                                                                                | Description                                                 |
| --------------------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
| [`ModelInitializer`](#nemoguardrails-integrations-langchain-langchain_initializer-ModelInitializer) | A method for initializing a model with its supported modes. |

### Functions

| Name                                                                                                                      | Description                                                                  |
| ------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| [`_handle_model_special_cases`](#nemoguardrails-integrations-langchain-langchain_initializer-_handle_model_special_cases) | Handle model initialization for special cases that need custom logic.        |
| [`_init_chat_completion_model`](#nemoguardrails-integrations-langchain-langchain_initializer-_init_chat_completion_model) | Initialize a chat completion model.                                          |
| [`_init_community_chat_models`](#nemoguardrails-integrations-langchain-langchain_initializer-_init_community_chat_models) | Initialize community chat models.                                            |
| [`_init_gpt35_turbo_instruct`](#nemoguardrails-integrations-langchain-langchain_initializer-_init_gpt35_turbo_instruct)   | Initialize GPT-3.5 Turbo Instruct model.                                     |
| [`_init_nvidia_model`](#nemoguardrails-integrations-langchain-langchain_initializer-_init_nvidia_model)                   | Initialize NVIDIA AI Endpoints model.                                        |
| [`_init_text_completion_model`](#nemoguardrails-integrations-langchain-langchain_initializer-_init_text_completion_model) | Initialize a text completion model.                                          |
| [`_update_model_kwargs`](#nemoguardrails-integrations-langchain-langchain_initializer-_update_model_kwargs)               | Update kwargs with the model name based on the provider's expected fields.   |
| [`init_langchain_model`](#nemoguardrails-integrations-langchain-langchain_initializer-init_langchain_model)               | Initialize a LangChain model using a series of initialization methods.       |
| [`try_initialization_method`](#nemoguardrails-integrations-langchain-langchain_initializer-try_initialization_method)     | Wrap an initialization method execution with a try/except to capture errors. |

### Data

[`ModelInitMethod`](#nemoguardrails-integrations-langchain-langchain_initializer-ModelInitMethod)

[`_PROVIDER_INITIALIZERS`](#nemoguardrails-integrations-langchain-langchain_initializer-_PROVIDER_INITIALIZERS)

[`_SPECIAL_MODEL_INITIALIZERS`](#nemoguardrails-integrations-langchain-langchain_initializer-_SPECIAL_MODEL_INITIALIZERS)

[`__all__`](#nemoguardrails-integrations-langchain-langchain_initializer-__all__)

[`log`](#nemoguardrails-integrations-langchain-langchain_initializer-log)

### API

```python
class nemoguardrails.integrations.langchain.langchain_initializer.ModelInitializer(
    init_method: nemoguardrails.integrations.langchain.langchain_initializer.ModelInitMethod,
    supported_modes: list[typing.Literal['chat', 'text']]
)
```

A method for initializing a model with its supported modes.

```python
nemoguardrails.integrations.langchain.langchain_initializer.ModelInitializer.__str__() -> str
```

```python
nemoguardrails.integrations.langchain.langchain_initializer.ModelInitializer.execute(
    model_name: str,
    provider_name: str,
    kwargs: typing.Dict[str, typing.Any]
) -> typing.Optional[typing.Union[langchain_core.language_models.BaseChatModel, langchain_core.language_models.BaseLLM]]
```

Execute this initializer to initialize a model.

```python
nemoguardrails.integrations.langchain.langchain_initializer.ModelInitializer.supports_mode(
    mode: typing.Literal['chat', 'text']
) -> bool
```

Check if this initializer supports the given mode.

```python
nemoguardrails.integrations.langchain.langchain_initializer._handle_model_special_cases(
    model_name: str,
    provider_name: str,
    kwargs: typing.Dict[str, typing.Any]
) -> typing.Optional[typing.Union[langchain_core.language_models.BaseChatModel, langchain_core.language_models.BaseLLM]]
```

Handle model initialization for special cases that need custom logic.

This function handles edge cases where standard initialization methods
don't work properly. It looks up initializers in the registry and dispatches
to the appropriate initialization function.

**Parameters:**

Name of the provider to use

Name of the model to initialize

Additional arguments to pass to the model initialization

**Returns:** `Optional[Union[BaseChatModel, BaseLLM]]`

An initialized model for special cases, or None if no special initializer exists

```python
nemoguardrails.integrations.langchain.langchain_initializer._init_chat_completion_model(
    model_name: str,
    provider_name: str,
    kwargs: typing.Dict[str, typing.Any]
) -> langchain_core.language_models.BaseChatModel
```

Initialize a chat completion model.

**Parameters:**

Name of the model to initialize

Name of the provider to use

Additional arguments to pass to the model initialization

**Returns:** `BaseChatModel`

An initialized chat completion model

**Raises:**

* `ValueError`: If the model cannot be initialized as a chat model

```python
nemoguardrails.integrations.langchain.langchain_initializer._init_community_chat_models(
    model_name: str,
    provider_name: str,
    kwargs: typing.Dict[str, typing.Any]
) -> langchain_core.language_models.BaseChatModel | None
```

Initialize community chat models.

**Parameters:**

Name of the provider to use

Name of the model to initialize

Additional arguments to pass to the model initialization

**Returns:** `BaseChatModel | None`

An initialized chat model

**Raises:**

* `ImportError`: If langchain\_community is not installed
* `ModelInitializationError`: If model initialization fails

```python
nemoguardrails.integrations.langchain.langchain_initializer._init_gpt35_turbo_instruct(
    model_name: str,
    provider_name: str,
    kwargs: typing.Dict[str, typing.Any]
) -> langchain_core.language_models.BaseLLM | None
```

Initialize GPT-3.5 Turbo Instruct model.

Currently init\_chat\_model from langchain infers this as a chat model.
This is a bug in langchain, and we need to handle it here.

This model requires text completion initialization.

**Parameters:**

Name of the model to initialize

Name of the provider to use

Additional arguments to pass to the model initialization

**Returns:** `BaseLLM | None`

An initialized text completion model

**Raises:**

* `ModelInitializationError`: If model initialization fails

```python
nemoguardrails.integrations.langchain.langchain_initializer._init_nvidia_model(
    model_name: str,
    provider_name: str,
    kwargs: typing.Dict[str, typing.Any]
) -> langchain_core.language_models.BaseChatModel
```

Initialize NVIDIA AI Endpoints model.

**Parameters:**

Name of the model to initialize

Name of the provider to use

Additional arguments to pass to the model initialization

**Returns:** `BaseChatModel`

An initialized chat model

**Raises:**

* `ImportError`: If langchain\_nvidia\_ai\_endpoints is not installed
* `ModelInitializationError`: If model initialization fails

```python
nemoguardrails.integrations.langchain.langchain_initializer._init_text_completion_model(
    model_name: str,
    provider_name: str,
    kwargs: typing.Dict[str, typing.Any]
) -> langchain_core.language_models.BaseLLM | None
```

Initialize a text completion model.

**Parameters:**

Name of the model to initialize

Name of the provider to use

Additional arguments to pass to the model initialization

**Returns:** `BaseLLM | None`

An initialized text completion model, or None if the provider is not found

```python
nemoguardrails.integrations.langchain.langchain_initializer._update_model_kwargs(
    provider_cls: type,
    model_name: str,
    kwargs: dict
) -> typing.Dict
```

Update kwargs with the model name based on the provider's expected fields.

If provider\_cls.model\_fields contains 'model' or 'model\_name',
sets the corresponding key in kwargs to model\_name.

```python
nemoguardrails.integrations.langchain.langchain_initializer.init_langchain_model(
    model_name: str,
    provider_name: str,
    mode: typing.Literal['chat', 'text'],
    kwargs: typing.Dict[str, typing.Any]
) -> typing.Union[langchain_core.language_models.BaseChatModel, langchain_core.language_models.BaseLLM]
```

Initialize a LangChain model using a series of initialization methods.

This function tries multiple initialization methods in sequence until one succeeds.
Each method is attempted only if it supports the requested mode.

```python
nemoguardrails.integrations.langchain.langchain_initializer.try_initialization_method(
    initializer: nemoguardrails.integrations.langchain.langchain_initializer.ModelInitializer,
    model_name: str,
    provider_name: str,
    mode: typing.Literal['chat', 'text'],
    kwargs: typing.Dict[str, typing.Any]
)
```

Wrap an initialization method execution with a try/except to capture errors.

1. Wraps the call to `try_initialization_method` in a try/except block
2. Catches any exceptions that might be thrown
3. Logs them and continues with the next initializer
4. Only fails at the end if all initializers have been tried

```python
nemoguardrails.integrations.langchain.langchain_initializer.ModelInitMethod = Callable[[str, str, Dict[str, Any]], Optional[Union[BaseChatModel, BaseLLM]]]
```

```python
nemoguardrails.integrations.langchain.langchain_initializer._PROVIDER_INITIALIZERS: Dict[str, Any] = {'nvidia_ai_endpoints': _init_nvidia_model, 'nim': _init_nvidia_model}
```

```python
nemoguardrails.integrations.langchain.langchain_initializer._SPECIAL_MODEL_INITIALIZERS = {'gpt-3.5-turbo-instruct': _init_gpt35_turbo_instruct}
```

```python
nemoguardrails.integrations.langchain.langchain_initializer.__all__ = ['ModelInitializationError', 'ModelInitMethod', 'ModelInitializer', 'init_langch...
```

```python
nemoguardrails.integrations.langchain.langchain_initializer.log = logging.getLogger(__name__)
```