basic chatbot example - langgraph

README.md

@@ -13,11 +13,21 @@ short_description: Langgraph
 
 # Langgraph
 ## UseCases
-### 1. Appointment Receptionist
+
+### 1. Basic Chatbot
+reference:
+![alt text](basic_chatbot.png)
+
+### 2. Chatbt with Tool
+reference:
+![alt text](chatbot_with_search_tool.png)
+
+### 3. Appointment Receptionist
 reference:
 ![alt text](appointment_receptionist.png)
 
-### 2. Customer Support
+### 4. Customer Support
 reference: 
 ![alt text](cs_flow.png)
-![alt text](image.png)
+![alt text](customer_support.png)
+

app.py

@@ -1,15 +1,18 @@
 import streamlit as st
 
 from configfile import Config
+from src.graph.graph_builder import GraphBuilder
 from src.streamlitui.loadui import LoadStreamlitUI
 from src.LLMS.groqllm import GroqLLM
 
 from src.langgraphagent.caller_agent import Caller_Agent
-from langchain_core.messages import HumanMessage
+from langchain_core.messages import HumanMessage,AIMessage,ToolMessage
 from src.tools.langgraphtool import APPOINTMENTS
 
 
 
+
+
 def submit_message(model):
     obj_caller_agent = Caller_Agent(model)
     # caller agent 
@@ -33,7 +36,7 @@ if __name__ == "__main__":
     
     if user_input['selected_usecase'] == "Appointment Receptionist":
         if st.chat_input("Type message here", key="message") :
-              # Configure LLM
+            # Configure LLM
             obj_llm_config = GroqLLM(user_controls_input=user_input)
             model = obj_llm_config.get_llm_model()
             CONVERSATION,APPOINTMENTS= (submit_message(model))
@@ -105,8 +108,53 @@ if __name__ == "__main__":
             st.write(customers_database)
             st.title('data protection checks')
             st.write(data_protection_checks)
+            
+            
+    else:
+        # Basic Examples - chatbot and chatbot with tool
+        # Text input for user message
+        user_message = st.chat_input("Enter your message:")
+        if user_message:
+            # Configure LLM
+            obj_llm_config = GroqLLM(user_controls_input=user_input)
+            model = obj_llm_config.get_llm_model()
+
+            # Initialize and set up the graph based on use case
+            usecase = user_input['selected_usecase']
+            graph_builder = GraphBuilder(model)
+            graph = graph_builder.setup_graph(usecase)
+
+            # Prepare state and invoke the graph
+            initial_state = {"messages": [user_message]}
+            entry_points = {"Basic Chatbot": "chatbot", "Chatbot with Tool": "chatbot_with_tool"}
+
+            entry_points = {"Basic Chatbot": "chatbot", "Chatbot with Tool": "chatbot_with_tool"}
+            if usecase =="Basic Chatbot":
+                for event in graph.stream({'messages':("user",user_message)}):
+                    print(event.values())
+                    for value in event.values():
+                        print(value['messages'])
+                        with st.chat_message("user"):
+                            st.write(user_message)
+                        with st.chat_message("assistant"):
+                            st.write(value["messages"].content)
+                            
+            else:
+                res = graph.invoke(initial_state)
+
+                for message in res['messages']:
+                    if type(message) == HumanMessage:
+                        with st.chat_message("user"):
+                            st.write(message.content)
+                    elif type(message)==ToolMessage:
+                        with st.chat_message("ai"):
+                            st.write("Tool Call Start")
+                            st.write(message.content)
+                            st.write("Tool Call End")
+                    elif type(message)==AIMessage and message.content:
+                        with st.chat_message("assistant"):
+                            st.write(message.content)
                             
-                        
                 
                         
                     

configfile.ini

@@ -1,6 +1,6 @@
 [DEFAULT]
 PAGE_TITLE = Langgraph IN ACTION
 LLM_OPTIONS = Groq
-USECASE_OPTIONS = Appointment Receptionist, Customer Support
+USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool, Appointment Receptionist, Customer Support
 GROQ_MODEL_OPTIONS = mixtral-8x7b-32768, llama3-8b-8192, llama3-70b-8192, gemma-7b-i
 

src/basic_bot/chatbot_node.py

@@ -0,0 +1,15 @@
+from src.LLMS.groqllm import GroqLLM
+from src.state.state import State
+
+class ChatbotNode:
+    """
+    Basic chatbot logic implementation.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates a chatbot response.
+        """
+        return {"messages":self.llm.invoke(state['messages'])}

src/basic_bot/chatbot_with_tool_node.py

