Enable multi-turn conversation with memory

You are just about ready to share your chatbot update with the school administration! For students to have a smooth learning experience, it's important to enable them to ask follow-up questions. This way, if any information is missing from the chatbot's first answer, the students can modify their questions by having a conversation. You'll now adapt your chatbot's streaming function to enable multiple turns, printing both the user's query as well as the chatbot's answer. To enable memory, LangGraph will send the full conversation to the LLM when follow-up questions are asked. To start with, your config parameters have already been set for one user:

config = {"configurable": {"thread_id": "1"}}

This exercise is part of the course

Designing Agentic Systems with LangChain

Exercise instructions

For each turn, start by printing the user's query from the queries list.
Iterate through msg and metadata using app.stream(), passing query as the content of HumanMessage along with config, and join the msg.content values.
To extract the chatbot's responses, print msg.content while excluding any msg labeled HumanMessage, adding a new line before the next query.

Hands-on interactive exercise

Have a go at this exercise by completing this sample code.

# Print the user query first for every interaction 
def user_agent_multiturn(queries):  
    for ____ in ____:
        print(f"User: {____}")
        
        # Stream through messages corresponding to queries, excluding metadata 
        print("Agent: " + "".join(____.____ for ____, ____ in app.____(
                {"messages": [____(____=_____)]}, config, stream_mode="messages") 
            
            # Filter out the human messages to print agent messages
            if ____.____ and not isinstance(____, ____)) + "____")       

queries = ["Is `stressed desserts?` a palindrome?", "What about the word `kayak`?",
    "What happened on the May 8th, 1945?", "What about 9 November 1989?"]
user_agent_multiturn(queries)

Edit and Run Code

This exercise is part of the course

Designing Agentic Systems with LangChain

IntermediateSkill Level

4.8+

Start Course for Free

Build intelligent agentic systems! Discover the key components of LangChain agents, including how prompts, LLMs, and tools work together for reasoning and action. You'll set up an agent with OpenAI's API, define custom tools, and tackle real-world tasks like math calculations. Plus, explore how LangChain organizes data using graphs, nodes, and edges.

Exercise 1: Agents in LangChain Exercise 2: Creating a ReAct agent Exercise 3: Components of LangChain agents Exercise 4: Building custom tools Exercise 5: Create a tool for math calculations Exercise 6: Integrating custom tools and queries Exercise 7: Conversation with a ReAct agent Exercise 8: Conversation setup Exercise 9: Ask questions about conversation history

Build dynamic, tool-augmented chatbots with LangChain and LangGraph! You’ll explore how to create a chatbot that adapts based on user input by defining states and integrating external APIs for real-time information retrieval. You'll connect these components into a responsive graph structure, enabling smooth transitions between conversation and tool-assisted responses. By the end, you’ll have a visually represented chatbot framework with enhanced reasoning and multi-step workflows.

Exercise 1: Building graphs for chatbots Exercise 2: Graph and agent states Exercise 3: Adding nodes and edges Exercise 4: Generating chatbot responses Exercise 5: Queries and responses Exercise 6: Generate a graph diagram Exercise 7: Adding external tools to a chatbot Exercise 8: Build a Wikipedia tool Exercise 9: Add a tool to a graph Exercise 10: Adding memory and conversation Exercise 11: Visualize the graph and return tool outputs Exercise 12: Adding graph memory Exercise 13: Using graph memory for conversation

Expand your chatbot with dynamic tools and memory! Define and integrate multiple tools into flexible workflows, build functions for dynamic tool calling, and configure your chatbot for multiple-tool handling. Organize memory and outputs to enable interleaved, multi-turn conversations. By the end, you'll have created a sophisticated chatbot capable of complex interactions.

Exercise 1: Defining multiple tools Exercise 2: Build a tool that invokes the LLM Exercise 3: Build a tool with Python code Exercise 4: Binding multiple tools Exercise 5: Defining nodes and edges for flexible function calling Exercise 6: Define a function that stops the chatbot Exercise 7: Create a function to return an LLM response Exercise 8: Create the graph workflow for multiple tools Exercise 9: Organize chatbot outputs with memory Exercise 10: Configure outputs for multiple tools Exercise 11: Enable multi-turn conversation with memory

Current Exercise

Exercise 12: Congratulations!