Messages: a conversation as a list

A LangChain message is a typed object for one turn of a conversation: SystemMessage, HumanMessage and AIMessage each hold one role's words.

Last updated: 27 Sep, 2026 · LangChain 1.4

Four kinds of message

Whatever you pass to model.invoke goes in as a human message, and the reply comes back as an AI message. A plain string, such as model.invoke("what is langchain"), is a text prompt: fine for a single request that needs no conversation history. A message prompt is a list of message objects, which lets you tell the model how to behave and carry a conversation. There are four types:

• SystemMessage tells the model how to behave: its role, tone and rules.
• HumanMessage is the user's input.
• AIMessage is the model's reply, including any tool calls it makes.
• ToolMessage carries a tool's result back to the model; you meet it in the bind_tools: asking for a tool lesson.

Import the classes from langchain.messages and build the list. The video's first list has two messages: a system message, "You are a poetry expert", and a human message asking for a poem on artificial intelligence. Both go to the model together, and the poem comes back as an AI message:

from langchain.chat_models import init_chat_model
from langchain.messages import SystemMessage, HumanMessage

model = init_chat_model("groq:openai/gpt-oss-120b")   # the model from the setup lesson

messages = [
    SystemMessage("You are a poetry expert"),
    HumanMessage("Write a poem on artificial intelligence"),
]
response = model.invoke(messages)

A one-line system message gets a generic answer. With "You are a helpful coding assistant.", the question "How do I create a REST API?" gets a general walkthrough that picks Flask as one example and lists other languages. A detailed system message, "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.", gets a practical Python answer to the same question, with Flask code and steps.

Each message carries a role, which names its type, content, which can be text, audio or documents, and optional metadata. The video's human message carries a name, Alice, and an id; the name tells users apart and the id helps trace the conversation.

Adding the model's side of a conversation

An AIMessage can also be written by hand, as if the model had said it. That is how a conversation's history is passed back in. The video writes "I'd be happy to help you with that question!" as an AI message, places it between "Can you help me?" and "Great! What's 2+2?", and the model answers the last question from the whole list. Here is that example, run on Groq:

from langchain.chat_models import init_chat_model

model = init_chat_model("groq:openai/gpt-oss-120b")

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)
print(response.content)
print(response.usage_metadata)

2 + 2 = 4.
{'input_tokens': 112, 'output_tokens': 36, 'total_tokens': 148, 'output_token_details': {'reasoning': 17}}

The reply read the whole history, including the AI message written by hand, and answered the last question. usage_metadata reports the tokens: 112 in and 36 out, 17 of them the reasoning the model did before it answered. The video's model reasons first too, which is why its reply opens with its thinking.

Now the shop's conversation, built from the same classes.

Importing the message classes

Import the three classes, one per role.

from langchain.messages import AIMessage, HumanMessage, SystemMessage

Building the conversation

Build the conversation as a list of these objects instead of dictionaries.

conversation = [
    SystemMessage("You help customers of a small online shop."),
    HumanMessage("Where is my order A17?"),
    AIMessage("Order A17 shipped on 3 March."),
]

Printing each turn

Loop over it. Each message carries a type naming its role, and text holds its words.

for message in conversation:
    print(f"{message.type:<7} {message.text}")

Printing a conversation end to end

The same pieces in one file, ready to run.

from langchain.messages import AIMessage, HumanMessage, SystemMessage

conversation = [
    SystemMessage("You help customers of a small online shop."),
    HumanMessage("Where is my order A17?"),
    AIMessage("Order A17 shipped on 3 March."),
]

for message in conversation:
    print(f"{message.type:<7} {message.text}")

system  You help customers of a small online shop.
human   Where is my order A17?
ai      Order A17 shipped on 3 March.

Reading the message fields

• type names the role: a user turn is human, a model turn is ai, the rules turn is system.
• text returns the words of the message, whatever the provider.

Sending the conversation to a model

The list is the model's memory. Send the whole list, add the reply to it, add the next question, and send it again:

from langchain.chat_models import init_chat_model
from langchain.messages import HumanMessage, SystemMessage

model = init_chat_model("groq:openai/gpt-oss-120b", temperature=0)
conversation = [
    SystemMessage("You help customers of a small online shop. Order A17 shipped on 3 March. Order C40 is waiting for stock. Answer in one short sentence, using only these facts."),
    HumanMessage("Where is my order A17?"),
]
reply = model.invoke(conversation)
print(reply.text)

conversation.append(reply)
conversation.append(HumanMessage("And C40?"))
print(model.invoke(conversation).text)

Order A17 was shipped on 3 March.
Order C40 is waiting for stock.

The second question, "And C40?", makes sense to the model only because the first question and its answer travel with it.

The dictionary form still works

The same conversation as dictionaries prints much the same way. Each turn has a role and content; the classes above are the typed version of exactly this.

conversation = [
    {"role": "system", "content": "You help customers of a small online shop."},
    {"role": "user", "content": "Where is my order A17?"},
]

for turn in conversation:
    print(f"{turn['role']:<7} {turn['content']}")

system  You help customers of a small online shop.
user    Where is my order A17?

Printing a message readably

pretty_print shows a message with a header naming its type, which is easier to read once a conversation gets long.

from langchain.messages import HumanMessage

HumanMessage("Where is my order A17?").pretty_print()

================================ Human Message =================================

Where is my order A17?

Plain dict vs message object

When to use message objects

• Holding a chat history you send to a model on every turn.
• Passing a saved conversation between models without rewriting it.

Related

• Previous: Installation and setup
• Next: Content blocks: images and files in a message
• Reference: Messages