> 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.message_utils

Utilities for converting between LangChain messages and dictionary format.

## Module Contents

### Functions

| Name                                                                                                                            | Description                                                              |
| ------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| [`all_base_messages`](#nemoguardrails-integrations-langchain-message_utils-all_base_messages)                                   | Check if all items in a list are BaseMessage instances.                  |
| [`chatmessage_to_langchain_message`](#nemoguardrails-integrations-langchain-message_utils-chatmessage_to_langchain_message)     | -                                                                        |
| [`chatmessages_to_langchain_messages`](#nemoguardrails-integrations-langchain-message_utils-chatmessages_to_langchain_messages) | -                                                                        |
| [`create_ai_message`](#nemoguardrails-integrations-langchain-message_utils-create_ai_message)                                   | Create an AIMessage with optional fields.                                |
| [`create_ai_message_chunk`](#nemoguardrails-integrations-langchain-message_utils-create_ai_message_chunk)                       | Create an AIMessageChunk with optional metadata.                         |
| [`create_human_message`](#nemoguardrails-integrations-langchain-message_utils-create_human_message)                             | Create a HumanMessage with optional fields.                              |
| [`create_system_message`](#nemoguardrails-integrations-langchain-message_utils-create_system_message)                           | Create a SystemMessage with optional fields.                             |
| [`create_tool_message`](#nemoguardrails-integrations-langchain-message_utils-create_tool_message)                               | Create a ToolMessage with optional fields.                               |
| [`dict_to_message`](#nemoguardrails-integrations-langchain-message_utils-dict_to_message)                                       | Convert a dictionary to the appropriate BaseMessage type.                |
| [`dicts_to_messages`](#nemoguardrails-integrations-langchain-message_utils-dicts_to_messages)                                   | Convert a list of dictionaries to BaseMessage objects.                   |
| [`get_message_class`](#nemoguardrails-integrations-langchain-message_utils-get_message_class)                                   | Get the appropriate message class for a given type/role.                 |
| [`get_message_role`](#nemoguardrails-integrations-langchain-message_utils-get_message_role)                                     | Get the role string for a BaseMessage.                                   |
| [`is_ai_message`](#nemoguardrails-integrations-langchain-message_utils-is_ai_message)                                           | Check if an object is an AIMessage.                                      |
| [`is_base_message`](#nemoguardrails-integrations-langchain-message_utils-is_base_message)                                       | Check if an object is any type of BaseMessage.                           |
| [`is_human_message`](#nemoguardrails-integrations-langchain-message_utils-is_human_message)                                     | Check if an object is a HumanMessage.                                    |
| [`is_message_type`](#nemoguardrails-integrations-langchain-message_utils-is_message_type)                                       | Check if an object is an instance of a specific message type.            |
| [`is_system_message`](#nemoguardrails-integrations-langchain-message_utils-is_system_message)                                   | Check if an object is a SystemMessage.                                   |
| [`is_tool_message`](#nemoguardrails-integrations-langchain-message_utils-is_tool_message)                                       | Check if an object is a ToolMessage.                                     |
| [`message_to_dict`](#nemoguardrails-integrations-langchain-message_utils-message_to_dict)                                       | Convert a BaseMessage to dictionary format, preserving all model fields. |
| [`messages_to_dicts`](#nemoguardrails-integrations-langchain-message_utils-messages_to_dicts)                                   | Convert a list of BaseMessage objects to dictionary format.              |
| [`tool_calls_to_langchain_format`](#nemoguardrails-integrations-langchain-message_utils-tool_calls_to_langchain_format)         | -                                                                        |

### Data

[`_ROLE_TO_LANGCHAIN`](#nemoguardrails-integrations-langchain-message_utils-_ROLE_TO_LANGCHAIN)

### API

```python
nemoguardrails.integrations.langchain.message_utils.all_base_messages(
    items: typing.List[typing.Any]
) -> bool
```

Check if all items in a list are BaseMessage instances.

```python
nemoguardrails.integrations.langchain.message_utils.chatmessage_to_langchain_message(
    msg: nemoguardrails.types.ChatMessage
) -> langchain_core.messages.BaseMessage
```

```python
nemoguardrails.integrations.langchain.message_utils.chatmessages_to_langchain_messages(
    msgs: typing.List[nemoguardrails.types.ChatMessage]
) -> typing.List[langchain_core.messages.BaseMessage]
```

```python
nemoguardrails.integrations.langchain.message_utils.create_ai_message(
    content: str,
    tool_calls: typing.Optional[list] = None,
    additional_kwargs: typing.Optional[dict] = None,
    response_metadata: typing.Optional[dict] = None,
    id: typing.Optional[str] = None,
    name: typing.Optional[str] = None,
    usage_metadata: typing.Optional[dict] = None,
    extra_kwargs = {}
) -> langchain_core.messages.AIMessage
```

Create an AIMessage with optional fields.

```python
nemoguardrails.integrations.langchain.message_utils.create_ai_message_chunk(
    content: str,
    metadata = {}
) -> langchain_core.messages.AIMessageChunk
```

Create an AIMessageChunk with optional metadata.

```python
nemoguardrails.integrations.langchain.message_utils.create_human_message(
    content: str,
    additional_kwargs: typing.Optional[dict] = None,
    response_metadata: typing.Optional[dict] = None,
    id: typing.Optional[str] = None,
    name: typing.Optional[str] = None
) -> langchain_core.messages.HumanMessage
```

Create a HumanMessage with optional fields.

```python
nemoguardrails.integrations.langchain.message_utils.create_system_message(
    content: str,
    additional_kwargs: typing.Optional[dict] = None,
    response_metadata: typing.Optional[dict] = None,
    id: typing.Optional[str] = None,
    name: typing.Optional[str] = None
) -> langchain_core.messages.SystemMessage
```

Create a SystemMessage with optional fields.

```python
nemoguardrails.integrations.langchain.message_utils.create_tool_message(
    content: str,
    tool_call_id: str,
    name: typing.Optional[str] = None,
    additional_kwargs: typing.Optional[dict] = None,
    response_metadata: typing.Optional[dict] = None,
    id: typing.Optional[str] = None,
    artifact: typing.Optional[typing.Any] = None,
    status: typing.Optional[str] = None
) -> langchain_core.messages.ToolMessage
```

Create a ToolMessage with optional fields.

```python
nemoguardrails.integrations.langchain.message_utils.dict_to_message(
    msg_dict: typing.Dict[str, typing.Any]
) -> langchain_core.messages.BaseMessage
```

Convert a dictionary to the appropriate BaseMessage type.

**Parameters:**

Dictionary with role/type, content, and optional fields

**Returns:** `BaseMessage`

The appropriate BaseMessage instance

```python
nemoguardrails.integrations.langchain.message_utils.dicts_to_messages(
    msg_dicts: typing.List[typing.Dict[str, typing.Any]]
) -> typing.List[langchain_core.messages.BaseMessage]
```

Convert a list of dictionaries to BaseMessage objects.

**Parameters:**

List of message dictionaries

**Returns:** `List[BaseMessage]`

List of appropriate BaseMessage instances

```python
nemoguardrails.integrations.langchain.message_utils.get_message_class(
    msg_type: str
) -> typing.Type[langchain_core.messages.BaseMessage]
```

Get the appropriate message class for a given type/role.

```python
nemoguardrails.integrations.langchain.message_utils.get_message_role(
    msg: langchain_core.messages.BaseMessage
) -> str
```

Get the role string for a BaseMessage.

```python
nemoguardrails.integrations.langchain.message_utils.is_ai_message(
    obj: typing.Any
) -> bool
```

Check if an object is an AIMessage.

```python
nemoguardrails.integrations.langchain.message_utils.is_base_message(
    obj: typing.Any
) -> bool
```

Check if an object is any type of BaseMessage.

```python
nemoguardrails.integrations.langchain.message_utils.is_human_message(
    obj: typing.Any
) -> bool
```

Check if an object is a HumanMessage.

```python
nemoguardrails.integrations.langchain.message_utils.is_message_type(
    obj: typing.Any,
    message_type: typing.Type[langchain_core.messages.BaseMessage]
) -> bool
```

Check if an object is an instance of a specific message type.

```python
nemoguardrails.integrations.langchain.message_utils.is_system_message(
    obj: typing.Any
) -> bool
```

Check if an object is a SystemMessage.

```python
nemoguardrails.integrations.langchain.message_utils.is_tool_message(
    obj: typing.Any
) -> bool
```

Check if an object is a ToolMessage.

```python
nemoguardrails.integrations.langchain.message_utils.message_to_dict(
    msg: langchain_core.messages.BaseMessage
) -> typing.Dict[str, typing.Any]
```

Convert a BaseMessage to dictionary format, preserving all model fields.

**Parameters:**

The BaseMessage to convert

**Returns:** `Dict[str, Any]`

Dictionary representation with role, content, and all other fields

```python
nemoguardrails.integrations.langchain.message_utils.messages_to_dicts(
    messages: typing.List[langchain_core.messages.BaseMessage]
) -> typing.List[typing.Dict[str, typing.Any]]
```

Convert a list of BaseMessage objects to dictionary format.

**Parameters:**

List of BaseMessage objects

**Returns:** `List[Dict[str, Any]]`

List of dictionary representations

```python
nemoguardrails.integrations.langchain.message_utils.tool_calls_to_langchain_format(
    tool_calls: typing.List[typing.Dict[str, typing.Any]]
) -> typing.List[typing.Dict[str, typing.Any]]
```

```python
nemoguardrails.integrations.langchain.message_utils._ROLE_TO_LANGCHAIN = {Role.USER: HumanMessage, Role.ASSISTANT: AIMessage, Role.SYSTEM: SystemMessage,...
```