Fixed web UI

models.py

@@ -90,9 +90,7 @@ def get_model(provider_model: str, temperature: float = 0.7) -> BaseChatModel:
                     model = 'Qwen/Qwen2.5-72B-Instruct'
                 llm = HuggingFaceEndpoint(
                     repo_id=model,
-                    max_length=8192,
                     temperature=temperature,
-                    huggingfacehub_api_token=os.getenv("HUGGINGFACE_API_KEY"),
                 )
                 chat_llm = ChatHuggingFace(llm=llm)
             case 'ollama':

nlp_rag.py

@@ -115,7 +115,7 @@ def semantic_search(query, chunks, nlp, similarity_threshold=0.5, top_n=10):
 
 
 @traceable(run_type="llm", name="nlp_rag")
-def query_rag(chat_llm, query, relevant_results):
+def query_rag(chat_llm, query, relevant_results, callbacks = []):
     """
     Generate a response using retrieval-augmented generation (RAG) based on relevant results.
 
@@ -127,20 +127,36 @@ def query_rag(chat_llm, query, relevant_results):
     Returns:
         str: The generated response.
     """
-    import web_rag as wr
+    prompt = build_rag_prompt(query, relevant_results)
+    response = chat_llm.invoke(prompt).content
+    return response
 
-    formatted_chunks = ""
-    for chunk, similarity in relevant_results:
-        formatted_chunk = f"""
-        <source>
-        <url>{chunk['metadata']['source']}</url>
-        <title>{chunk['metadata']['title']}</title>
-        <text>{chunk['text']}</text>
-        </source>
-        """
-        formatted_chunks += formatted_chunk
 
+def build_rag_prompt(query, relevant_results):
+    import web_rag as wr
+    formatted_chunks = format_docs(relevant_results)
     prompt = wr.get_rag_prompt_template().format(query=query, context=formatted_chunks)  
+    return prompt
+
+def format_docs(relevant_results):
+    """
+    Convert relevant search results into a JSON-formatted string.
+
+    Args:
+        relevant_results (list): List of relevant chunks with metadata.
+
+    Returns:
+        str: JSON-formatted string of document chunks.
+    """
+    import json
+
+    formatted_chunks = []
+    for chunk, _ in relevant_results:  # Unpack the tuple, ignore similarity score
+        formatted_chunk = {
+            "content": chunk['text'],
+            "link": chunk['metadata'].get('source', ''),
+            "title": chunk['metadata'].get('title', ''),
+        }
+        formatted_chunks.append(formatted_chunk)
 
-    draft = chat_llm.invoke(prompt).content
-    return draft
+    return json.dumps(formatted_chunks, indent=2)

search_agent_ui.py

@@ -3,16 +3,19 @@ import os
 
 import dotenv
 import streamlit as st
+import spacy
 
 from langchain_core.tracers.langchain import LangChainTracer
 from langchain.callbacks.base import BaseCallbackHandler
 from langsmith.client import Client
 
-import web_rag as wr
 import web_crawler as wc
-import copywriter as cw
 import models as md
+import nlp_rag as nr
+import web_rag as wr
+
 dotenv.load_dotenv()
