Managing Multi-Turn Conversation History with LangChain

Welcome to your next lesson on LangChain! So far, you've learned how to send basic messages to AI models, customize their parameters, and structure conversations using SystemMessage and HumanMessage. These skills have given you the foundation to create single-turn interactions with AI models. However, real-world conversations rarely consist of just one exchange.

Think about how you communicate with friends or colleagues. You ask a question, they respond, and then you might ask a follow-up question based on their answer. This natural flow of conversation relies on both participants remembering what was previously discussed. Without this shared context, conversations would feel disjointed and repetitive. The same principle applies when building AI applications. To create truly engaging and helpful AI assistants, we need to maintain conversation history across multiple exchanges. This allows the AI to understand references to previous messages and provide coherent, contextually appropriate responses.

In this lesson, we'll build on your knowledge of message types to implement multi-turn conversations. You'll learn how to create and manage a persistent conversation history, enabling the AI to maintain context across multiple exchanges. By the end of this lesson, you'll be able to create a conversational AI that can remember previous exchanges and respond appropriately to follow-up questions. Let's get started!

In our previous lesson, we learned how to use SystemMessage and HumanMessage classes to structure a single exchange with an AI model. Now, we'll expand on this concept by working with lists of messages that persist throughout a conversation.

The key to managing conversation history in LangChain is to maintain a list of messages that grows as the conversation progresses. Each message in this list represents a turn in the conversation, whether it's a system instruction, a human query, or an AI response.

Let's start by creating a message list to store our conversation, using TypeScript's type annotations for clarity and safety:

import { SystemMessage, HumanMessage, BaseMessage } from "@langchain/core/messages";

// Define initial messages for the conversation
const messages: BaseMessage[] = [
  new SystemMessage("You are a math assistant"),
  new HumanMessage("What is the square root of 9?")
];

In this code, we're creating a messages array of type BaseMessage[] that contains our initial conversation state. We start with a system message that defines the AI's role as a math assistant, followed by a human message asking about the square root of 9. This array will serve as the foundation for our ongoing conversation.

Now that we have our initial messages array, let's send it to the AI model to get a response.

import { ChatOpenAI, type ChatOpenAIFields } from "@langchain/openai";
import { AIMessage } from "@langchain/core/messages";

// Create a ChatOpenAI instance
const chat: ChatOpenAI = new ChatOpenAI({
  model: "gpt-5.6-luna",
  reasoningEffort: "none" as ChatOpenAIFields["reasoningEffort"],
  maxTokens: 50
});

// Send the initial messages to the AI model
const response: AIMessage = await chat.invoke(messages);

// Display the first AI response
console.log(`First Response: ${response.content}`);

When we run this code, we'll see output similar to:

First Response: The square root of 9 is 3.

Notice that we're passing the entire messages array to the invoke method, not just the human message. This allows the AI to see both the system instruction (that it should act as a math assistant) and the human query (about the square root of 9). The AI then generates a response based on this complete context. By explicitly typing response as AIMessage, we ensure that our code is type-safe and that we can reliably access the AI's response content.

To create a true multi-turn conversation, we need to add the AI's response to our message history and then ask a follow-up question. Since the response object returned by chat.invoke is already an instance of AIMessage, you can add it directly to the messages array:

// Add the AI's response directly (since response is already an AIMessage)
messages.push(response);

At this point, your conversation history contains three messages: the system instruction, the human's first question, and the AI's response.

With the AI's response added to the conversation history, you can now ask a follow-up question:

// Add a new human message to the conversation
messages.push(new HumanMessage("And 16?"));

Notice that the follow-up message is quite brief: "And 16?" In a normal conversation without history, this would be too vague for the AI to understand. However, because we're maintaining conversation history, the AI will have the context to interpret that we're asking about the square root of 16.

Now that we've updated our conversation history with both the AI's first response and our follow-up question, let's send the updated messages array to the AI model.

// Send the updated conversation to the AI model
const secondResponse: AIMessage = await chat.invoke(messages);

// Display the second AI response
console.log(`Second Response: ${secondResponse.content}`);

It's important to note that we're passing the entire messages array to the invoke method again, not just the new human message. This array now contains four messages: the system instruction, the first human question, the AI's first response, and the follow-up question. By sending the complete conversation history, we ensure the AI has all the context it needs to provide a relevant response.

When we run this code, we'll see output similar to:

Second Response: The square root of 16 is 4

The AI correctly interprets our follow-up question as asking for the square root of 16, even though we didn't explicitly mention "square root" in our second message. This demonstrates the power of maintaining conversation history: the AI can understand context and references to previous exchanges, enabling more natural and efficient communication.

Let's put everything together to see the complete implementation of our conversational math assistant in TypeScript:

import { ChatOpenAI, type ChatOpenAIFields } from "@langchain/openai";
import { SystemMessage, HumanMessage, AIMessage, BaseMessage } from "@langchain/core/messages";

// Create a ChatOpenAI instance
const chat: ChatOpenAI = new ChatOpenAI({
  model: "gpt-5.6-luna",
  reasoningEffort: "none" as ChatOpenAIFields["reasoningEffort"],
  maxTokens: 50
});

// Define initial messages for the conversation
const messages: BaseMessage[] = [
  new SystemMessage("You are a math assistant"),
  new HumanMessage("What is the square root of 9?")
];

// Send the initial messages to the AI model
const response: AIMessage = await chat.invoke(messages);
console.log(`First Response: ${response.content}`);

// Add the AI's response to the conversation history
messages.push(response);

// Add a new human message to the conversation
messages.push(new HumanMessage("And 16?"));

// Send the updated conversation to the AI model
const secondResponse: AIMessage = await chat.invoke(messages);
console.log(`Second Response: ${secondResponse.content}`);

This code demonstrates a complete multi-turn conversation with an AI assistant. We start with a system message and a human query, get a response from the AI, add that response to our conversation history, ask a follow-up question, and then get another response that takes into account the full conversation context. By using TypeScript's type annotations and LangChain's message classes, we ensure our code is both robust and type-safe.

In this lesson, you've learned how to manage conversation history in LangChain to create multi-turn interactions with AI models using TypeScript. Here are the key concepts we covered:

1. Using message arrays (BaseMessage[]) to maintain conversation state across multiple exchanges
2. Incorporating the AIMessage class to capture and store AI responses
3. Adding new messages to an ongoing conversation with type safety
4. Leveraging conversation history to enable contextual understanding of follow-up questions

These techniques allow you to build more sophisticated AI applications that can engage in natural, flowing conversations with users. By maintaining conversation history, your AI assistants can understand references to previous messages, remember information shared earlier in the conversation, and provide more coherent and contextually appropriate responses.

As you work through the practice exercises, try to think about how you might apply these techniques to your own projects. Consider what types of conversations would benefit from maintained history, and how you might structure your message arrays to support different conversation flows. Happy coding!