📢 Announcing our research paper: Zentry achieves 26% higher accuracy than OpenAI Memory, 91% lower latency, and 90% token savings! Read the paper to learn how we're revolutionizing AI agent memory.
Build a personalized Customer Support AI Agent using LangGraph for conversation flow and Zentry for memory retention. This integration enables context-aware and efficient support experiences.

​
Overview

In this guide, we’ll create a Customer Support AI Agent that:
  1. Uses LangGraph to manage conversation flow
  2. Leverages Zentry to store and retrieve relevant information from past interactions
  3. Provides personalized responses based on user history

​
Setup and Configuration

Install necessary libraries: 
pip install langgraph langchain-openai Zentryai
Import required modules and set up configurations:
Remember to get the Zentry API key from Zentry Platform.
from typing import Annotated, TypedDict, List
from langgraph.graph import StateGraph, START
from langgraph.graph.message import add_messages
from langchain_openai import ChatOpenAI
from Zentry import MemoryClient
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage

# Configuration
OPENAI_API_KEY = 'sk-xxx'  # Replace with your actual OpenAI API key
Zentry_API_KEY = 'your-Zentry-key'  # Replace with your actual Zentry API key

# Initialize LangChain and Zentry
llm = ChatOpenAI(model="gpt-4", api_key=OPENAI_API_KEY)
Zentry = MemoryClient(api_key=Zentry_API_KEY)

​
Define State and Graph

Set up the conversation state and LangGraph structure: 
class State(TypedDict):
    messages: Annotated[List[HumanMessage | AIMessage], add_messages]
    Zentry_user_id: str

graph = StateGraph(State)

​
Create Chatbot Function

Define the core logic for the Customer Support AI Agent: 
def chatbot(state: State):
    messages = state["messages"]
    user_id = state["Zentry_user_id"]

    # Retrieve relevant memories
    memories = Zentry.search(messages[-1].content, user_id=user_id)

    context = "Relevant information from previous conversations:\n"
    for memory in memories:
        context += f"- {memory['memory']}\n"

    system_message = SystemMessage(content=f"""You are a helpful customer support assistant. Use the provided context to personalize your responses and remember user preferences and past interactions.
{context}""")

    full_messages = [system_message] + messages
    response = llm.invoke(full_messages)

    # Store the interaction in Zentry
    Zentry.add(f"User: {messages[-1].content}\nAssistant: {response.content}", user_id=user_id)
    return {"messages": [response]}

​
Set Up Graph Structure

Configure the LangGraph with appropriate nodes and edges: 
graph.add_node("chatbot", chatbot)
graph.add_edge(START, "chatbot")
graph.add_edge("chatbot", "chatbot")

compiled_graph = graph.compile()

​
Create Conversation Runner

Implement a function to manage the conversation flow: 
def run_conversation(user_input: str, Zentry_user_id: str):
    config = {"configurable": {"thread_id": Zentry_user_id}}
    state = {"messages": [HumanMessage(content=user_input)], "Zentry_user_id": Zentry_user_id}

    for event in compiled_graph.stream(state, config):
        for value in event.values():
            if value.get("messages"):
                print("Customer Support:", value["messages"][-1].content)
                return

​
Main Interaction Loop

Set up the main program loop for user interaction: 
if __name__ == "__main__":
    print("Welcome to Customer Support! How can I assist you today?")
    Zentry_user_id = "customer_123"  # You can generate or retrieve this based on your user management system
    while True:
        user_input = input("You: ")
        if user_input.lower() in ['quit', 'exit', 'bye']:
            print("Customer Support: Thank you for contacting us. Have a great day!")
            break
        run_conversation(user_input, Zentry_user_id)

​
Key Features

  1. Memory Integration: Uses Zentry to store and retrieve relevant information from past interactions.
  2. Personalization: Provides context-aware responses based on user history.
  3. Flexible Architecture: LangGraph structure allows for easy expansion of the conversation flow.
  4. Continuous Learning: Each interaction is stored, improving future responses.

​
Conclusion

By integrating LangGraph with Zentry, you can build a personalized Customer Support AI Agent that can maintain context across interactions and provide personalized assistance.

​
Help

  • For more details on LangGraph, visit the LangChain documentation.
  • For Zentry documentation, refer to the Zentry Platform.
  • If you need further assistance, please feel free to reach out to us through following methods:

Telegram

Join our community

GitHub

Ask questions on GitHub

Support

Talk to founders