+nlp = nr.get_nlp_model()
 
 ls_tracer = LangChainTracer(
     project_name=os.getenv("LANGSMITH_PROJECT_NAME"),
@@ -56,6 +59,12 @@ st.title("🔍 Simple Search Agent 💬")
 
 if "models" not in st.session_state:
     models = []
+    if os.getenv("MISTRAL_API_KEY"):
+        models.append("mistral")
+    if os.getenv("HF_TOKEN"):
+        models.append("huggingface")    
+    if os.getenv("COHERE_API_KEY"):
+        models.append("cohere")
     if os.getenv("FIREWORKS_API_KEY"):
         models.append("fireworks")
     if os.getenv("TOGETHER_API_KEY"):
@@ -75,24 +84,12 @@ if "models" not in st.session_state:
 with st.sidebar.expander("Options", expanded=False):
     model_provider = st.selectbox("Model provider 🧠", st.session_state["models"])
     temperature = st.slider("Model temperature 🌡️", 0.0, 1.0, 0.1, help="The higher the more creative")
-    max_pages = st.slider("Max pages to retrieve 🔍", 1, 20, 10, help="How many web pages to retrive from the internet")
+    max_pages = st.slider("Max pages to retrieve 🔍", 1, 20, 10, help="How many web pages to retrieve from the internet")
     top_k_documents = st.slider("Nbr of doc extracts to consider 📄", 1, 20, 10, help="How many of the top extracts to consider")
-    reviewer_mode =  st.checkbox("Draft / Comment / Rewrite mode ✍️", value=False, help="First generate a draft, then comments and then rewrite")
 
 with st.sidebar.expander("Links", expanded=False):
     links_md = st.markdown("")
 
-if reviewer_mode:
-    with st.sidebar.expander("Answer review", expanded=False):
-        st.caption("Draft")  
-        draft_md = st.markdown("")
-        st.divider()
-        st.caption("Comments")
-        comments_md = st.markdown("")
-        st.divider()
-        st.caption("Comparaison")
-        comparaison_md = st.markdown("")   
-
 if "messages" not in st.session_state:
     st.session_state["messages"] = [{"role": "assistant", "content": "How can I help you?"}]
 
@@ -106,47 +103,30 @@ for message in st.session_state.messages:
             mime="text/plain"
         )
 
-if prompt := st.chat_input("Enter you instructions..." ):   
+if prompt := st.chat_input("Enter your instructions..." ):   
     st.chat_message("user").write(prompt)
     st.session_state.messages.append({"role": "user", "content": prompt})
 
     chat = md.get_model(model_provider, temperature)
-    embedding_model = md.get_embedding_model(model_provider)
 
     with st.status("Thinking", expanded=True):
         st.write("I first need to do some research")
         
-        optimize_search_query = wr.optimize_search_query(chat, query=prompt, callbacks=[ls_tracer])
-        st.write(f"I should search the web for: {optimize_search_query}")
+        optimized_search_query = wr.optimize_search_query(chat, query=prompt, callbacks=[ls_tracer])
+        st.write(f"I should search the web for: {optimized_search_query}")
         
-        sources = wc.get_sources(optimize_search_query, max_pages=max_pages)
+        sources = wc.get_sources(optimized_search_query, max_pages=max_pages)
         links_md.markdown(create_links_markdown(sources))
        
         st.write(f"I'll now retrieve the {len(sources)} webpages and documents I found")
         contents = wc.get_links_contents(sources, use_selenium=False)
 
-        st.write( f"Reading through the {len(contents)} sources I managed to retrieve")
-        vector_store = wc.vectorize(contents, embedding_model=embedding_model)
-        st.write(f"I collected {vector_store.index.ntotal} chunk of data and I can now answer")
+        st.write(f"Reading through the {len(contents)} sources I managed to retrieve")
+        chunks = nr.recursive_split_documents(contents)
+        relevant_results = nr.semantic_search(optimized_search_query, chunks, nlp, top_n=top_k_documents)
+        st.write(f"I collected {len(relevant_results)} chunks of data and I can now answer")
       
-    
-        if reviewer_mode:
-            st.write("Creating a draft")
-            draft_prompt = wr.build_rag_prompt(
-                chat, prompt, optimize_search_query, 
-                vector_store, top_k=top_k_documents, callbacks=[ls_tracer])
-            draft = chat.invoke(draft_prompt, stream=False, config={ "callbacks": [ls_tracer]})
-            draft_md.markdown(draft.content)
-            st.write("Sending draft for review")
-            comments = cw.generate_comments(chat, prompt, draft, callbacks=[ls_tracer])
-            comments_md.markdown(comments)
-            st.write("Reviewing comments and generating final answer")
-            rag_prompt = cw.get_final_text_prompt(prompt, draft, comments)
-        else:
-            rag_prompt = wr.build_rag_prompt(
-                chat, prompt, optimize_search_query, vector_store,
-                top_k=top_k_documents, callbacks=[ls_tracer]
-            )
+        rag_prompt = nr.build_rag_prompt(query=prompt, relevant_results=relevant_results)
 
     with st.chat_message("assistant"):
         st_cb = StreamHandler(st.empty())
