消息是 LangChain 中模型上下文的基本单元。它们表示模型的输入和输出,携带在与 LLM 交互时表示对话状态所需的内容和元数据。 消息是包含以下内容的对象:
  • 角色 - 标识消息类型(例如 systemuser
  • 内容 - 表示消息的实际内容(如文本、图像、音频、文档等)
  • 元数据 - 可选字段,如响应信息、消息 ID 和令牌使用情况
LangChain 提供了一个适用于所有模型提供商的标准消息类型,确保无论调用哪个模型都具有一致的行为。

基本用法

使用消息的最简单方法是创建消息对象并在调用时将它们传递给模型。
from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage, AIMessage, SystemMessage

model = init_chat_model("gpt-5-nano")

system_msg = SystemMessage("You are a helpful assistant.")
human_msg = HumanMessage("Hello, how are you?")

# Use with chat models
messages = [system_msg, human_msg]
response = model.invoke(messages)  # Returns AIMessage

文本提示

文本提示是字符串 - 适用于不需要保留对话历史记录的简单生成任务。
response = model.invoke("写一首关于春天的俳句")
在以下情况下使用文本提示:
  • 您有一个单一的独立请求
  • 您不需要对话历史记录
  • 您希望代码复杂性最小

消息提示

或者,您可以通过提供消息对象列表向模型传递消息列表。
from langchain.messages import SystemMessage, HumanMessage, AIMessage

messages = [
    SystemMessage("You are a poetry expert"),
    HumanMessage("Write a haiku about spring"),
    AIMessage("Cherry blossoms bloom...")
]
response = model.invoke(messages)
在以下情况下使用消息提示:
  • 管理多轮对话
  • 处理多模态内容(图像、音频、文件)
  • 包含系统指令

字典格式

您也可以直接以 OpenAI 聊天完成格式指定消息。
messages = [
    {"role": "system", "content": "You are a poetry expert"},
    {"role": "user", "content": "Write a haiku about spring"},
    {"role": "assistant", "content": "Cherry blossoms bloom..."}
]
response = model.invoke(messages)

消息类型

系统消息

SystemMessage 表示一组初始指令,用于引导模型的行为。您可以使用系统消息来设置语气、定义模型的角色并建立响应指南。
Basic instructions
system_msg = SystemMessage("You are a helpful coding assistant.")

messages = [
    system_msg,
    HumanMessage("How do I create a REST API?")
]
response = model.invoke(messages)
Detailed persona
from langchain.messages import SystemMessage, HumanMessage

system_msg = SystemMessage("""
You are a senior Python developer with expertise in web frameworks.
Always provide code examples and explain your reasoning.
Be concise but thorough in your explanations.
""")

messages = [
    system_msg,
    HumanMessage("How do I create a REST API?")
]
response = model.invoke(messages)

Human Message

A HumanMessage represents user input and interactions. They can contain text, images, audio, files, and any other amount of multimodal content.

Text content

response = model.invoke([
  HumanMessage("What is machine learning?")
])

Message metadata

Add metadata
human_msg = HumanMessage(
    content="Hello!",
    name="alice",  # Optional: identify different users
    id="msg_123",  # Optional: unique identifier for tracing
)
name 字段的行为因提供商而异 - 有些将其用于用户识别,有些则忽略它。要检查,请参阅模型提供商的参考

AI 消息

AIMessage 表示模型调用的输出。它们可以包括多模态数据、工具调用和您稍后可以访问的提供商特定元数据。
response = model.invoke("Explain AI")
print(type(response))  # <class 'langchain_core.messages.AIMessage'>
AIMessage 对象在调用模型时由模型返回,它包含响应中的所有相关元数据。 提供商对消息类型的权衡/上下文化方式不同,这意味着有时手动创建一个新的 AIMessage 对象并将其插入消息历史记录中,就像它来自模型一样,会很有帮助。
from langchain.messages import AIMessage, SystemMessage, HumanMessage

# Create an AI message manually (e.g., for conversation history)
ai_msg = AIMessage("I'd be happy to help you with that question!")

# Add to conversation history
messages = [
    SystemMessage("You are a helpful assistant"),
    HumanMessage("Can you help me?"),
    ai_msg,  # Insert as if it came from the model
    HumanMessage("Great! What's 2+2?")
]

response = model.invoke(messages)
text
string
The text content of the message.
content
string | dict[]
The raw content of the message.
content_blocks
ContentBlock[]
The standardized content blocks of the message.
tool_calls
dict[] | None
The tool calls made by the model. Empty if no tools are called.
id
string
A unique identifier for the message (either automatically generated by LangChain or returned in the provider response)
usage_metadata
dict | None
The usage metadata of the message, which can contain token counts when available.
response_metadata
ResponseMetadata | None
The response metadata of the message.

Tool calls

When models make tool calls, they’re included in the AIMessage:
from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-5-nano")

def get_weather(location: str) -> str:
    """Get the weather at a location."""
    ...

model_with_tools = model.bind_tools([get_weather])
response = model_with_tools.invoke("What's the weather in Paris?")

for tool_call in response.tool_calls:
    print(f"Tool: {tool_call['name']}")
    print(f"Args: {tool_call['args']}")
    print(f"ID: {tool_call['id']}")
Other structured data, such as reasoning or citations, can also appear in message content.

Token usage

An AIMessage can hold token counts and other usage metadata in its usage_metadata field:
from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-5-nano")

response = model.invoke("Hello!")
response.usage_metadata
{'input_tokens': 8,
 'output_tokens': 304,
 'total_tokens': 312,
 'input_token_details': {'audio': 0, 'cache_read': 0},
 'output_token_details': {'audio': 0, 'reasoning': 256}}
See UsageMetadata for details.

Streaming and chunks

During streaming, you’ll receive AIMessageChunk objects that can be combined into a full message object:
chunks = []
full_message = None
for chunk in model.stream("Hi"):
    chunks.append(chunk)
    print(chunk.text)
    full_message = chunk if full_message is None else full_message + chunk

Tool Message

For models that support tool calling, AI messages can contain tool calls. Tool messages are used to pass the results of a single tool execution back to the model. Tools can generate ToolMessage objects directly. Below, we show a simple example. Read more in the tools guide.
# After a model makes a tool call
ai_message = AIMessage(
    content=[],
    tool_calls=[{
        "name": "get_weather",
        "args": {"location": "San Francisco"},
        "id": "call_123"
    }]
)

# Execute tool and create result message
weather_result = "Sunny, 72°F"
tool_message = ToolMessage(
    content=weather_result,
    tool_call_id="call_123"  # Must match the call ID
)

# Continue conversation
messages = [
    HumanMessage("What's the weather in San Francisco?"),
    ai_message,  # Model's tool call
    tool_message,  # Tool execution result
]
response = model.invoke(messages)  # Model processes the result
content
string
required
The stringified output of the tool call.
tool_call_id
string
required
The ID of the tool call that this message is responding to. (this must match the ID of the tool call in the AIMessage)
name
string
required
The name of the tool that was called.
artifact
dict
Additional data not sent to the model but can be accessed programmatically.
The artifact field stores supplementary data that won’t be sent to the model but can be accessed programmatically. This is useful for storing raw results, debugging information, or data for downstream processing without cluttering the model’s context.
For example, a retrieval tool could retrieve a passage from a document for reference by a model. Where message content contains text that the model will reference, an artifact can contain document identifiers or other metadata that an application can use (e.g., to render a page). See example below:
from langchain.messages import ToolMessage

# Sent to model
message_content = "It was the best of times, it was the worst of times."

# Artifact available downstream
artifact = {"document_id": "doc_123", "page": 0}

tool_message = ToolMessage(
    content=message_content,
    tool_call_id="call_123",
    name="search_books",
    artifact=artifact,
)
See the RAG tutorial for an end-to-end example of building retrieval agents with LangChain.

Message content

You can think of a message’s content as the payload of data that gets sent to the model. Messages have a content attribute that is loosely-typed, supporting strings and lists of untyped objects (e.g., dictionaries). This allows support for provider-native structures directly in LangChain chat models, such as multimodal content and other data. Separately, LangChain provides dedicated content types for text, reasoning, citations, multi-modal data, server-side tool calls, and other message content. See content blocks below. LangChain chat models accept message content in the content attribute, and can contain:
  1. A string
  2. A list of content blocks in a provider-native format
  3. A list of LangChain’s standard content blocks
See below for an example using multimodal inputs:
from langchain.messages import HumanMessage

# String content
human_message = HumanMessage("Hello, how are you?")

# Provider-native format (e.g., OpenAI)
human_message = HumanMessage(content=[
    {"type": "text", "text": "Hello, how are you?"},
    {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
])

# List of standard content blocks
human_message = HumanMessage(content_blocks=[
    {"type": "text", "text": "Hello, how are you?"},
    {"type": "image", "url": "https://example.com/image.jpg"},
])
Specifying content_blocks when initializing a message will still populate message content, but provides a type-safe interface for doing so.

Standard content blocks

LangChain provides a standard representation for message content that works across providers. Message objects implement a content_blocks property that will lazily parse the content attribute into a standard, type-safe representation. For example, messages generated from ChatAnthropic or ChatOpenAI will include thinking or reasoning blocks in the format of the respective provider, but can be lazily parsed into a consistent ReasoningContentBlock representation:
  • Anthropic
  • OpenAI
from langchain.messages import AIMessage

message = AIMessage(
    content=[
        {"type": "thinking", "thinking": "...", "signature": "WaUjzkyp..."},
        {"type": "text", "text": "..."},
    ],
    response_metadata={"model_provider": "anthropic"}
)
message.content_blocks
[{'type': 'reasoning',
  'reasoning': '...',
  'extras': {'signature': 'WaUjzkyp...'}},
 {'type': 'text', 'text': '...'}]
See the integrations guides to get started with the inference provider of your choice.
Serializing standard contentIf an application outside of LangChain needs access to the standard content block representation, you can opt-in to storing content blocks in message content.To do this, you can set the LC_OUTPUT_VERSION environment variable to v1. Or, initialize any chat model with output_version="v1":
from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-5-nano", output_version="v1")

Multimodal

Multimodality refers to the ability to work with data that comes in different forms, such as text, audio, images, and video. LangChain includes standard types for these data that can be used across providers. Chat models can accept multimodal data as input and generate it as output. Below we show short examples of input messages featuring multimodal data.
Extra keys can be included top-level in the content block or nested in "extras": {"key": value}.OpenAI and AWS Bedrock Converse, for example, require a filename for PDFs. See the provider page for your chosen model for specifics.
# From URL
message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Describe the content of this image."},
        {"type": "image", "url": "https://example.com/path/to/image.jpg"},
    ]
}

