Complex chatbot agent with langgraph

[robertomotta1]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

const mainFlow = new StateGraph(State)
  .addNode("router", routerNode)
  .addEdge(START, "router")
  .addNode("transferToHuman", transferToHumanNode)
  .addNode("FAQ", FAQNode)
  .addNode("helpUser", helpUserNode)
  .addConditionalEdges("router", shouldContinue, [
    "transferToHuman",
    "FAQ",
    "helpUser",
    END,
  ])
  .addEdge("FAQ", END)
  .addEdge("transferToHuman", END)
  .compile();

Description

Hi, i'm trying to create and agent with langgraph that does the following:

• identify if the user is making a general question or need some help
  • if is making a general question, answer with the use of a vector store
• if the user need help
  • ask the user some informations (first name, last name, ...)
  • get the user email with a tool and ask the user if the email is correct
  • if the email is correct, proceed with the flow, otherwise end
  • the flow then need to ask more information about the user (for example what does he need help for)

What i have reached so far is that i'm able to correct choosing the user "intent" and then getting the user informations and calling the function tool.
I'm stuck now at the point where i need to ask the user confirm and then i don't know how i can proceed with the flow, asking then more questions and so on.
This agent is meant to be a conversation with the user and the ai. Am i using right langgraph?

Thank you

System Info

nodejs on windows using @langchain/core 0.3.2

[dosubot[bot]]

Hey there, @robertomotta1! 👋 I'm here to help you with any bugs, questions, or contributions you might have. Let's squash those bugs together!

I found a similar unsolved discussion that might be relevant to your issue: Multi-step chatbot ^[1].

To create a complex chatbot agent with LangGraph that identifies user intent, collects user information, confirms the email, and proceeds with the flow based on user responses, you can follow these steps:

1. Install LangChain and LangGraph:

   pip install langchain-chroma langchain_community tiktoken langchain-openai langchainhub langchain langgraph neo4j

2. Set Up Environment Variables:

   import getpass
   import os
   
   os.environ["OPENAI_API_KEY"] = getpass.getpass()
   os.environ["NEO4J_URI"] = "bolt://localhost:7687"
   os.environ["NEO4J_USERNAME"] = "neo4j"
   os.environ["NEO4J_PASSWORD"] = "password"

3. Define Tools:

   from langchain.text_splitter import RecursiveCharacterTextSplitter
   from langchain_chroma import Chroma
   from langchain_community.document_loaders import WebBaseLoader
   from langchain_openai import OpenAIEmbeddings
   
   urls = [
       "https://lilianweng.github.io/posts/2023-06-23-agent/",
       "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/",
       "https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/",
   ]
   
   docs = [WebBaseLoader(url).load() for url in urls]
   docs_list = [item for sublist in docs for item in sublist]
   
   text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
       chunk_size=100, chunk_overlap=50
   )
   doc_splits = text_splitter.split_documents(docs_list)
   
   # Add to vectorDB
   vectorstore = Chroma.from_documents(
       documents=doc_splits,
       collection_name="rag-chroma",
       embedding=OpenAIEmbeddings(),
   )
   retriever = vectorstore.as_retriever()

4. Create Retriever Tool:

   from langchain.tools.retriever import create_retriever_tool
   
   tool = create_retriever_tool(
       retriever,
       "retrieve_blog_posts",
       "Search and return information about Lilian Weng blog posts.",
   )
   
   tools = [tool]

5. Initialize Language Model:

   from langchain_openai import ChatOpenAI
   model = ChatOpenAI(model="gpt-4-0125-preview", temperature=0)

6. Define Agent State:

   import operator
   from typing import Annotated, Sequence, TypedDict
   
   from langchain_core.messages import BaseMessage
   
   class AgentState(TypedDict):
       messages: Annotated[Sequence[BaseMessage], operator.add]

