Connecting to front

app.py

@@ -4,7 +4,7 @@ embeddings_function = get_embeddings_function()
 from climateqa.papers.openalex import OpenAlex
 from sentence_transformers import CrossEncoder
 
-reranker = CrossEncoder("mixedbread-ai/mxbai-rerank-xsmall-v1")
+# reranker = CrossEncoder("mixedbread-ai/mxbai-rerank-xsmall-v1")
 oa = OpenAlex()
 
 import gradio as gr
@@ -29,16 +29,19 @@ from utils import create_user_id
 
 # ClimateQ&A imports
 from climateqa.engine.llm import get_llm
-from climateqa.engine.chains.answer_rag import make_rag_chain
 from climateqa.engine.vectorstore import get_pinecone_vectorstore
 from climateqa.engine.retriever import ClimateQARetriever
+from climateqa.engine.reranker import get_reranker
 from climateqa.engine.embeddings import get_embeddings_function
 from climateqa.engine.chains.prompts import audience_prompts
 from climateqa.sample_questions import QUESTIONS
 from climateqa.constants import POSSIBLE_REPORTS
 from climateqa.utils import get_image_from_azure_blob_storage
 from climateqa.engine.keywords import make_keywords_chain
-from climateqa.engine.chains.answer_rag import make_rag_papers_chain
+# from climateqa.engine.chains.answer_rag import make_rag_papers_chain
+from climateqa.engine.graph import make_graph_agent,display_graph
+
+from front.utils import make_html_source,parse_output_llm_with_sources,serialize_docs,make_toolbox
 
 # Load environment variables in local mode
 try:
@@ -81,48 +84,21 @@ user_id = create_user_id()
 
 
 
-def parse_output_llm_with_sources(output):
-    # Split the content into a list of text and "[Doc X]" references
-    content_parts = re.split(r'\[(Doc\s?\d+(?:,\s?Doc\s?\d+)*)\]', output)
-    parts = []
-    for part in content_parts:
-        if part.startswith("Doc"):
-            subparts = part.split(",")
-            subparts = [subpart.lower().replace("doc","").strip() for subpart in subparts]
-            subparts = [f"""<a href="#doc{subpart}" class="a-doc-ref" target="_self"><span class='doc-ref'><sup>{subpart}</sup></span></a>""" for subpart in subparts]
-            parts.append("".join(subparts))
-        else:
-            parts.append(part)
-    content_parts = "".join(parts)
-    return content_parts
-
-
 # Create vectorstore and retriever
 vectorstore = get_pinecone_vectorstore(embeddings_function)
 llm = get_llm(provider="openai",max_tokens = 1024,temperature = 0.0)
+reranker = get_reranker("nano")
+agent = make_graph_agent(llm,vectorstore,reranker)
 
 
-def make_pairs(lst):
-    """from a list of even lenght, make tupple pairs"""
-    return [(lst[i], lst[i + 1]) for i in range(0, len(lst), 2)]
-
-
-def serialize_docs(docs):
-    new_docs = []
-    for doc in docs:
-        new_doc = {}
-        new_doc["page_content"] = doc.page_content
-        new_doc["metadata"] = doc.metadata
-        new_docs.append(new_doc)
-    return new_docs
-
 
 
 async def chat(query,history,audience,sources,reports):
     """taking a query and a message history, use a pipeline (reformulation, retriever, answering) to yield a tuple of:
     (messages in gradio format, messages in langchain format, source documents)"""
 
-    print(f">> NEW QUESTION : {query}")
+    date_now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f">> NEW QUESTION ({date_now}) : {query}")
 
     if audience == "Children":
         audience_prompt = audience_prompts["children"]
@@ -139,59 +115,39 @@ async def chat(query,history,audience,sources,reports):
 
     if len(reports) == 0:
         reports = []
-
-    retriever = ClimateQARetriever(vectorstore=vectorstore,sources = sources,min_size = 200,reports = reports,k_summary = 3,k_total = 15,threshold=0.5)
-    rag_chain = make_rag_chain(retriever,llm)
     
-    inputs = {"query": query,"audience": audience_prompt}
-    result = rag_chain.astream_log(inputs) #{"callbacks":[MyCustomAsyncHandler()]})
+    inputs = {"user_input": query,"audience": audience_prompt,"sources":sources}
+    result = agent.astream_events(inputs,version = "v1") #{"callbacks":[MyCustomAsyncHandler()]})
     # result = rag_chain.stream(inputs)
 
-    path_reformulation = "/logs/reformulation/final_output"
-    path_keywords = "/logs/keywords/final_output"
-    path_retriever = "/logs/find_documents/final_output"
-    path_answer = "/logs/answer/streamed_output_str/-"
+    # path_reformulation = "/logs/reformulation/final_output"
+    # path_keywords = "/logs/keywords/final_output"
+    # path_retriever = "/logs/find_documents/final_output"
+    # path_answer = "/logs/answer/streamed_output_str/-"
 
+    docs = []
     docs_html = ""
     output_query = ""
     output_language = ""
     output_keywords = ""
     gallery = []
+    start_streaming = False
 
-    try:
-        async for op in result:
-
-            op = op.ops[0]
+    steps_display = {
+        "categorize_intent":("🔄️ Analyzing user message",True),
+        "transform_query":("🔄️ Thinking step by step to answer the question",True),
+        "retrieve_documents":("🔄️ Searching in the knowledge base",False),
+    }
 
-            if op['path'] == path_reformulation: # reforulated question
-                try:
-                    output_language = op['value']["language"] # str
-                    output_query = op["value"]["question"]
-                except Exception as e:
-                    raise gr.Error(f"ClimateQ&A Error: {e} - The error has been noted, try another question and if the error remains, you can contact us :)")
-            
-            if op["path"] == path_keywords:
-                try:
-                    output_keywords = op['value']["keywords"] # str
-                    output_keywords = " AND ".join(output_keywords)
-                except Exception as e:
-                    pass
-            
+    try:
+        async for event in result:
 
