Video summary

LangChain 7: Chatbot with LCEL + Message History | Tamil

Main summary

Key takeaways

Technology

What the video teaches (LangChain 7: Chatbot with LCEL + message history)

This tutorial (Computer Lab Tamil) continues from earlier “chain” concepts in LangChain and shows how to build a chatbot where answers depend on previous turns (conversation context). It focuses on LCEL-style pipelines and progressively introduces memory/message history, first manually and then using LangChain’s built-in utility.

Key technological concepts covered

1) Baseline LCEL chain: single question → single answer

Earlier chains are described as:

  • input → model/LLM call → output

Limitation: If you ask a new question, the chain treats it like a fresh, unrelated prompt, so it may not know the topic discussed earlier (no retained context).

Example idea: Ask “What is Google?” then ask “Where is it located?” Without memory, the second question may not have the context needed to answer correctly.

2) Why “memory” is needed for chatbots

Memory is used to store the prior conversation, so subsequent questions can be answered “with context.”

In practice, memory works by sending past messages along with the new user input.

Three approaches to “build chatbot memory” mentioned

  1. LCEL-style / Long chain with a manually included history

    • The tutorial explicitly builds a chain that uses a prompt template with placeholders for message history.

  2. Runnable with Message History

    • Instead of manually wiring memory, LangChain provides a runnable wrapper that manages history retrieval/storage.

  3. “LangGraph” / advanced agent tool (mentioned briefly)

    • Positioned as an advanced approach for more complex multi-turn/back-and-forth chatbot workflows (but details are not deeply implemented in this clip).

Manual implementation details (Message History + PromptTemplate)

The tutorial shows building a chain using:

  • ChatPromptTemplate (with MessagesPlaceholder / message history slot)
  • Template messages including:
    • system role: “You are a helpful assistant… answer briefly”
    • human role: user input
    • history placeholder: where prior turns are inserted

Example of manual history flow

The tutorial describes a function that:

  1. Extracts user input from the payload
  2. Loads/constructs conversation history (a list of messages)
  3. Invokes the chain with:
    • the new input
    • the message history
  4. Returns the model response

It emphasizes that the conversation history is a list of HumanMessage / AIMessage objects.

Important implementation notes/errors mentioned

  • Correct usage of message placeholder name/spelling (auto-generated subtitles imply an error like message placeholder vs messages placeholder).
  • How to append to history:
    • For ChatMessageHistory, direct list append may not work.
    • Methods mentioned include:
      • add_user_message(...)
      • add_ai_message(...)
    • If you need the underlying list, use something like .messages.

Multi-user support: session-based memory

A key product feature/concept: memory must be separated per user.

  • Without session separation, a single shared conversation list leads to “mixing” between users.
  • The tutorial introduces:
    • a dictionary/store like {user_id: [messages...] }
    • session IDs passed alongside input
  • For each session:
    • load its specific message history
    • append the new user question and subsequent answer
    • keep the data isolated per user

Built-in approach: RunnableWithMessageHistory

After demonstrating manual memory, the tutorial switches to LangChain’s higher-level helper.

RunnableWithMessageHistory concept

  • You create a base chain (prompt → model → output parser).
  • Wrap it with RunnableWithMessageHistory, providing:
    • how to get session history
    • which keys represent:
      • input messages
      • history messages

The user supplies a session_id via configurable, e.g.:

  • configurable={"session_id": ...} (syntax shown in the video, with subtitles mentioning a small parentheses/closing syntax fix)

Result

You can call invoke(...) normally, and the wrapper ensures:

  • previous messages for that session are fetched
  • appended automatically
  • passed back into the prompt on the next turn

Summary of what the viewer is expected to learn/do

  • Understand why chat memory is required.
  • Learn both:
    1. Manual conversation state management using ChatMessageHistory + prompt message placeholders
    2. Automatic per-session history using RunnableWithMessageHistory
  • Recognize the need for session IDs to prevent cross-user data leaks/mixing.

Main speakers/sources

  • Speaker/source: Computer Lab Tamil (channel/host implied by “welcome to Computer Lab Tamil”)
  • Content/tool source: LangChain (LCEL, ChatPromptTemplate, MessagesPlaceholder, ChatMessageHistory, RunnableWithMessageHistory)

Original video