added chatbot with web search functionality

.github/workflows/main.yml

@@ -2,6 +2,7 @@ name: Sync to Hugging Face Space
 on:
   push:
     branches: [main]
+
   workflow_dispatch:
 
 jobs:
@@ -10,8 +11,8 @@ jobs:
     steps:
       - uses: actions/checkout@v3
         with:
-          fetch-depth: 0
-          lfs: true
+          fetch-depth: 0 # Required for history rewriting
+          lfs: true # Enable Git LFS support
 
       - name: Install git-filter-repo
         run: pip install git-filter-repo
@@ -19,10 +20,17 @@ jobs:
       - name: Remove large file from history
         run: git filter-repo --path "Rag_Documents/layout-parser-paper.pdf" --invert-paths --force
 
-      - name: Push to Hugging Face Spaces
-        uses: huggingface/huggingface_hub@main
-        with:
-          target_repo: bpratik/Chatbot
-          token: ${{ secrets.HF_TOKEN }}
-          repo_type: space
-          space_sdk: streamlit  
+      - name: Log in to Hugging Face Hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          pip install -U "huggingface_hub>=0.20.0"
+          git config --global credential.helper store
+          echo "https://bpratik:$HF_TOKEN@huggingface.co" > ~/.git-credentials
+
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          git remote add hf https://huggingface.co/spaces/bpratik/Chatbot
+          git push --force hf main

README.md

@@ -206,24 +206,10 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## 🚧 Future Enhancements
 
-- [ ] **Memory/History Implementation**: Add persistent conversation memory using LangChain's built-in memory features
-- [ ] **Web Search Integration**: Implement web search capabilities for the chatbot
+- [x] **Memory/History Implementation**: Add persistent conversation memory using LangChain's built-in memory features
+- [x] **Web Search Integration**: Implement web search capabilities for the chatbot
 - [ ] **File Upload Support**: Allow users to upload and chat about documents
 - [ ] **Multiple Conversation Sessions**: Support for multiple concurrent chat sessions
 - [ ] **Custom Model Integration**: Support for additional LLM providers
 - [ ] **Chat Export**: Export conversation history to various formats
 
