feat: Added search tool tavily

README.md

@@ -11,9 +11,8 @@ pinned: false
 short_description: agenticai
 license: mit
 ---
-# Welcome to Streamlit!
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+### END TO END AGENTIC AI APPLICATION
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+- Add support for memory, tools and MCP in it
+- Add guardrail and lanfuse support

src/langgraphagenticai/graph/graph_builder.py

@@ -3,20 +3,58 @@ from langgraph.prebuilt import tools_condition, ToolNode
 from langchain_core.prompts import ChatPromptTemplate
 from src.langgraphagenticai.state.state import State
 from src.langgraphagenticai.nodes.basic_chatbot_node import BasicChatbotNode
+from src.langgraphagenticai.nodes.chatbot_with_tool_node import ChatbotWithToolNode
+from src.langgraphagenticai.tools.search_tool import get_tools, create_tool_node
 import datetime
 
+
 class GraphBuilder:
     def __init__(self, model):
         self.llm = model
-        self.graph_builder = StateGraph(State)
 
     def basic_chatbot_build_graph(self):
+        graph_builder = StateGraph(State)
         self.basic_chatbot_node = BasicChatbotNode(self.llm)
-        self.graph_builder.add_node("chatbot", self.basic_chatbot_node.process)
-        self.graph_builder.add_edge(START, "chatbot")
-        self.graph_builder.add_edge("chatbot", END)
+        graph_builder.add_node("chatbot", self.basic_chatbot_node.process)
+        graph_builder.add_edge(START, "chatbot")
+        graph_builder.add_edge("chatbot", END)
+        return graph_builder
+
+    def chatbot_with_tools_build_graph(self):
+        graph_builder = StateGraph(State)
+
+        # define tools and toolnode
+        tools = get_tools()
+        tool_node = create_tool_node(tools=tools)
+
+        # define llm
+        llm = self.llm
+
+        # define chatbot node
+        obj_chatbot_with_node = ChatbotWithToolNode(llm)
+        chatbot_node = obj_chatbot_with_node.create_chatbot(tools=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_edge(START, "chatbot")
+        graph_builder.add_conditional_edges("chatbot", tools_condition)
+        graph_builder.add_edge("tools", "chatbot")
+
+        return graph_builder
 
     def setup_graph(self, usecase: str):
         if usecase == "Basic Chatbot":
-            self.basic_chatbot_build_graph()
-        return self.graph_builder.compile()
+            graph_builder = self.basic_chatbot_build_graph()
+        elif usecase == "Chatbot with Tool":
+            graph_builder = self.chatbot_with_tools_build_graph()
+        elif usecase == "AI News":
+            graph_builder = (
+                self.chatbot_with_tools_build_graph()
+            )  # AI News also uses tools
+        else:
+            raise ValueError(f"Unknown usecase: {usecase}")
+
+        return graph_builder.compile()

src/langgraphagenticai/main.py

@@ -1,5 +1,6 @@
 import streamlit as st
 import json
+import os
 from src.langgraphagenticai.ui.streamlitui.loadui import LoadStreamlitUI
 from src.langgraphagenticai.llms.groqllm import GroqLLM
 from src.langgraphagenticai.graph.graph_builder import GraphBuilder
@@ -39,6 +40,15 @@ def load_langgraph_agenticai_app():
                 st.error("Error: no usecase selected")
                 return
 
+            # Set TAVILY API key if needed for tool-based usecases
+            if usecase in ["Chatbot with Tool", "AI News"]:
+                tavily_key = user_input.get("TAVILY_API_KEY")
+                if tavily_key:
+                    os.environ["TAVILY_API_KEY"] = tavily_key
+                else:
+                    st.error("TAVILY API key is required for this usecase")
+                    return
+
             # Graph Builder
             graph_builder = GraphBuilder(model)
 

src/langgraphagenticai/nodes/chatbot_with_tool_node.py

@@ -0,0 +1,51 @@
+from src.langgraphagenticai.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
+
+    # def chatbot_node(state: State, llm_with_tools):
+    #     """
+    #     Chatbot logic for processing the input state and returning a response
+    #     """
+    #     return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+    # def create_chatbot(self, tools):
+    #     """
+    #     Returns a chatbot node function
+    #     """
+    #     llm_with_tools = self.llm.bind_tools(tools)
+
+    #     chatbot_node = self.chatbot_node(State, llm_with_tools)
+
+    #     return chatbot_node

src/langgraphagenticai/tools/search_tool.py

@@ -0,0 +1,20 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langgraph.prebuilt import ToolNode
+import os
+
+def get_tools():
+    """
+    Return the list of tools to be used in the chatbot
+    """
+    # Check if TAVILY_API_KEY is set
+    if not os.getenv("TAVILY_API_KEY"):
+        raise ValueError("TAVILY_API_KEY environment variable is not set")
+    
+    tool = TavilySearchResults(max_results=2)
+    return [tool]
+
+def create_tool_node(tools):
+    """
+    Creates and return tool node for the graph
+    """
+    return ToolNode(tools=tools)

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from langchain_core.messages import HumanMessage, AIMessage
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
 import json
 
 class DisplayResultStremlit:
@@ -20,4 +20,36 @@ class DisplayResultStremlit:
                     with st.chat_message("user"):
                         st.write(user_message)
                     with st.chat_message("assisstant"):
-                        st.write(value["messages"].content)
+                        st.write(value["messages"].content)
+
+        elif usecase == "Chatbot with Tool" or usecase == "AI News":
+            # Prepare state and invoke the graph
+            initial_state = {"messages": [HumanMessage(content=user_message)]}
+            
+            # Display user message
+            with st.chat_message("user"):
+                st.write(user_message)
+            
+            # Stream the graph execution
+            for event in graph.stream(initial_state):
+                for node_name, node_output in event.items():
+                    if "messages" in node_output:
+                        messages = node_output["messages"]
+                        if not isinstance(messages, list):
+                            messages = [messages]
+                        
+                        for message in messages:
+                            if isinstance(message, ToolMessage):
+                                with st.chat_message("assistant"):
+                                    st.write("🔍 **Tool Search Results:**")
+                                    st.write(message.content)
+                            elif isinstance(message, AIMessage):
+                                if message.tool_calls:
+                                    with st.chat_message("assistant"):
+                                        st.write("🔧 **Calling search tool...**")
+                                        for tool_call in message.tool_calls:
+                                            st.write(f"Searching for: {tool_call['args'].get('query', 'N/A')}")
+                                else:
+                                    with st.chat_message("assistant"):
+                                        st.write(message.content)
+