7. Define Nodes and Edges:

   import json
   from langchain.output_parsers import PydanticOutputParser
   from langchain.prompts import PromptTemplate
   from langchain.tools.render import format_tool_to_openai_function
   from langchain_core.messages import BaseMessage, FunctionMessage
   from langgraph.prebuilt import ToolInvocation
   
   def should_retrieve(state):
       messages = state["messages"]
       last_message = messages[-1]
       if "function_call" not in last_message.additional_kwargs:
           return "end"
       else:
           return "continue"
   
   def check_relevance(state):
       class FunctionOutput(BaseModel):
           binary_score: str = Field(description="Relevance score 'yes' or 'no'")
   
       parser = PydanticOutputParser(pydantic_object=FunctionOutput)
       format_instructions = parser.get_format_instructions()
   
       prompt = PromptTemplate(
           template="""You are a grader assessing relevance of retrieved docs to a user question. \n 
           Here are the retrieved docs:
           \n ------- \n
           {context} 
           \n ------- \n
           Here is the user question: {question}
           If the docs contain keyword(s) in the user question, then score them as relevant. \n
           Give a binary score 'yes' or 'no' score to indicate whether the docs are relevant to the question. \n 
           Output format instructions: \n {format_instructions}""",
           input_variables=["question"],
           partial_variables={"format_instructions": format_instructions},
       )
   
       model = ChatOpenAI(temperature=0, model="gpt-4-0125-preview")
       chain = prompt | model | parser
   
       messages = state["messages"]
       last_message = messages[-1]
       score = chain.invoke(
           {"question": messages[0].content, "context": last_message.content}
       )
   
       if score.binary_score == "yes":
           return "yes"
       else:
           return "no"
   
   def call_model(state):
       messages = state["messages"]
       model = ChatOpenAI(temperature=0, streaming=True, model="gpt-4-0125-preview")
       functions = [format_tool_to_openai_function(t) for t in tools]
       model = model.bind_functions(functions)
       response = model.invoke(messages)
       return {"messages": [response]}
   
   def call_tool(state):
       messages = state["messages"]
       last_message = messages[-1]
       action = ToolInvocation(
           tool=last_message.additional_kwargs["function_call"]["name"],
           tool_input=json.loads(
               last_message.additional_kwargs["function_call"]["arguments"]
           ),
       )
       response = tool_executor.invoke(action)
       function_message = FunctionMessage(content=str(response), name=action.tool)
       return {"messages": [function_message]}

8. Create the Agent Graph:

   from langgraph.graph import END, StateGraph
   
   workflow = StateGraph(AgentState)
   
   workflow.add_node("agent", call_model)
   workflow.add_node("action", call_tool)
   
   workflow.set_entry_point("agent")
   workflow.add_conditional_edges(
       "agent",
       should_retrieve,
       {
           "continue": "action",
           "end": END,
       },
   )
   
   workflow.add_conditional_edges(
       "action",
       check_relevance,
       {
           "yes": "agent",
           "no": END,
       },
   )
   
   app = workflow.compile()

9. Run the Agent:

   import pprint
   from langchain_core.messages import HumanMessage
   
   inputs = {
       "messages": [
           HumanMessage(
               content="I need help with my account"
           )
       ]
   }
   for output in app.stream(inputs):
       for key, value in output.items():
           pprint.pprint(f"Output from node '{key}':")
           pprint.pprint("---")
           pprint.pprint(value, indent=2, width=80, depth=None)
       pprint.pprint("\n---\n")

This setup will allow you to create a chatbot agent that can identify user intent, collect user information, confirm the email, and proceed with the flow based on user responses using LangGraph. The use of AgentState ensures that the conversation history is maintained, allowing the agent to provide contextually relevant responses. Additionally, the integration with Neo4j allows for a semantic layer over a graph database, enhancing the chatbot's ability to interact with structured data ^{[2][3][4][5][6]}.

To continue talking to Dosu, mention @dosu.