@@ -185,9 +165,4 @@ if prompt := st.chat_input("Enter you instructions..." ):
             data=st.session_state.messages[-1]["content"],
             file_name=f"{message_id}.txt",
             mime="text/plain"
-        )
-        
-    if reviewer_mode:
-        compare_prompt = cw.get_compare_texts_prompts(prompt, draft_text=draft, final_text=response)
-        result = chat.invoke(compare_prompt, stream=False, config={ "callbacks": [ls_tracer]})
-        comparaison_md.markdown(result.content)
+        )

web_rag.py

@@ -19,6 +19,7 @@ Perform RAG using a single query to retrieve relevant documents.
 """
 import os
 import json
+from datetime import datetime
 from docopt import re
 from langchain.schema import SystemMessage, HumanMessage
 from langchain.prompts.chat import (
@@ -115,55 +116,6 @@ def get_optimized_search_messages(query):
 
 
 
-def get_optimized_search_messages2(query):
-    """
-    Generate optimized search messages for a given query.
-
-    Args:
-        query (str): The user's query.
-
-    Returns:
-        list: A list containing the system message and human message for optimized search.
-    """
-    system_message = SystemMessage(
-        content="""
-            You are a prompt optimizer for web search. Your task is to take a given chat prompt or question and transform it into an optimized search string that will yield the most relevant and useful information from a search engine like Google.
-
-            The goal is to create a search query that will help users find the most accurate and pertinent information related to their original prompt or question. An effective search string should be concise, use relevant keywords, and leverage search engine syntax for better results.
-
-            Here are some key principles for creating effective search queries:
-            1. Use specific and relevant keywords
-            2. Remove unnecessary words (articles, prepositions, etc.)
-            3. Utilize quotation marks for exact phrases
-            4. Employ Boolean operators (AND, OR, NOT) when appropriate
-            5. Include synonyms or related terms to broaden the search
-
-            I will provide you with a chat prompt or question. Your task is to optimize this into an effective search string.
-
-            Process the input as follows:
-            1. Analyze the Question to identify the main topic and key concepts.
-            2. Extract the most relevant keywords and phrases.
-            3. Consider any implicit information or context that might be useful for the search.
-
-            Then, optimize the search string by:
-            1. Removing filler words and unnecessary language
-            2. Rearranging keywords in a logical order
-            3. Adding quotation marks around exact phrases if applicable
-            4. Including relevant synonyms or related terms (in parentheses) to broaden the search
-            5. Using Boolean operators if needed to refine the search
-
-            You should answer only with the optimized search query and add "**" to the end of the search string to indicate the end of the optimized search query
-        """
-    )
-    human_message = HumanMessage(
-        content=f"""
-            Question: {query}
-
-        """
-    )
-    return [system_message, human_message]
-
-
 @traceable(run_type="llm", name="optimize_search_query")
 def optimize_search_query(chat_llm, query, callbacks=[]):
     """
@@ -200,10 +152,11 @@ def get_rag_prompt_template():
     Returns:
         ChatPromptTemplate: The prompt template for RAG.
     """
+    today = datetime.now().strftime("%Y-%m-%d")
     system_prompt = SystemMessagePromptTemplate(
         prompt=PromptTemplate(
             input_variables=[],
-            template="""
+            template=f"""
                 You are an expert research assistant.
                 You are provided with a Context in JSON format and a Question.
                 Each JSON entry contains: content, title, link
@@ -219,6 +172,8 @@ def get_rag_prompt_template():
                 If the provided context is not relevant to the question, say it and answer with your internal knowledge.
                 If you cannot answer the question using either the extracts or your internal knowledge, state that you don't have enough information to provide an accurate answer.
                 If the information in the provided context is in contradiction with your internal knowledge, answer but warn the user about the contradiction.
+
+                Today's date is {today}
             """
         )
     )