@@ -0,0 +1,38 @@
+from src.LLMS.groqllm import GroqLLM
+from src.state.state import State
+
+class ChatbotWithToolNode:
+    """
+    Chatbot logic enhanced with tool integration.
+    """
+    def __init__(self,model):
+        self.llm = model
+
+    def process(self, state: State) -> dict:
+        """
+        Processes the input state and generates a response with tool integration.
+        """
+        user_input = state["messages"][-1] if state["messages"] else ""
+        llm_response = self.llm.invoke([{"role": "user", "content": user_input}])
+
+        # Simulate tool-specific logic
+        tools_response = f"Tool integration for: '{user_input}'"
+
+        return {"messages": [llm_response, tools_response]}
+
+
+
+    def create_chatbot(self, tools):
+        """
+        Returns a chatbot node function.
+        """
+        llm_with_tools = self.llm.bind_tools(tools)
+
+        def chatbot_node(state: State):
+            """
+            Chatbot logic for processing the input state and returning a response.
+            """
+            return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+        return chatbot_node
+

src/graph/graph_builder.py

@@ -0,0 +1,66 @@
+from langgraph.graph import StateGraph
+from src.state.state import State
+from src.basic_bot.chatbot_node import ChatbotNode
+from src.basic_bot.chatbot_with_tool_node import ChatbotWithToolNode
+
+
+from langgraph.graph import StateGraph
+from langgraph.prebuilt import tools_condition
+from src.tools.search_tool import get_tools, create_tool_node
+from src.basic_bot.chatbot_with_tool_node import ChatbotWithToolNode
+
+class GraphBuilder:
+    """
+    Manages the creation and setup of the StateGraph based on use cases.
+    """
+    def __init__(self,model):
+        self.llm = model
+        self.graph_builder = StateGraph(State)
+        self.chatbot_node = ChatbotNode(model)
+        self.chatbot_with_tool_node = ChatbotWithToolNode(model)
+        
+        
+    def build_graph(self):
+        """
+        Builds and returns the LangGraph graph based on the defined nodes and edges.
+        """
+        # Initialize state graph
+        graph_builder = StateGraph(State)
+
+        # Define tools and tool node
+        tools = get_tools()
+        tool_node = create_tool_node(tools)
+
+        # Define LLM
+        llm = self.llm
+
+        # Define chatbot node
+        obj_chatbot_with_node = ChatbotWithToolNode(llm)
+        chatbot_node = obj_chatbot_with_node.create_chatbot(tools)
+
+        # Add nodes
+        graph_builder.add_node("chatbot", chatbot_node)
+        graph_builder.add_node("tools", tool_node)
+
+        # Define conditional and direct edges
+        graph_builder.add_conditional_edges("chatbot", tools_condition)
+        graph_builder.add_edge("tools", "chatbot")
+
+        # Set entry point and compile graph
+        graph_builder.set_entry_point("chatbot")
+        return graph_builder
+    
+
+    def setup_graph(self, usecase: str):
+        """
+        Sets up the graph for the selected use case.
+        """
+        if usecase == "Basic Chatbot":
+            self.graph_builder.add_node("chatbot", self.chatbot_node.process)
+            self.graph_builder.set_entry_point("chatbot")
+            self.graph_builder.set_finish_point("chatbot")
+        elif usecase == "Chatbot with Tool":
+            self.graph_builder = self.build_graph()
+        else:
+            raise ValueError("Invalid use case selected.")
+        return self.graph_builder.compile()

src/state/state.py

@@ -0,0 +1,9 @@
+from typing import Annotated
+from typing_extensions import TypedDict
+from langgraph.graph.message import add_messages
+
+class State(TypedDict):
+    """
+    Represents the structure of the state used in the graph.
+    """
+    messages: Annotated[list, add_messages]

src/streamlitui/loadui.py

@@ -27,8 +27,15 @@ class LoadStreamlitUI:
                 # API key input
                 self.user_controls["GROQ_API_KEY"] = st.session_state["GROQ_API_KEY"] = st.text_input("API Key",
                                                                                                       type="password")
+                
+            
             # Use case selection
             self.user_controls["selected_usecase"] = st.selectbox("Select Usecases", usecase_options)
+            
+            if self.user_controls["selected_usecase"] =="Chatbot with Tool":
+            # API key input
+                os.environ["TAVILY_API_KEY"] = self.user_controls["TAVILY_API_KEY"] = st.session_state["TAVILY_API_KEY"] = st.text_input("TAVILY API KEY",
+                                                                                                      type="password")
         
                    
                

src/tools/search_tool.py

@@ -0,0 +1,15 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langgraph.prebuilt import ToolNode
+
+def get_tools():
+    """
+    Returns a list of tools to be used in the chatbot.
+    """
+    tool = TavilySearchResults( max_results=2)
+    return [tool]
+
+def create_tool_node(tools):
+    """
+    Creates and returns a tool node for the graph.
+    """
+    return ToolNode(tools=tools)