Update sherlock2.py

sherlock2.py

@@ -65,134 +65,6 @@ def generate_embeddings_from_documents(extracted_text):
             st.error(f"Error generating embeddings: {e}")
     return embeddings
 
-
-# Web scraping and Wikipedia search function
-def search_and_scrape_wikipedia(keywords, max_topics_per_query=3, react_model='gemini-pro'):
-    """
-    Searches and scrapes Wikipedia using the ReAct prompting method to find information relevant to the provided keywords.
-
-    Args:
-        keywords (list): A list of keywords to search for on Wikipedia.
-        max_topics_per_query (int, optional): The maximum number of Wikipedia topics to explore for each query. Defaults to 3.
-        react_model (str, optional): The name of the generative model to use with ReAct prompting. 
-                                     Defaults to 'gemini-pro'.
-    Returns:
-        list: A list of dictionaries, where each dictionary represents a relevant piece of information, with keys:
-        - "topic": The Wikipedia topic title.
-        - "summary": A summary of the relevant information extracted from the topic.
-        - "url": The URL of the Wikipedia page.
-        - "additional_sources": (Optional) A list of additional source URLs extracted from citations.
-    """
-
-    model_instructions = """Solve a question answering task with interleaving Thought, Action, Observation steps. Thought can reason about the current situation, Observation is understanding relevant information from an Action's output and Action can be of three types:
-    (1) , which searches the exact entity on Wikipedia and returns the first paragraph if it exists. If not, it will return some similar entities to search and you can try to search the information from those topics.
-    (2) , which returns the next sentence containing keyword in the current context. This only does exact matches, so keep your searches short.
-    (3) , which returns the answer and finishes the task.
-    """
-
-    # Define tools for ReAct (search, lookup, finish)
-    class ReAct:
-        def __init__(self, model: str, react_prompt: str):
-            self.model = genai.GenerativeModel(model)
-            self.chat = self.model.start_chat(history=[])
-            self.should_continue_prompting = True
-            self._search_history: list[str] = []
-            self._search_urls: list[str] = []
-            self._prompt = react_prompt
-
-        @classmethod
-        def add_method(cls, func):
-            setattr(cls, func.__name__, func)
-
-        @staticmethod
-        def clean(text: str):
-            text = text.replace("\n", " ")
-            return text
-
-        def search(self, query: str):
-            observation = None
-            query = query.strip()
-            try:
-                observation = wikipedia.summary(query, sentences=4, auto_suggest=False)
-                wiki_url = wikipedia.page(query, auto_suggest=False).url
-                observation = self.clean(observation)
-                self._search_history.append(query)
-                self._search_urls.append(wiki_url)
-            except (DisambiguationError, PageError) as e:
-                observation = f'Could not find ["{query}"]. Similar: {wikipedia.search(query)}.'
-            return observation
-
-        def lookup(self, phrase: str, context_length=200):
-            page = wikipedia.page(self._search_history[-1], auto_suggest=False).content
-            page = self.clean(page)
-            start_index = page.find(phrase)
-            result = page[max(0, start_index - context_length):start_index+len(phrase)+context_length]
-            return result
-
-        def finish(self, _):
-            self.should_continue_prompting = False
-
-        def __call__(self, user_question, max_calls: int=8, **generation_kwargs):
-            if len(self.chat.history) == 0:
-                model_prompt = self._prompt.format(question=user_question)
-            else:
-                model_prompt = user_question
-
-            callable_entities = ['', '', '']
-            generation_kwargs.update({'stop_sequences': callable_entities})
-
-            self.should_continue_prompting = True
-            for idx in range(max_calls):
-                self.response = self.chat.send_message(content=[model_prompt],
-                                                       generation_config=generation_kwargs, stream=False)
-                response_cmd = self.chat.history[-1].parts[-1].text
-                try:
-                    cmd = re.findall(r'<(.*)>', response_cmd)[-1]
-                    query = response_cmd.split(f'<{cmd}>')[-1].strip()
-                    observation = self.__getattribute__(cmd)(query)
-
-                    if not self.should_continue_prompting:
-                        break
-
-                    model_prompt = f"\nObservation {idx + 1}\n{observation}"
-
-                except (IndexError, AttributeError) as e:
-                    model_prompt = "Please try to generate thought-action-observation traces."
-
-    # Initialize ReAct with model and instructions
-    react_agent = ReAct(model=react_model, react_prompt=model_instructions) 
-
-    search_history = set()
-    wikipedia_info = []
-
-    for query in keywords:
-        # Use ReAct to search and extract information
-        react_agent(query) 
-        response_text = react_agent.response.text
-
-        # Process response_text to extract information
-        observations = []
-        for line in response_text.strip().split('\n'):
-            if line.startswith("Observation"):
-                observations.append(line.split(':')[-1].strip())
-
-        # Check if observations list is not empty before accessing elements
-        if observations:
-            summary = observations[-1]  
-            url = react_agent._search_urls[-1] 
-
-            # Create a dictionary with the extracted information
-            wikipedia_info.append({
-                "topic": query,  # Using the original query as the topic
-                "summary": summary,
-                "url": url
-            })
-        else:
-            # Handle the case where no observations were found (optional)
-            print(f"No observations found for query: {query}")
-
-    return wikipedia_info
-
 def extract_keywords_simple(extracted_text):
     """Extracts keywords and important information from the given text using Gemini 1.5 Pro."""
     prompt = """
@@ -299,16 +171,26 @@ def clear_chat():
     st.session_state.chat_history = []
 
 def show_intro_popup():
-    """Displays a popup with information about Sherlock and chat instructions."""
-    with st.expander("Welcome to AI Detective Sherlock Holmes!"):  # Use expander for a collapsible popup
+    """Displays a popup with detailed information about Sherlock and chat instructions, 
+    emphasizing the importance of reliable sources and cautioning against misleading online information."""
+    with st.expander("Welcome to AI Detective Sherlock Holmes!"):
         st.write("""
         **Meet Sherlock Holmes, the world's most renowned detective!**
 
         This application allows you to:
-        * **Investigate Cases:** Upload case files and images for Sherlock to analyze. 
-        * **Chat with Sherlock:** Ask him questions and get his insights. 
 
-        **To chat with Sherlock, go to the "Chat with Sherlock" page in the sidebar.** 
+        * **Investigate Cases:** Upload case files and images for Sherlock to analyze. He will use his exceptional deductive reasoning skills to uncover clues and provide insights.
+        * **Chat with Sherlock:** Ask him questions and get his expert opinion on various aspects of the case. 
+
+        **To chat with Sherlock, go to the "Chat with Sherlock" page in the sidebar.**
+
+        **Important Note:**
+
+        While the internet can be a valuable resource, it's crucial to be aware that not all information found online is accurate or reliable. To ensure the integrity of our investigation, we prioritize the use of trustworthy sources such as official documents, witness testimonies, and expert analysis. 
+
+        Therefore, **we advise against relying solely on internet searches** during the investigation process. Instead, focus on providing Sherlock with concrete evidence and factual information to facilitate his deductions.
+
+        Remember, the truth is often elusive, but with careful observation, logical reasoning, and a discerning eye, we can unravel even the most complex mysteries.
         """)
 
 def investigate():