# From base64 data
message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Describe the content of this image."},
        {
            "type": "image",
            "base64": "AAAAIGZ0eXBtcDQyAAAAAGlzb21tcDQyAAACAGlzb2...",
            "mime_type": "image/jpeg",
        },
    ]
}

# From provider-managed File ID
message = {
    "role": "user",
    "content": [
        {"type": "text", "text": "Describe the content of this image."},
        {"type": "image", "file_id": "file-abc123"},
    ]
}
Not all models support all file types. Check the model provider’s reference for supported formats and size limits.

Content block reference

Content blocks are represented (either when creating a message or accessing the content_blocks property) as a list of typed dictionaries. Each item in the list must adhere to one of the following block types:
Purpose: Standard text output
type
string
required
Always "text"
text
string
required
The text content
annotations
object[]
List of annotations for the text
extras
object
Additional provider-specific data
Example:
{
    "type": "text",
    "text": "Hello world",
    "annotations": []
}
Purpose: Model reasoning steps
type
string
required
Always "reasoning"
reasoning
string
The reasoning content
extras
object
Additional provider-specific data
Example:
{
    "type": "reasoning",
    "reasoning": "The user is asking about...",
    "extras": {"signature": "abc123"},
}
Purpose: Image data
type
string
required
Always "image"
url
string
URL pointing to the image location.
base64
string
Base64-encoded image data.
id
string
Reference ID to an externally stored image (e.g., in a provider’s file system or in a bucket).
mime_type
string
Image MIME type (e.g., image/jpeg, image/png)
Purpose: Audio data
type
string
required
Always "audio"
url
string
URL pointing to the audio location.
base64
string
Base64-encoded audio data.
id
string
Reference ID to an externally stored audio file (e.g., in a provider’s file system or in a bucket).
mime_type
string
Audio MIME type (e.g., audio/mpeg, audio/wav)
Purpose: Video data
type
string
required
Always "video"
url
string
URL pointing to the video location.
base64
string
Base64-encoded video data.
id
string
Reference ID to an externally stored video file (e.g., in a provider’s file system or in a bucket).
mime_type
string
Video MIME type (e.g., video/mp4, video/webm)
Purpose: Generic files (PDF, etc)
type
string
required
Always "file"
url
string
URL pointing to the file location.
base64
string
Base64-encoded file data.
id
string
Reference ID to an externally stored file (e.g., in a provider’s file system or in a bucket).
mime_type
string
File MIME type (e.g., application/pdf)
Purpose: Document text (.txt, .md)
type
string
required
Always "text-plain"
text
string
The text content
mime_type
string
MIME type of the text (e.g., text/plain, text/markdown)
Purpose: Function calls
type
string
required
Always "tool_call"
name
string
required
Name of the tool to call
args
object
required
Arguments to pass to the tool
id
string
required
Unique identifier for this tool call
Example:
{
    "type": "tool_call",
    "name": "search",
    "args": {"query": "weather"},
    "id": "call_123"
}
Purpose: Streaming tool call fragments
type
string
required
Always "tool_call_chunk"
name
string
Name of the tool being called
args
string
Partial tool arguments (may be incomplete JSON)
id
string
Tool call identifier
index
number | string
Position of this chunk in the stream
Purpose: Malformed calls, intended to catch JSON parsing errors.
type
string
required
Always "invalid_tool_call"
name
string
Name of the tool that failed to be called
args
object
Arguments to pass to the tool
error
string
Description of what went wrong
Purpose: Tool call that is executed server-side.
type
string
required
Always "server_tool_call"
id
string
required
An identifier associated with the tool call.
name
string
required
The name of the tool to be called.
args
string
required
Partial tool arguments (may be incomplete JSON)
Purpose: Streaming server-side tool call fragments
type
string
required
Always "server_tool_call_chunk"
id
string
An identifier associated with the tool call.
name
string
Name of the tool being called
args
string
Partial tool arguments (may be incomplete JSON)
index
number | string
Position of this chunk in the stream
Purpose: Search results
type
string
required
Always "server_tool_result"
tool_call_id
string
required
Identifier of the corresponding server tool call.
id
string
Identifier associated with the server tool result.
status
string
required
Execution status of the server-side tool. "success" or "error".
output
Output of the executed tool.
Purpose: Provider-specific escape hatch
type
string
required
Always "non_standard"
value
object
required
Provider-specific data structure
Usage: For experimental or provider-unique features
Additional provider-specific content types may be found within the reference documentation of each model provider.
View the canonical type definitions in the API reference.
Content blocks were introduced as a new property on messages in LangChain v1 to standardize content formats across providers while maintaining backward compatibility with existing code. Content blocks are not a replacement for the content property, but rather a new property that can be used to access the content of a message in a standardized format.

Use with chat models

Chat models accept a sequence of message objects as input and return an AIMessage as output. Interactions are often stateless, so that a simple conversational loop involves invoking a model with a growing list of messages. Refer to the below guides to learn more:
Connect these docs programmatically to Claude, VSCode, and more via MCP for real-time answers.