-## 📞 Support
-
-If you encounter any issues or have questions, please:
-1. Check the troubleshooting section above
-2. Search existing GitHub issues
-3. Create a new issue with detailed information about the problem
-
-## 🙏 Acknowledgments
-
-- [LangChain](https://langchain.com/) for the AI framework
-- [LangGraph](https://langchain-ai.github.io/langgraph/) for state graph implementation
-- [Streamlit](https://streamlit.io/) for the web interface
-- [Groq](https://groq.com/) for fast inference
-- [OpenAI](https://openai.com/) for GPT models

requirements.txt

@@ -6,3 +6,4 @@ langchain_openai
 langchain_groq
 langchain_core
 streamlit
+tavily-python

src/graph/graph_builder.py

@@ -4,15 +4,17 @@ from langchain_core.prompts import ChatPromptTemplate
 import datetime
 from src.state.state import State
 from src.nodes.basic_chatbot import BasicChatbot
+from src.nodes.websearch_chatbot import WebSearchChatbot
 
 
 class GraphBuilder:
     
     """Class to build the state graph for the application."""
 
-    def __init__(self, model, session_id: str = "default"):
+    def __init__(self, model, session_id: str = "default", tavily_api_key: str = None):
         self.llm = model
         self.session_id = session_id
+        self.tavily_api_key = tavily_api_key
         self.graph_builder = StateGraph(State)
     
     def basic_chatbot(self):
@@ -22,6 +24,12 @@ class GraphBuilder:
         self.graph_builder.add_edge(START, 'basic_chatbot')
         self.graph_builder.add_edge('basic_chatbot', END)                                  
 
+    def websearch_chatbot(self):
+        self.websearch_chatbot_node = WebSearchChatbot(self.llm, self.session_id, self.tavily_api_key)
+        self.graph_builder.add_node('websearch_chatbot', self.websearch_chatbot_node.process)
+        self.graph_builder.add_edge(START, 'websearch_chatbot')
+        self.graph_builder.add_edge('websearch_chatbot', END)                                  
+
     def setup_graph(self, use_case: str):
         """
         Setup the graph with the appropriate nodes based on use case.
@@ -31,8 +39,9 @@ class GraphBuilder:
         
         if use_case == 'Basic Chatbot':
             self.basic_chatbot()
+        elif use_case == 'Chatbot with Web Search':
+            self.websearch_chatbot()
         else:
-            # Default to basic chatbot if use case is not recognized
             self.basic_chatbot()
         
         # Compile and return the graph

src/main.py

@@ -81,7 +81,13 @@ def load_app():
                 model, st.session_state.session_id
             )
             
-            graph_builder = GraphBuilder(model=memory_enabled_model, session_id=st.session_state.session_id)
+            tavily_api_key = user_input.get('Tavily API Key', '')
+            
+            graph_builder = GraphBuilder(
+                model=memory_enabled_model, 
+                session_id=st.session_state.session_id,
+                tavily_api_key=tavily_api_key
+            )
 
             try:
                 graph = graph_builder.setup_graph(use_case=use_case)

src/nodes/websearch_chatbot.py

@@ -0,0 +1,60 @@
+from src.state.state import State
+from src.tools.websearch import WebSearchTool
+from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
+from langchain.tools import BaseTool
+
+class WebSearchChatbot:
+    def __init__(self, model, session_id: str = "default", tavily_api_key: str = None):
+        self.model = model
+        self.session_id = session_id
+        self.memory_config = {"configurable": {"session_id": session_id}}
+        
+        if tavily_api_key and tavily_api_key.strip():
+            try:
+                self.web_search = WebSearchTool(tavily_api_key)
+                self.tools = [self.web_search.get_tool()]
+                self.model_with_tools = model.bind_tools(self.tools)
+                self.has_search = True
+            except Exception as e:
+                self.model_with_tools = model
+                self.has_search = False
+        else:
+            self.model_with_tools = model
+            self.has_search = False
+
+    def process(self, state):
+        messages = state['messages']
+        if not messages:
+            return state
+        
+        if not self.has_search:
+            # If no search capability, add a message about it
+            last_message = messages[-1]
+            if hasattr(last_message, 'content') and any(keyword in last_message.content.lower() for keyword in ['search', 'find', 'latest', 'current', 'news']):
+                search_disclaimer = "I don't have web search capabilities enabled. Please provide a Tavily API key to search for current information."
+                response_content = f"{search_disclaimer}\n\nBased on my training data, I can still help with general questions."
+                from langchain_core.messages import AIMessage
+                return {'messages': AIMessage(content=response_content)}
+        
+        response = self.model_with_tools.invoke(messages, config=self.memory_config)
+        
+        if hasattr(response, 'tool_calls') and response.tool_calls:
+            messages.append(response)
+            
+            for tool_call in response.tool_calls:
+                tool_result = self._execute_tool_call(tool_call)
+                tool_message = ToolMessage(
+                    content=str(tool_result),
+                    tool_call_id=tool_call['id']
+                )
+                messages.append(tool_message)
+            
+            final_response = self.model_with_tools.invoke(messages, config=self.memory_config)
+            return {'messages': final_response}
+        
+        return {'messages': response}
+    
+    def _execute_tool_call(self, tool_call):
+        if tool_call['name'] == 'tavily_search_results_json':
+            return self.web_search.search_tool.invoke(tool_call['args'])
+        return "Tool not found"

src/tools/websearch.py

@@ -0,0 +1,40 @@
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_core.tools import tool
+import os
+
+class WebSearchTool:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        if not api_key:
+            raise ValueError("Tavily API key is required for web search functionality")
+        
+        # Set the API key as environment variable for TavilySearchResults
+        os.environ["TAVILY_API_KEY"] = api_key
+        
+        self.search_tool = TavilySearchResults(
+            max_results=5
+        )
+    
+    def search_web(self, query: str) -> str:
+        """Search the web for current information about the given query."""
+        try:
+            results = self.search_tool.invoke(query)
+            if not results:
+                return "No search results found."
+                
+            formatted_results = []
+            for result in results:
+                if isinstance(result, dict):
+                    title = result.get('title', 'N/A')
+                    content = result.get('content', 'N/A')
+                    url = result.get('url', 'N/A')
+                    formatted_results.append(f"Title: {title}\nContent: {content}\nURL: {url}\n")
+                else:
+                    formatted_results.append(str(result))
+            
+            return "\n".join(formatted_results)
+        except Exception as e:
+            return f"Error searching the web: {str(e)}"
+    
+    def get_tool(self):
+        return self.search_tool

src/ui/config.ini

@@ -1,5 +1,5 @@
 [DEFAULT]
-Title = Basic Chatbot
+Title = AI Chatbot with Web Search
 USE_CASE = Basic Chatbot, Chatbot with Web Search
 LLM_options = Groq, OpenAI
 

src/ui/load.py

@@ -62,6 +62,12 @@ class LoadStreamlitUI:
       # Use Case Selection
       self.user_controls['Selected Use Case'] = st.selectbox('Select Use Case', use_case)
 
+      # Tavily API Key for Web Search
+      if self.user_controls['Selected Use Case'] == 'Chatbot with Web Search':
+          self.user_controls['Tavily API Key'] = st.text_input('Enter Tavily API Key for Web Search', type='password')
+          if not self.user_controls['Tavily API Key']:
+              st.warning('Tavily API key is required for web search functionality. Get one at https://tavily.com')
+
       # Memory Management Section
       st.divider()
       st.subheader("💭 Memory Management")