-            elif op['path'] == path_retriever: # documents
-                try:
-                    docs = op['value']['docs'] # List[Document]
-                    docs_html = []
-                    for i, d in enumerate(docs, 1):
-                        docs_html.append(make_html_source(d, i))
-                    docs_html = "".join(docs_html)
-                except TypeError:
-                    print("No documents found")
-                    print("op: ",op)
-                    continue
+            if event["event"] == "on_chat_model_stream":
+                if start_streaming == False:
+                    start_streaming = True
+                    history[-1] = (query,"")
 
-            elif op['path'] == path_answer: # final answer
-                new_token = op['value'] # str
+                new_token = event["data"]["chunk"].content
                 # time.sleep(0.01)
                 previous_answer = history[-1][1]
                 previous_answer = previous_answer if previous_answer is not None else ""
@@ -199,10 +155,47 @@ async def chat(query,history,audience,sources,reports):
                 answer_yet = parse_output_llm_with_sources(answer_yet)
                 history[-1] = (query,answer_yet)
 
+            
+            elif event["name"] == "retrieve_documents" and event["event"] == "on_chain_end":
+                try:
+                    docs = event["data"]["output"]["documents"]
+                    docs_html = []
+                    for i, d in enumerate(docs, 1):
+                        docs_html.append(make_html_source(d, i))
+                    docs_html = "".join(docs_html)
+                except Exception as e:
+                    print(f"Error getting documents: {e}")
+                    print(event)
+
+
+            for event_name,(event_description,display_output) in steps_display.items():
+                if event["name"] == event_name:
+                    if event["event"] == "on_chain_start":
+                        # answer_yet = f"<p><span class='loader'></span>{event_description}</p>"
+                        # answer_yet = make_toolbox(event_description, "", checked = False)
+                        answer_yet = event_description
+                        history[-1] = (query,answer_yet)
+                    # elif event["event"] == "on_chain_end":
+                    #     answer_yet = ""
+                    #     history[-1] = (query,answer_yet)
+                        # if display_output:
+                        #     print(event["data"]["output"])
+
+            # if op['path'] == path_reformulation: # reforulated question
+            #     try:
+            #         output_language = op['value']["language"] # str
+            #         output_query = op["value"]["question"]
+            #     except Exception as e:
+            #         raise gr.Error(f"ClimateQ&A Error: {e} - The error has been noted, try another question and if the error remains, you can contact us :)")
+            
+            # if op["path"] == path_keywords:
+            #     try:
+            #         output_keywords = op['value']["keywords"] # str
+            #         output_keywords = " AND ".join(output_keywords)
+            #     except Exception as e:
+            #         pass
 
 
-            else:
-                continue
 
             history = [tuple(x) for x in history]
             yield history,docs_html,output_query,output_language,gallery,output_query,output_keywords
@@ -276,68 +269,6 @@ async def chat(query,history,audience,sources,reports):
     yield history,docs_html,output_query,output_language,gallery,output_query,output_keywords
 
 
-def make_html_source(source,i):
-    meta = source.metadata
-    # content = source.page_content.split(":",1)[1].strip()
-    content = source.page_content.strip()
-
-    toc_levels = []
-    for j in range(2):
-        level = meta[f"toc_level{j}"]
-        if level != "N/A":
-            toc_levels.append(level)
-        else:
-            break
-    toc_levels = " > ".join(toc_levels)
-
-    if len(toc_levels) > 0:
-        name = f"<b>{toc_levels}</b><br/>{meta['name']}"
-    else:
-        name = meta['name']
-
-    if meta["chunk_type"] == "text":
-
-        card = f"""
-    <div class="card" id="doc{i}">
-        <div class="card-content">
-            <h2>Doc {i} - {meta['short_name']} - Page {int(meta['page_number'])}</h2>
-            <p>{content}</p>
-        </div>
-        <div class="card-footer">
-            <span>{name}</span>
-            <a href="{meta['url']}#page={int(meta['page_number'])}" target="_blank" class="pdf-link">
-                <span role="img" aria-label="Open PDF">🔗</span>
-            </a>
-        </div>
-    </div>
-    """
-    
-    else:
-
-        if meta["figure_code"] != "N/A":
-            title = f"{meta['figure_code']} - {meta['short_name']}"
-        else:
-            title = f"{meta['short_name']}"
-
-        card = f"""
-    <div class="card card-image">
-        <div class="card-content">
-            <h2>Image {i} - {title} - Page {int(meta['page_number'])}</h2>
-            <p>{content}</p>
-            <p class='ai-generated'>AI-generated description</p>
-        </div>
-        <div class="card-footer">
-            <span>{name}</span>
-            <a href="{meta['url']}#page={int(meta['page_number'])}" target="_blank" class="pdf-link">
-                <span role="img" aria-label="Open PDF">🔗</span>
-            </a>
-        </div>
-    </div>
-    """
-        
-    return card
-
-
 
 #     else:
 #         docs_string = "No relevant passages found in the climate science reports (IPCC and IPBES)"
