Update app.py

app.py

@@ -1,50 +1,52 @@
 import streamlit as st
-import os
-from tavily import TavilyClient
+import wikipedia
 from groq import Groq
+import os
 
 # Step 1: Retrieve API Keys from Hugging Face Secrets
-TAVILY_API_KEY = st.secrets["TAVILY_API_KEY"]
 GROQ_API_KEY = st.secrets["GROQ_API_KEY"]
 
-# Step 2: Initialize Clients for Tavily and Groq
-if TAVILY_API_KEY is None or GROQ_API_KEY is None:
-    st.error("API key(s) are missing. Please add the API keys in Hugging Face Secrets.")
+# Step 2: Initialize Groq Client
+if GROQ_API_KEY is None:
+    st.error("Groq API key is missing. Please add the API key in Hugging Face Secrets.")
 else:
-    tavily_client = TavilyClient(api_key=TAVILY_API_KEY)
     groq_client = Groq(api_key=GROQ_API_KEY)
 
-    # Step 3: Fetch Suggestions Using Tavily
-    def fetch_tavily_suggestions(query):
+    # Step 3: Wikipedia Query Function
+    def get_wikipedia_response(query):
         """
-        Use Tavily API to fetch real-time suggestions based on the query.
+        Fetch information from Wikipedia based on the query.
         """
         try:
-            response = tavily_client.search(query)
-            return response.get("text", None)  # Return None if no suggestions are available
+            # Fetch a summary of the query from Wikipedia
+            result = wikipedia.summary(query, sentences=3)
+            return result
+        except wikipedia.exceptions.DisambiguationError as e:
+            return f"Ambiguous query, please clarify: {e.options}"
+        except wikipedia.exceptions.HTTPTimeoutError:
+            return "Error: Wikipedia request timed out. Please try again."
+        except wikipedia.exceptions.RedirectError:
+            return "Error: Redirect error while fetching Wikipedia data."
         except Exception as e:
-            return None  # Return None in case of error
+            return f"An unexpected error occurred: {str(e)}"
 
-    # Step 4: Enhance Suggestions Using Groq
+    # Step 4: Enhance with Groq (if needed)
     def enhance_with_groq(query, suggestions=None):
         """
-        If suggestions are provided by Tavily, enhance them using Groq.
-        Otherwise, generate a response using Groq based on the original query.
+        Enhance suggestions using Groq or generate from scratch.
         """
         if suggestions is None:
-            # If no suggestions from Tavily, generate from Groq directly
+            # If no suggestions, use Groq to generate an enhancement
             response_content = query
         else:
-            # If suggestions from Tavily exist, use them as context
             response_content = suggestions
 
         try:
-            # Perform chat completion using Groq for better formatting and response enhancement
+            # Perform chat completion using Groq
             chat_completion = groq_client.chat.completions.create(
                 messages=[{"role": "user", "content": response_content}],
                 model="llama-3.3-70b-versatile",  # Specify model for Groq
             )
-            # Extract and return the enhanced message
             return chat_completion.choices[0].message.content
         except Exception as e:
             return f"Error with Groq API: {str(e)}"
@@ -67,23 +69,22 @@ else:
     # Fetch and Enhance Suggestions
     if st.sidebar.button("Get Suggestions"):
         if location:
-            query = f"Provide internet connectivity options for rural areas near {location}, especially affordable providers."
+            # Query Wikipedia first for general information about the location
+            wikipedia_query = f"Internet providers in {location}"
+            wikipedia_response = get_wikipedia_response(wikipedia_query)
+
             st.subheader(f"Suggestions for {needs} in {location}")
-            
-            # Get suggestions from Tavily
-            tavily_suggestions = fetch_tavily_suggestions(query)
+            st.write("Raw Suggestions from Wikipedia:")
+            st.write(wikipedia_response)
 
-            if tavily_suggestions:
-                st.write("Raw Suggestions from Tavily:")
-                st.write(tavily_suggestions)
-                # Enhance the response using Groq
-                enhanced_suggestions = enhance_with_groq(query, tavily_suggestions)
+            # If Wikipedia response is not enough, use Groq to enhance
+            if wikipedia_response:
+                enhanced_response = enhance_with_groq(wikipedia_query, wikipedia_response)
                 st.subheader("Enhanced Suggestions from Groq:")
-                st.write(enhanced_suggestions)
+                st.write(enhanced_response)
             else:
-                st.write("No suggestions available from Tavily. Generating response from Groq...")
-                # If Tavily doesn't provide any suggestions, generate a response from Groq
-                groq_response = enhance_with_groq(query)
+                # If no meaningful Wikipedia results, fallback to Groq
+                groq_response = enhance_with_groq(wikipedia_query)
                 st.subheader("Generated Response from Groq:")
                 st.write(groq_response)
         else: