Update app.py

app.py

@@ -10,8 +10,7 @@ import string
 
 ###
 
-import requests
-from bs4 import BeautifulSoup
+import wikipedia
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -126,37 +125,46 @@ class SuperSmartAgent:
             return state
 
         ###################
-        def query_wikipedia(question):
-            search_url = "https://en.wikipedia.org/w/api.php"
-            params = {
-                "action": "query",
-                "list": "search",
-                "srsearch": question,
-                "format": "json",
-                "srlimit": 1  # get top result only
-            }
-            response = requests.get(search_url, params=params)
-            data = response.json()
+        def general_reasoning_qa(state):
+            question = state["question"]
+            
+            # Step 1: Search Wikipedia broadly
+            search_results = wikipedia.search(question)
+            relevant_pages = search_results[:3]  # get top 3 pages
+            
+            context = ""
+            for title in relevant_pages:
+                try:
+                    context += wikipedia.page(title).content + "\n"
+                except:
+                    continue
         
-            if "query" not in data or len(data["query"]["search"]) == 0:
-                return "No relevant Wikipedia page found."
+            if not context:
+                state["response"] = "Sorry, I couldn’t find enough information."
+                return state
         
-            page_title = data["query"]["search"][0]["title"]
-            page_url = f"https://en.wikipedia.org/wiki/{page_title.replace(' ', '_')}"
+            # Step 2: Ask the LLM to reason over the context
+            prompt = f"""
+            Based on the following Wikipedia content, answer the question:
             
-            # Fetch the page content
-            page_resp = requests.get(page_url)
-            if page_resp.status_code != 200:
-                return f"Could not retrieve Wikipedia page for '{page_title}'."
-        
-            soup = BeautifulSoup(page_resp.text, "html.parser")
-            paragraphs = soup.select("p")
-            for p in paragraphs:
-                text = p.get_text().strip()
-                if len(text) > 50:  # Skip very short paragraphs
-                    return f"From Wikipedia page '{page_title}':\n\n{text}"
+            Question: {question}
+            
+            Context:
+            {context}
+            
+            Answer in a single sentence.
+            """
         
-            return f"Page '{page_title}' found but no suitable paragraph available."
+            state["response"] = call_llm(prompt)  # call your preferred LLM method
+            return state
+
+        def check_reasoning_needed(state):
+            q = state["question"].lower()
+            # very rough heuristic — refine as needed
+            needs_reasoning = any(word in q for word in ["whose", "only", "first", "after", "before", "no longer", "not", "but", "except"])
+            state["needs_reasoning"] = needs_reasoning
+            return state
+    
 
         def check_wikipedia_suitability(state):
             q = state["question"].lower()
@@ -168,7 +176,17 @@ class SuperSmartAgent:
         
         def search_wikipedia(state):
             question = state["question"]
-            state["response"] = query_wikipedia(question)
+            try:
+                page_titles = wikipedia.search(question)
+                if not page_titles:
+                    state["response"] = "No relevant Wikipedia article found."
+                    return state
+        
+                page = wikipedia.page(page_titles[0])
+                summary = page.summary
+                state["response"] = summary
+            except Exception as e:
+                state["response"] = f"Error fetching Wikipedia content: {e}"
             return state
 
         ##################
@@ -183,21 +201,24 @@ class SuperSmartAgent:
         
         builder = StateGraph(AgentState)
 
+
         # --- Nodes ---
         builder.add_node("check_reversed", check_reversed)
         builder.add_node("fix_question", fix_question)
         builder.add_node("check_riddle_or_trick", check_riddle_or_trick)
         builder.add_node("solve_riddle", solve_riddle)
         builder.add_node("check_wikipedia_suitability", check_wikipedia_suitability)
+        builder.add_node("check_reasoning_needed", check_reasoning_needed)
+        builder.add_node("general_reasoning_qa", general_reasoning_qa)
         builder.add_node("search_wikipedia", search_wikipedia)
         builder.add_node("check_python_suitability", check_python_suitability)
         builder.add_node("generate_code", generate_code)
         builder.add_node("fallback", fallback)
-
-        # --- Entry point ---
-        builder.set_entry_point("check_reversed")
         
-        # --- Reasoning pipeline ---
+        # Entry
+        builder.set_entry_point("check_reversed")
+
+        # Edges
         builder.add_edge("check_reversed", "fix_question")
         builder.add_edge("fix_question", "check_riddle_or_trick")
         
@@ -206,24 +227,30 @@ class SuperSmartAgent:
             lambda s: "solve_riddle" if s.get("is_riddle") else "check_wikipedia_suitability"
         )
         
-        builder.add_edge("solve_riddle", END)
-        
         builder.add_conditional_edges(
             "check_wikipedia_suitability",
-            lambda s: "search_wikipedia" if s.get("is_wiki") else "check_python_suitability"
+            lambda s: "search_wikipedia" if s.get("is_wiki") else "check_reasoning_needed"
         )
         
-        builder.add_edge("search_wikipedia", END)
+        builder.add_conditional_edges(
+            "check_reasoning_needed",
+            lambda s: "general_reasoning_qa" if s.get("needs_reasoning") else "check_python_suitability"
+        )
         
         builder.add_conditional_edges(
             "check_python_suitability",
             lambda s: "generate_code" if s.get("is_python") else "fallback"
         )
         
+        # Ends
+        builder.add_edge("solve_riddle", END)
+        builder.add_edge("search_wikipedia", END)
+        builder.add_edge("general_reasoning_qa", END)
         builder.add_edge("generate_code", END)
         builder.add_edge("fallback", END)
 
 
+
         
   
         graph = builder.compile()