@@ -390,54 +321,54 @@ papers_cols_widths = {
 papers_cols = list(papers_cols_widths.keys())
 papers_cols_widths = list(papers_cols_widths.values())
 
-async def find_papers(query, keywords,after):
+# async def find_papers(query, keywords,after):
 
-    summary = ""
+#     summary = ""
     
-    df_works = oa.search(keywords,after = after)
-    df_works = df_works.dropna(subset=["abstract"])
-    df_works = oa.rerank(query,df_works,reranker)
-    df_works = df_works.sort_values("rerank_score",ascending=False)
-    G = oa.make_network(df_works)
+#     df_works = oa.search(keywords,after = after)
+#     df_works = df_works.dropna(subset=["abstract"])
+#     df_works = oa.rerank(query,df_works,reranker)
+#     df_works = df_works.sort_values("rerank_score",ascending=False)
+#     G = oa.make_network(df_works)
 
-    height = "750px"
-    network = oa.show_network(G,color_by = "rerank_score",notebook=False,height = height)
-    network_html = network.generate_html()
+#     height = "750px"
+#     network = oa.show_network(G,color_by = "rerank_score",notebook=False,height = height)
+#     network_html = network.generate_html()
 
-    network_html = network_html.replace("'", "\"")
-    css_to_inject = "<style>#mynetwork { border: none !important; } .card { border: none !important; }</style>"
-    network_html = network_html + css_to_inject
+#     network_html = network_html.replace("'", "\"")
+#     css_to_inject = "<style>#mynetwork { border: none !important; } .card { border: none !important; }</style>"
+#     network_html = network_html + css_to_inject
 
     
-    network_html = f"""<iframe style="width: 100%; height: {height};margin:0 auto" name="result" allow="midi; geolocation; microphone; camera; 
-    display-capture; encrypted-media;" sandbox="allow-modals allow-forms 
-    allow-scripts allow-same-origin allow-popups 
-    allow-top-navigation-by-user-activation allow-downloads" allowfullscreen="" 
-    allowpaymentrequest="" frameborder="0" srcdoc='{network_html}'></iframe>"""
+#     network_html = f"""<iframe style="width: 100%; height: {height};margin:0 auto" name="result" allow="midi; geolocation; microphone; camera; 
+#     display-capture; encrypted-media;" sandbox="allow-modals allow-forms 
+#     allow-scripts allow-same-origin allow-popups 
+#     allow-top-navigation-by-user-activation allow-downloads" allowfullscreen="" 
+#     allowpaymentrequest="" frameborder="0" srcdoc='{network_html}'></iframe>"""
 
 
-    docs = df_works["content"].head(15).tolist()
+#     docs = df_works["content"].head(15).tolist()
 
-    df_works = df_works.reset_index(drop = True).reset_index().rename(columns = {"index":"doc"})
-    df_works["doc"] = df_works["doc"] + 1
-    df_works = df_works[papers_cols]
+#     df_works = df_works.reset_index(drop = True).reset_index().rename(columns = {"index":"doc"})
+#     df_works["doc"] = df_works["doc"] + 1
+#     df_works = df_works[papers_cols]
 
-    yield df_works,network_html,summary
+#     yield df_works,network_html,summary
 
-    chain = make_rag_papers_chain(llm)
-    result = chain.astream_log({"question": query,"docs": docs,"language":"English"})
-    path_answer = "/logs/StrOutputParser/streamed_output/-"
+#     chain = make_rag_papers_chain(llm)
+#     result = chain.astream_log({"question": query,"docs": docs,"language":"English"})
+#     path_answer = "/logs/StrOutputParser/streamed_output/-"
 
-    async for op in result:
+#     async for op in result:
 
-        op = op.ops[0]
+#         op = op.ops[0]
 
-        if op['path'] == path_answer: # reforulated question
-            new_token = op['value'] # str
-            summary += new_token
-        else:
-            continue
-        yield df_works,network_html,summary
+#         if op['path'] == path_answer: # reforulated question
+#             new_token = op['value'] # str
+#             summary += new_token
+#         else:
+#             continue
+#         yield df_works,network_html,summary
     
 
 
@@ -560,9 +491,6 @@ with gr.Blocks(title="Climate Q&A", css="style.css", theme=theme,elem_id = "main
 
 
 
-
-
-
 #---------------------------------------------------------------------------------------
 # OTHER TABS
 #---------------------------------------------------------------------------------------
@@ -571,25 +499,25 @@ with gr.Blocks(title="Climate Q&A", css="style.css", theme=theme,elem_id = "main
     with gr.Tab("Figures",elem_id = "tab-images",elem_classes = "max-height other-tabs"):
         gallery_component = gr.Gallery()
 
-    with gr.Tab("Papers (beta)",elem_id = "tab-papers",elem_classes = "max-height other-tabs"):
+    # with gr.Tab("Papers (beta)",elem_id = "tab-papers",elem_classes = "max-height other-tabs"):
 
-        with gr.Row():
-            with gr.Column(scale=1):
-                query_papers = gr.Textbox(placeholder="Question",show_label=False,lines = 1,interactive = True,elem_id="query-papers")
-                keywords_papers = gr.Textbox(placeholder="Keywords",show_label=False,lines = 1,interactive = True,elem_id="keywords-papers")
-                after = gr.Slider(minimum=1950,maximum=2023,step=1,value=1960,label="Publication date",show_label=True,interactive=True,elem_id="date-papers")
-                search_papers = gr.Button("Search",elem_id="search-papers",interactive=True)
+    #     with gr.Row():
+    #         with gr.Column(scale=1):
+    #             query_papers = gr.Textbox(placeholder="Question",show_label=False,lines = 1,interactive = True,elem_id="query-papers")
+    #             keywords_papers = gr.Textbox(placeholder="Keywords",show_label=False,lines = 1,interactive = True,elem_id="keywords-papers")
+    #             after = gr.Slider(minimum=1950,maximum=2023,step=1,value=1960,label="Publication date",show_label=True,interactive=True,elem_id="date-papers")
+    #             search_papers = gr.Button("Search",elem_id="search-papers",interactive=True)
 
-            with gr.Column(scale=7):
+    #         with gr.Column(scale=7):
 
-                with gr.Tab("Summary",elem_id="papers-summary-tab"):
-                    papers_summary = gr.Markdown(visible=True,elem_id="papers-summary")
+    #             with gr.Tab("Summary",elem_id="papers-summary-tab"):
+    #                 papers_summary = gr.Markdown(visible=True,elem_id="papers-summary")
 
-                with gr.Tab("Relevant papers",elem_id="papers-results-tab"):
-                    papers_dataframe = gr.Dataframe(visible=True,elem_id="papers-table",headers = papers_cols)
+    #             with gr.Tab("Relevant papers",elem_id="papers-results-tab"):
+    #                 papers_dataframe = gr.Dataframe(visible=True,elem_id="papers-table",headers = papers_cols)
 
-                with gr.Tab("Citations network",elem_id="papers-network-tab"):
-                    citations_network = gr.HTML(visible=True,elem_id="papers-citations-network")
+    #             with gr.Tab("Citations network",elem_id="papers-network-tab"):
+    #                 citations_network = gr.HTML(visible=True,elem_id="papers-citations-network")
 
 
             
@@ -609,13 +537,13 @@ with gr.Blocks(title="Climate Q&A", css="style.css", theme=theme,elem_id = "main
 
     (textbox
         .submit(start_chat, [textbox,chatbot], [textbox,tabs,chatbot],queue = False,api_name = "start_chat_textbox")
-        .then(chat, [textbox,chatbot,dropdown_audience, dropdown_sources,dropdown_reports], [chatbot,sources_textbox,output_query,output_language,gallery_component,query_papers,keywords_papers],concurrency_limit = 8,api_name = "chat_textbox")
+        .then(chat, [textbox,chatbot,dropdown_audience, dropdown_sources,dropdown_reports], [chatbot,sources_textbox,output_query,output_language,gallery_component],concurrency_limit = 8,api_name = "chat_textbox")
         .then(finish_chat, None, [textbox],api_name = "finish_chat_textbox")
     )
 
     (examples_hidden
         .change(start_chat, [examples_hidden,chatbot], [textbox,tabs,chatbot],queue = False,api_name = "start_chat_examples")
-        .then(chat, [examples_hidden,chatbot,dropdown_audience, dropdown_sources,dropdown_reports], [chatbot,sources_textbox,output_query,output_language,gallery_component,query_papers,keywords_papers],concurrency_limit = 8,api_name = "chat_examples")
+        .then(chat, [examples_hidden,chatbot,dropdown_audience, dropdown_sources,dropdown_reports], [chatbot,sources_textbox,output_query,output_language,gallery_component],concurrency_limit = 8,api_name = "chat_examples")
         .then(finish_chat, None, [textbox],api_name = "finish_chat_examples")
     )
 
@@ -630,47 +558,8 @@ with gr.Blocks(title="Climate Q&A", css="style.css", theme=theme,elem_id = "main
 
     dropdown_samples.change(change_sample_questions,dropdown_samples,samples)
 
-    query_papers.submit(generate_keywords,[query_papers], [keywords_papers])
-    search_papers.click(find_papers,[query_papers,keywords_papers,after], [papers_dataframe,citations_network,papers_summary])
-
-    # # textbox.submit(predict_climateqa,[textbox,bot],[None,bot,sources_textbox])
-    # (textbox
-    #     .submit(answer_user, [textbox,examples_hidden, bot], [textbox, bot],queue = False)
-    #     .success(change_tab,None,tabs)
-    #     .success(fetch_sources,[textbox,dropdown_sources], [textbox,sources_textbox,docs_textbox,output_query,output_language])
-    #     .success(answer_bot, [textbox,bot,docs_textbox,output_query,output_language,dropdown_audience], [textbox,bot],queue = True)
-    #     .success(lambda x : textbox,[textbox],[textbox])
-    # )
-
-    # (examples_hidden
-    #     .change(answer_user_example, [textbox,examples_hidden, bot], [textbox, bot],queue = False)
-    #     .success(change_tab,None,tabs)
-    #     .success(fetch_sources,[textbox,dropdown_sources], [textbox,sources_textbox,docs_textbox,output_query,output_language])
-    #     .success(answer_bot, [textbox,bot,docs_textbox,output_query,output_language,dropdown_audience], [textbox,bot],queue=True)
-    #     .success(lambda x : textbox,[textbox],[textbox])
-    # )
-    # submit_button.click(answer_user, [textbox, bot], [textbox, bot], queue=True).then(
-    #         answer_bot, [textbox,bot,dropdown_audience,dropdown_sources], [textbox,bot,sources_textbox]
-    #     )
-
-
-    # with Modal(visible=True) as first_modal:
-    #     gr.Markdown("# Welcome to ClimateQ&A !")
-
-    #     gr.Markdown("### Examples")
-
-    #     examples = gr.Examples(
-    #         ["Yo ça roule","ça boume"],
-    #         [examples_hidden],
-    #         examples_per_page=8,
-    #         run_on_click=False,
-    #         elem_id="examples",
-    #         api_name="examples",
-    #     )
-
-
-    # submit.click(lambda: Modal(visible=True), None, config_modal)
-    
+    # query_papers.submit(generate_keywords,[query_papers], [keywords_papers])
+    # search_papers.click(find_papers,[query_papers,keywords_papers,after], [papers_dataframe,citations_network,papers_summary])
 
     demo.queue()
 

climateqa/engine/chains/answer_rag.py

@@ -2,15 +2,11 @@ from operator import itemgetter
 
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.output_parsers import StrOutputParser
-from langchain_core.runnables import RunnablePassthrough, RunnableLambda, RunnableBranch
 from langchain_core.prompts.prompt import PromptTemplate
 from langchain_core.prompts.base import format_document
 
-from climateqa.engine.chains.reformulation import make_reformulation_chain
-from climateqa.engine.prompts import answer_prompt_template,answer_prompt_without_docs_template,answer_prompt_images_template
-from climateqa.engine.prompts import papers_prompt_template
-from climateqa.engine.utils import pass_values, flatten_dict,prepare_chain,rename_chain
-from climateqa.engine.keywords import make_keywords_chain
+from climateqa.engine.chains.prompts import answer_prompt_template,answer_prompt_without_docs_template,answer_prompt_images_template
+from climateqa.engine.chains.prompts import papers_prompt_template
 
 DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template="{page_content}")
 
@@ -40,105 +36,64 @@ def get_text_docs(x):
 def get_image_docs(x):
     return [doc for doc in x if doc.metadata["chunk_type"] == "image"]
 
-
-def make_rag_chain(retriever,llm):
-
-    # Construct the prompt
+def make_rag_chain(llm):
     prompt = ChatPromptTemplate.from_template(answer_prompt_template)
-    prompt_without_docs = ChatPromptTemplate.from_template(answer_prompt_without_docs_template)
-
-    # ------- CHAIN 0 - Reformulation
-    reformulation = make_reformulation_chain(llm)
-    reformulation = prepare_chain(reformulation,"reformulation")
-
-    # ------- Find all keywords from the reformulated query
-    keywords = make_keywords_chain(llm)
-    keywords = {"keywords":itemgetter("question") | keywords}
-    keywords = prepare_chain(keywords,"keywords")
-
-    # ------- CHAIN 1
-    # Retrieved documents
-    find_documents = {"docs": itemgetter("question") | retriever} | RunnablePassthrough()
-    find_documents = prepare_chain(find_documents,"find_documents")
-
-    # ------- CHAIN 2
-    # Construct inputs for the llm
-    input_documents = {
-        "context":lambda x : _combine_documents(x["docs"]),
-        **pass_values(["question","audience","language","keywords"])
-    }
-
-    # ------- CHAIN 3
-    # Bot answer
-    llm_final = rename_chain(llm,"answer")
-
-    answer_with_docs = {
-        "answer": input_documents | prompt | llm_final | StrOutputParser(),
-        **pass_values(["question","audience","language","query","docs","keywords"]),
-    }
-
-    answer_without_docs = {
-        "answer":  prompt_without_docs | llm_final | StrOutputParser(),
-        **pass_values(["question","audience","language","query","docs","keywords"]),
-    }
-
-    # def has_images(x):
-    #     image_docs = [doc for doc in x["docs"] if doc.metadata["chunk_type"]=="image"]
-    #     return len(image_docs) > 0
-    
-    def has_docs(x):
-        return len(x["docs"]) > 0
+    chain = ({
+        "context":lambda x : _combine_documents(x["documents"]),
+        "query":itemgetter("query"),
+        "language":itemgetter("language"),
+        "audience":itemgetter("audience"),
+    } | prompt | llm | StrOutputParser())
+    return chain
 
-    answer = RunnableBranch(
-        (lambda x: has_docs(x), answer_with_docs),
-        answer_without_docs,
-    )
+def make_rag_chain_without_docs(llm):
+    prompt = ChatPromptTemplate.from_template(answer_prompt_without_docs_template)
+    chain = prompt | llm | StrOutputParser()
+    return chain
 
 
-    # ------- FINAL CHAIN
-    # Build the final chain
-    rag_chain = reformulation | keywords | find_documents | answer
+def make_rag_node(llm,with_docs = True):
 
-    return rag_chain
+    if with_docs:
+        rag_chain = make_rag_chain(llm)
+    else:
+        rag_chain = make_rag_chain_without_docs(llm)
 
+    async def answer_rag(state,config):
+        answer = await rag_chain.ainvoke(state,config)
+        return {"answer":answer}
 
-def make_rag_papers_chain(llm):
+    return answer_rag
 
-    prompt = ChatPromptTemplate.from_template(papers_prompt_template)
 
-    input_documents = {
-        "context":lambda x : _combine_documents(x["docs"]),
-        **pass_values(["question","language"])
-    }
 
-    chain = input_documents | prompt | llm | StrOutputParser()
-    chain = rename_chain(chain,"answer")
 
-    return chain
+# def make_rag_papers_chain(llm):
 
+#     prompt = ChatPromptTemplate.from_template(papers_prompt_template)
+#     input_documents = {
+#         "context":lambda x : _combine_documents(x["docs"]),
+#         **pass_values(["question","language"])
+#     }
 
+#     chain = input_documents | prompt | llm | StrOutputParser()
+#     chain = rename_chain(chain,"answer")
 
+#     return chain
 
 
 
-def make_illustration_chain(llm):
 
-    prompt_with_images = ChatPromptTemplate.from_template(answer_prompt_images_template)
 
-    input_description_images = {
-        "images":lambda x : _combine_documents(get_image_docs(x["docs"])),
-        **pass_values(["question","audience","language","answer"]),
-    }
 
-    illustration_chain = input_description_images | prompt_with_images | llm | StrOutputParser()
-    return illustration_chain
+# def make_illustration_chain(llm):
 
+#     prompt_with_images = ChatPromptTemplate.from_template(answer_prompt_images_template)
 
-def make_answer_rag_node(llm):
+#     input_description_images = {
+#         "images":lambda x : _combine_documents(get_image_docs(x["docs"])),
+#         **pass_values(["question","audience","language","answer"]),
+#     }
 
-                    
-    def answer_rag(state):
-        answer = "\n".join([x["question"] for x in state["questions"]])
-        return {"answer":answer}
-    
-    return answer_rag
+#     illustration_chain = input_description_images | prompt_with_images | llm | StrOutputParser()
+#     return illustration_chain

climateqa/engine/chains/{intent_routing.py → intent_categorization.py}

@@ -7,7 +7,7 @@ from langchain_core.utils.function_calling import convert_to_openai_function
 from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
 
 
-class IntentRouter(BaseModel):
+class IntentCategorizer(BaseModel):
     """Analyzing the user message input"""
     
     language: str = Field(
@@ -37,31 +37,31 @@ class IntentRouter(BaseModel):
 
 
 
-def make_intent_router_chain(llm):
+def make_intent_categorization_chain(llm):
 
-    openai_functions = [convert_to_openai_function(IntentRouter)]
-    llm_with_router = llm.bind(functions = openai_functions,function_call={"name":"IntentRouter"})
+    openai_functions = [convert_to_openai_function(IntentCategorizer)]
+    llm_with_functions = llm.bind(functions = openai_functions,function_call={"name":"IntentCategorizer"})
 
     prompt = ChatPromptTemplate.from_messages([
         ("system", "You are a helpful assistant, you will analyze, translate and reformulate the user input message using the function provided"),
         ("user", "input: {input}")
     ])
 
-    chain = prompt | llm_with_router | JsonOutputFunctionsParser()
+    chain = prompt | llm_with_functions | JsonOutputFunctionsParser()
     return chain
 
 
-def make_intent_router_node(llm):
+def make_intent_categorization_node(llm):
 
-    router_chain = make_intent_router_chain(llm)
+    categorization_chain = make_intent_categorization_chain(llm)
 
-    def route_input_message(state):
-        output = router_chain.invoke({"input":state["user_input"]})
+    def categorize_message(state):
+        output = categorization_chain.invoke({"input":state["user_input"]})
         if "language" not in output: output["language"] = "English"
         output["query"] = state["user_input"]
         return output
     
-    return route_input_message
+    return categorize_message
 
 
 

climateqa/engine/chains/prompts.py

@@ -56,7 +56,7 @@ Passages:
 {context}
 
 -----------------------
-Question: {question} - Explained to {audience}
+Question: {query} - Explained to {audience}
 Answer in {language} with the passages citations:
 """
 
@@ -137,7 +137,7 @@ Guidelines:
 - If the question is not related to environmental issues, never never answer it. Say it's not your role.
 - Make paragraphs by starting new lines to make your answers more readable. 
 
-Question: {question}
+Question: {query}
 Answer in {language}:
 """
 

climateqa/engine/chains/retriever.py

@@ -45,7 +45,7 @@ def suppress_output():
 
 
 
-def make_retriever_node(vectorstore,reranker):
+def make_retriever_node(vectorstore,reranker,rerank_by_question=True, k_final=15, k_before_reranking=100, k_summary=5):
 
     def retrieve_documents(state):
         
@@ -53,15 +53,12 @@ def make_retriever_node(vectorstore,reranker):
         questions = state["questions"]
         
         # Use sources from the user input or from the LLM detection
-        sources_input = state["sources_input"] if "sources_input" in state else ["auto"]
+        if "sources_input" not in state or state["sources_input"] is None:
+            sources_input = ["auto"]
+        else:
+            sources_input = state["sources_input"]
         auto_mode = "auto" in sources_input
-        
-        # Constants
-        k_final = 15
-        k_before_reranking = 100
-        k_summary = 5
-        rerank_by_question = True
-        
+
         # There are several options to get the final top k
         # Option 1 - Get 100 documents by question and rerank by question
         # Option 2 - Get 100/n documents by question and rerank the total
@@ -96,9 +93,14 @@ def make_retriever_node(vectorstore,reranker):
             docs_question = retriever.get_relevant_documents(question)
             
             # Rerank
-            with suppress_output():
-                docs_question = rerank_docs(reranker,docs_question,question)
-            
+            if reranker is not None:
+                with suppress_output():
+                    docs_question = rerank_docs(reranker,docs_question,question)
+            else:
+                # Add a default reranking score
+                for doc in docs_question:
+                    doc.metadata["reranking_score"] = doc.metadata["similarity_score"]
+                
             # If rerank by question we select the top documents for each question
             if rerank_by_question:
                 docs_question = docs_question[:k_by_question[i]]
@@ -112,7 +114,7 @@ def make_retriever_node(vectorstore,reranker):
             
         # Sorting the list in descending order by rerank_score
         # Then select the top k
-        docs = sorted(docs, key=lambda x: x.metadata["rerank_score"], reverse=True)
+        docs = sorted(docs, key=lambda x: x.metadata["reranking_score"], reverse=True)
         docs = docs[:k_final]
         
         new_state = {"documents":docs}

climateqa/engine/graph.py

@@ -4,14 +4,20 @@ from contextlib import contextmanager
 
 from langchain.schema import Document
 from langgraph.graph import END, StateGraph
+from langchain_core.runnables.graph import CurveStyle, NodeColors, MermaidDrawMethod
+
 from typing_extensions import TypedDict
 from typing import List
 
+from IPython.display import display, HTML, Image
+
 from .chains.answer_chitchat import make_chitchat_node
 from .chains.answer_ai_impact import make_ai_impact_node
-from .chains.query_transform import make_query_transform_node
+from .chains.query_transformation import make_query_transform_node
 from .chains.translation import make_translation_node
-from .chains.intent_routing import make_intent_router_node
+from .chains.intent_categorization import make_intent_categorization_node
+from .chains.retriever import make_retriever_node
+from .chains.answer_rag import make_rag_node
 
 
 class GraphState(TypedDict):
@@ -24,9 +30,109 @@ class GraphState(TypedDict):
     query: str
     questions : List[dict]
     answer: str
-    audience: str
-    sources_input: str
+    audience: str = "experts"
+    sources_input: List[str] = ["auto"]
     documents: List[Document]
 
 def search(state):
-    return {}
+    return {}
+
+def route_intent(state):
+    intent = state["intent"]
+    if intent in ["chitchat","esg"]:
+        return "answer_chitchat"
+    elif intent == "ai_impact":
+        return "answer_ai_impact"
+    else:
+        # Search route
+        return "search"
+    
+def route_translation(state):
+    if state["language"].lower() == "english":
+        return "transform_query"
+    else:
+        return "translate_query"
+    
+def route_based_on_relevant_docs(state,threshold_docs=0.2):
+    docs = [x for x in state["documents"] if x.metadata["reranking_score"] > threshold_docs]
+    if len(docs) > 0:
+        return "answer_rag"
+    else:
+        return "answer_rag_no_docs"
+    
+
+def make_id_dict(values):
+    return {k:k for k in values}
+
+def make_graph_agent(llm,vectorstore,reranker,threshold_docs = 0.2):
+    
+    workflow = StateGraph(GraphState)
+
+    # Define the node functions
+    categorize_intent = make_intent_categorization_node(llm)
+    transform_query = make_query_transform_node(llm)
+    translate_query = make_translation_node(llm)
+    answer_chitchat = make_chitchat_node(llm)
+    answer_ai_impact = make_ai_impact_node(llm)
+    retrieve_documents = make_retriever_node(vectorstore,reranker)
+    answer_rag = make_rag_node(llm,with_docs=True)
+    answer_rag_no_docs = make_rag_node(llm,with_docs=False)
+
+    # Define the nodes
+    workflow.add_node("categorize_intent", categorize_intent)
+    workflow.add_node("search", search)
+    workflow.add_node("transform_query", transform_query)
+    workflow.add_node("translate_query", translate_query)
+    workflow.add_node("answer_chitchat", answer_chitchat)
+    workflow.add_node("answer_ai_impact", answer_ai_impact)
+    workflow.add_node("retrieve_documents",retrieve_documents)
+    workflow.add_node("answer_rag",answer_rag)
+    workflow.add_node("answer_rag_no_docs",answer_rag_no_docs)
+
+    # Entry point
+    workflow.set_entry_point("categorize_intent")
+
+    # CONDITIONAL EDGES
+    workflow.add_conditional_edges(
+        "categorize_intent",
+        route_intent,
+        make_id_dict(["answer_chitchat","answer_ai_impact","search"])
+    )
+
+    workflow.add_conditional_edges(
+        "search",
+        route_translation,
+        make_id_dict(["translate_query","transform_query"])
+    )
+
+    workflow.add_conditional_edges(
+        "retrieve_documents",
+        lambda x : route_based_on_relevant_docs(x,threshold_docs=threshold_docs),
+        make_id_dict(["answer_rag","answer_rag_no_docs"])
+    )
+
+    # Define the edges
+    workflow.add_edge("translate_query", "transform_query")
+    workflow.add_edge("transform_query", "retrieve_documents")
+    workflow.add_edge("retrieve_documents", "answer_rag")
+    workflow.add_edge("answer_rag", END)
+    workflow.add_edge("answer_rag_no_docs", END)
+    workflow.add_edge("answer_chitchat", END)
+    workflow.add_edge("answer_ai_impact", END)
+
+    # Compile
+    app = workflow.compile()
+    return app
+
+
+
+
+def display_graph(app):
+
+    display(
+        Image(
+            app.get_graph(xray = True).draw_mermaid_png(
+                draw_method=MermaidDrawMethod.API,
+            )
+        )
+    )

climateqa/engine/reranker.py

@@ -34,7 +34,7 @@ def rerank_docs(reranker,docs,query):
     for result in results.results:
         doc_id = result.document.doc_id
         doc = docs[doc_id]
-        doc.metadata["rerank_score"] = result.score
+        doc.metadata["reranking_score"] = result.score
         doc.metadata["query_used_for_retrieval"] = query
         docs_reranked.append(doc)
     return docs_reranked

front/utils.py

@@ -0,0 +1,142 @@
+
+import re
+
+def make_pairs(lst):
+    """from a list of even lenght, make tupple pairs"""
+    return [(lst[i], lst[i + 1]) for i in range(0, len(lst), 2)]
+
+
+def serialize_docs(docs):
+    new_docs = []
+    for doc in docs:
+        new_doc = {}
+        new_doc["page_content"] = doc.page_content
+        new_doc["metadata"] = doc.metadata
+        new_docs.append(new_doc)
+    return new_docs
+
+
+
+def parse_output_llm_with_sources(output):
+    # Split the content into a list of text and "[Doc X]" references
+    content_parts = re.split(r'\[(Doc\s?\d+(?:,\s?Doc\s?\d+)*)\]', output)
+    parts = []
+    for part in content_parts:
+        if part.startswith("Doc"):
+            subparts = part.split(",")
+            subparts = [subpart.lower().replace("doc","").strip() for subpart in subparts]
+            subparts = [f"""<a href="#doc{subpart}" class="a-doc-ref" target="_self"><span class='doc-ref'><sup>{subpart}</sup></span></a>""" for subpart in subparts]
+            parts.append("".join(subparts))
+        else:
+            parts.append(part)
+    content_parts = "".join(parts)
+    return content_parts
+
+
+def make_html_source(source,i):
+    meta = source.metadata
+    # content = source.page_content.split(":",1)[1].strip()
+    content = source.page_content.strip()
+
+    toc_levels = []
+    for j in range(2):
+        level = meta[f"toc_level{j}"]
+        if level != "N/A":
+            toc_levels.append(level)
+        else:
+            break
+    toc_levels = " > ".join(toc_levels)
+
+    if len(toc_levels) > 0:
+        name = f"<b>{toc_levels}</b><br/>{meta['name']}"
+    else:
+        name = meta['name']
+
+    score = meta['reranking_score']
+    if score > 0.8:
+        color = "score-green"
+    elif score > 0.4:
+        color = "score-orange"
+    else:
+        color = "score-red"
+
+    relevancy_score = f"<p class=relevancy-score>Relevancy score: <span class='{color}'>{score:.1%}</span></p>"
+
+    if meta["chunk_type"] == "text":
+
+        card = f"""
+    <div class="card" id="doc{i}">
+        <div class="card-content">
+            <h2>Doc {i} - {meta['short_name']} - Page {int(meta['page_number'])}</h2>
+            <p>{content}</p>
+            {relevancy_score}
+        </div>
+        <div class="card-footer">
+            <span>{name}</span>
+            <a href="{meta['url']}#page={int(meta['page_number'])}" target="_blank" class="pdf-link">
+                <span role="img" aria-label="Open PDF">🔗</span>
+            </a>
+        </div>
+    </div>
+    """
+    
+    else:
+
+        if meta["figure_code"] != "N/A":
+            title = f"{meta['figure_code']} - {meta['short_name']}"
+        else:
+            title = f"{meta['short_name']}"
+
+        card = f"""
+    <div class="card card-image">
+        <div class="card-content">
+            <h2>Image {i} - {title} - Page {int(meta['page_number'])}</h2>
+            <p>{content}</p>
+            <p class='ai-generated'>AI-generated description</p>
+            {relevancy_score}
+        </div>
+        <div class="card-footer">
+            <span>{name}</span>
+            <a href="{meta['url']}#page={int(meta['page_number'])}" target="_blank" class="pdf-link">
+                <span role="img" aria-label="Open PDF">🔗</span>
+            </a>
+        </div>
+    </div>
+    """
+        
+    return card
+
+
+
+def make_toolbox(tool_name,description = "",checked = False,elem_id = "toggle"):
+
+    if checked:
+        span = "<span class='checkmark'>&#10003;</span>"
+    else:
+        span = "<span class='loader'></span>"
+
+#     toolbox = f"""
+# <div class="dropdown">
+# <label for="{elem_id}" class="dropdown-toggle">
+#     {span}
+#     {tool_name}
+#     <span class="caret"></span>
+# </label>
+# <input type="checkbox" id="{elem_id}" hidden/>
+# <div class="dropdown-content">
+#     <p>{description}</p>
+# </div>
+# </div>
+# """
+    
+
+    toolbox = f"""
+<div class="dropdown">
+<label for="{elem_id}" class="dropdown-toggle">
+    {span}
+    {tool_name}
+</label>
+</div>
+"""
+
+    return toolbox

requirements.txt

@@ -2,13 +2,16 @@ gradio==4.19.1
 azure-storage-file-share==12.11.1
 azure-storage-blob
 python-dotenv==1.0.0
-langchain==0.1.4
-langchain_openai==0.0.6
-pinecone-client==3.0.2
+langchain==0.2.1
+langchain_openai==0.1.7
+langgraph==0.0.55
+pinecone-client==4.1.0
 sentence-transformers==2.6.0
 huggingface-hub
-msal
 pyalex==0.13
 networkx==3.2.1
 pyvis==0.3.2
 flashrank==0.2.5
+rerankers==0.3.0
+torch==2.3.0
+nvidia-cudnn-cu12==8.9.2.26

style.css

@@ -363,3 +363,105 @@ span.chatbot > p > img{
 .a-doc-ref{
 	text-decoration: none !important;
 }
+
+
+.dropdown {
+    position: relative;
+    display:inline-block;
+    margin-bottom: 10px;
+  }
+  
+  .dropdown-toggle {
+    background-color: #f2f2f2;
+    color: black;
+    padding: 10px;
+    font-size: 16px;
+    cursor: pointer;
+    display: block;
+    width: 400px; /* Adjust width as needed */
+    position: relative;
+    display: flex;
+    align-items: center; /* Vertically center the contents */
+    justify-content: left;
+  }
+  
+  .dropdown-toggle .caret {
+    content: "";
+    position: absolute;
+    right: 10px;
+    top: 50%;
+    border-left: 5px solid transparent;
+    border-right: 5px solid transparent;
+    border-top: 5px solid black;
+    transform: translateY(-50%);
+  }
+  
+  input[type="checkbox"] {
+    display: none !important;
+  }
+  
+  input[type="checkbox"]:checked + .dropdown-content {
+    display: block;
+  }
+  
+  .dropdown-content {
+    display: none;
+    position: absolute;
+    background-color: #f9f9f9;
+    min-width: 300px;
+    box-shadow: 0 8px 16px 0 rgba(0,0,0,0.2);
+    z-index: 1;
+    padding: 12px;
+    border: 1px solid #ccc;
+  }
+  
+  input[type="checkbox"]:checked + .dropdown-toggle + .dropdown-content {
+    display: block;
+  }
+  
+  input[type="checkbox"]:checked + .dropdown-toggle .caret {
+    border-top: 0;
+    border-bottom: 5px solid black;
+  }
+  
+  .loader {
+    border: 1px solid #d0d0d0 !important; /* Light grey background */
+    border-top: 1px solid #3498db !important; /* Blue color */
+    border-right: 1px solid #3498db !important; /* Blue color */
+    border-radius: 50%;
+    width: 20px;
+    height: 20px;
+    animation: spin 2s linear infinite;
+    display:inline-block;
+    margin-right:10px !important;
+  }
+  
+  .checkmark{
+    color:green !important;
+    font-size:18px;
+    margin-right:10px !important;
+  }
+  
+  @keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+  }
+
+
+  .relevancy-score{
+    margin-top:10px !important;
+    font-size:10px !important;
+    font-style:italic;
+  }
+  
+  .score-green{
+    color:green !important;
+  }
+  
+  .score-orange{
+    color:orange !important;
+  }
+  
+  .score-orange{
+    color:red !important;
+  }