retrieve by ToC

.gitignore

@@ -12,4 +12,9 @@ notebooks/
 data/
 sandbox/
 
-*.db
+climateqa/talk_to_data/database/
+*.db
+
+data_ingestion/
+.vscode
+*old/

app.py

@@ -12,9 +12,11 @@ from climateqa.engine.reranker import get_reranker
 from climateqa.engine.graph import make_graph_agent,make_graph_agent_poc
 from climateqa.engine.chains.retrieve_papers import find_papers
 from climateqa.chat import start_chat, chat_stream, finish_chat
+from climateqa.engine.talk_to_data.main import ask_vanna
 
 from front.tabs import (create_config_modal, create_examples_tab, create_papers_tab, create_figures_tab, create_chat_interface, create_about_tab)
 from front.utils import process_figures
+from gradio_modal import Modal
 
 
 from utils import create_user_id
@@ -67,7 +69,10 @@ vectorstore_graphs = get_pinecone_vectorstore(embeddings_function, index_name=os
 vectorstore_region = get_pinecone_vectorstore(embeddings_function, index_name=os.getenv("PINECONE_API_INDEX_REGION"))
 
 llm = get_llm(provider="openai",max_tokens = 1024,temperature = 0.0)
-reranker = get_reranker("nano")
+if os.environ["GRADIO_ENV"] == "local":
+    reranker = get_reranker("nano")
+else :
+    reranker = get_reranker("large")
 
 agent = make_graph_agent(llm=llm, vectorstore_ipcc=vectorstore, vectorstore_graphs=vectorstore_graphs, vectorstore_region = vectorstore_region, reranker=reranker, threshold_docs=0.2)
 agent_poc = make_graph_agent_poc(llm=llm, vectorstore_ipcc=vectorstore, vectorstore_graphs=vectorstore_graphs, vectorstore_region = vectorstore_region, reranker=reranker, threshold_docs=0)#TODO put back default 0.2
@@ -91,7 +96,7 @@ async def chat_poc(query, history, audience, sources, reports, relevant_content_
 # Function to update modal visibility
 def update_config_modal_visibility(config_open):
     new_config_visibility_status = not config_open
-    return gr.update(visible=new_config_visibility_status), new_config_visibility_status
+    return Modal(visible=new_config_visibility_status), new_config_visibility_status
     
 
 def update_sources_number_display(sources_textbox, figures_cards, current_graphs, papers_html):
@@ -116,7 +121,7 @@ def cqa_tab(tab_name):
         with gr.Row(elem_id="chatbot-row"):
             # Left column - Chat interface
             with gr.Column(scale=2):
-                chatbot, textbox, config_button = create_chat_interface()
+                chatbot, textbox, config_button = create_chat_interface(tab_name)
 
             # Right column - Content panels
             with gr.Column(scale=2, variant="panel", elem_id="right-panel"):
@@ -139,7 +144,7 @@ def cqa_tab(tab_name):
 
                             # Papers subtab
                             with gr.Tab("Papers", elem_id="tab-citations", id=4) as tab_papers:
-                                papers_summary, papers_html, citations_network, papers_modal = create_papers_tab()
+                                papers_direct_search, papers_summary, papers_html, citations_network, papers_modal = create_papers_tab()
 
                             # Graphs subtab
                             with gr.Tab("Graphs", elem_id="tab-graphs", id=5) as tab_graphs:
@@ -147,6 +152,20 @@ def cqa_tab(tab_name):
                                     "<h2>There are no graphs to be displayed at the moment. Try asking another question.</h2>",
                                     elem_id="graphs-container"
                                 )
+                            with gr.Tab("DRIAS", elem_id="tab-vanna", id=6) as tab_vanna:
+                                vanna_direct_question = gr.Textbox(label="Direct Question", placeholder="You can write direct question here",elem_id="direct-question", interactive=True)
+                                with gr.Accordion("Details",elem_id = 'vanna-details', open=False) as vanna_details :
+                                    vanna_sql_query = gr.Textbox(label="SQL Query Used", elem_id="sql-query", interactive=False)
+                                    show_vanna_table = gr.Button("Show Table", elem_id="show-table")
+                                    with Modal(visible=False) as vanna_table_modal:
+                                        vanna_table = gr.DataFrame([], elem_id="vanna-table")
+                                        close_vanna_modal = gr.Button("Close", elem_id="close-vanna-modal")
+                                        close_vanna_modal.click(lambda: Modal(visible=False),None, [vanna_table_modal])
+                                    show_vanna_table.click(lambda: Modal(visible=True),None ,[vanna_table_modal])
+
+                                vanna_display = gr.Plot()
+                                vanna_direct_question.submit(ask_vanna, [vanna_direct_question], [vanna_sql_query ,vanna_table, vanna_display])
+                                
     return {
         "chatbot": chatbot,
         "textbox": textbox,
@@ -159,6 +178,7 @@ def cqa_tab(tab_name):
         "figures_cards": figures_cards,
         "gallery_component": gallery_component,
         "config_button": config_button,
+        "papers_direct_search" : papers_direct_search,
         "papers_html": papers_html,
         "citations_network": citations_network,
         "papers_summary": papers_summary,
@@ -167,7 +187,10 @@ def cqa_tab(tab_name):
         "tab_figures": tab_figures,
         "tab_graphs": tab_graphs,
         "tab_papers": tab_papers,
-        "graph_container": graphs_container
+        "graph_container": graphs_container,
+        "vanna_sql_query": vanna_sql_query,
+        "vanna_table" : vanna_table,
+        "vanna_display": vanna_display
     }
                                 
  
@@ -188,6 +211,7 @@ def event_handling(
     figures_cards = main_tab_components["figures_cards"]
     gallery_component = main_tab_components["gallery_component"]
     config_button = main_tab_components["config_button"]
+    papers_direct_search = main_tab_components["papers_direct_search"]
     papers_html = main_tab_components["papers_html"]
     citations_network = main_tab_components["citations_network"]
     papers_summary = main_tab_components["papers_summary"]
@@ -197,6 +221,10 @@ def event_handling(
     tab_graphs = main_tab_components["tab_graphs"]
     tab_papers = main_tab_components["tab_papers"]
     graphs_container = main_tab_components["graph_container"]
+    vanna_sql_query = main_tab_components["vanna_sql_query"]
+    vanna_table = main_tab_components["vanna_table"]
+    vanna_display = main_tab_components["vanna_display"]
+    
     
     config_open = config_components["config_open"]
     config_modal = config_components["config_modal"]
@@ -211,8 +239,8 @@ def event_handling(
     close_config_modal = config_components["close_config_modal_button"]
     
     new_sources_hmtl = gr.State([])
-    
-    print("textbox id : ", textbox.elem_id)
+    ttd_data = gr.State([])
+
      
     for button in [config_button, close_config_modal]:
         button.click(
@@ -262,11 +290,14 @@ def event_handling(
         component.change(update_sources_number_display, [sources_textbox, figures_cards, current_graphs, papers_html], [tab_recommended_content, tab_sources, tab_figures, tab_graphs, tab_papers])
     
     # Search for papers
-    for component in [textbox, examples_hidden]:
+    for component in [textbox, examples_hidden, papers_direct_search]:
         component.submit(find_papers, [component, after, dropdown_external_sources], [papers_html, citations_network, papers_summary])
-        
+    
         
 
+    if tab_name == "Beta - POC Adapt'Action":
+        # Drias search
+        textbox.submit(ask_vanna, [textbox], [vanna_sql_query ,vanna_table, vanna_display])
 
 def main_ui():
     # config_open = gr.State(True)
@@ -280,7 +311,7 @@ def main_ui():
             create_about_tab()
         
         event_handling(cqa_components, config_components, tab_name = 'ClimateQ&A')
-        event_handling(local_cqa_components, config_components, tab_name = 'Beta - POC Adapt\'Action')
+        event_handling(local_cqa_components, config_components, tab_name = "Beta - POC Adapt'Action")
         
         demo.queue()
         

climateqa/chat.py

@@ -53,6 +53,13 @@ def log_interaction_to_azure(history, output_query, sources, docs, share_client,
         print(f"Error logging on Azure Blob Storage: {e}")
         error_msg = f"ClimateQ&A Error: {str(e)[:100]} - The error has been noted, try another question and if the error remains, you can contact us :)"
         raise gr.Error(error_msg)
+
+def handle_numerical_data(event):
+    if event["name"] == "retrieve_drias_data" and event["event"] == "on_chain_end":
+        numerical_data = event["data"]["output"]["drias_data"]
+        sql_query = event["data"]["output"]["drias_sql_query"]
+        return numerical_data, sql_query
+    return None, None
     
 # Main chat function
 async def chat_stream(
@@ -121,6 +128,7 @@ async def chat_stream(
     used_documents = []
     retrieved_contents = []
     answer_message_content = ""
+    vanna_data = {}
 
     # Define processing steps
     steps_display = {
@@ -142,6 +150,14 @@ async def chat_stream(
                     history, used_documents, retrieved_contents = handle_retrieved_documents(
                         event, history, used_documents, retrieved_contents
                     )
+                # Handle Vanna retrieval
+                # if event["event"] == "on_chain_end" and event["name"] in ["retrieve_documents","retrieve_local_data"] and event["data"]["output"] != None:
+                #     df_output_vanna, sql_query = handle_numerical_data(
+                #         event
+                #     )
+                #     vanna_data = {"df_output": df_output_vanna, "sql_query": sql_query}
+                 
+                    
                 if event["event"] == "on_chain_end" and event["name"] == "answer_search" :
                     docs = event["data"]["input"]["documents"]
                     docs_html = convert_to_docs_to_html(docs)                    
@@ -184,7 +200,7 @@ async def chat_stream(
                         sub_questions = [q["question"] + "-> relevant sources : " + str(q["sources"]) for q in event["data"]["output"]["questions_list"]]
                         history[-1].content += "Decompose question into sub-questions:\n\n - " + "\n - ".join(sub_questions)
 
-            yield history, docs_html, output_query, output_language, related_contents, graphs_html 
+            yield history, docs_html, output_query, output_language, related_contents, graphs_html#, vanna_data
 
     except Exception as e:
         print(f"Event {event} has failed")
@@ -195,4 +211,4 @@ async def chat_stream(
     # Call the function to log interaction
     log_interaction_to_azure(history, output_query, sources, docs, share_client, user_id)
 
-    yield history, docs_html, output_query, output_language, related_contents, graphs_html 
+    yield history, docs_html, output_query, output_language, related_contents, graphs_html#, vanna_data

climateqa/engine/chains/drias_retriever.py

@@ -0,0 +1,16 @@
+import sys
+import os
+from climateqa.engine.talk_to_data.main import ask_vanna
+
+
+def make_drias_retriever_node(llm):
+    
+    def retrieve_drias_data(state):
+        print("---- Retrieving data from DRIAS ----")
+        query = state["query"]
+        sql_query, df, fig = ask_vanna(query)
+        state["drias_data"] = df
+        state["drias_sql_query"] = sql_query
+        return state
+    
+    return retrieve_drias_data

climateqa/engine/chains/intent_categorization.py

@@ -29,7 +29,7 @@ class IntentCategorizer(BaseModel):
             Examples:
             - ai_impact = Environmental impacts of AI: "What are the environmental impacts of AI", "How does AI affect the environment"
             - search = Searching for any quesiton about climate change, energy, biodiversity, nature, and everything we can find the IPCC or IPBES reports or scientific papers,
-            - chitchat = Any general question that is not related to the environment or climate change or just conversational, or if you don't think searching the IPCC or IPBES reports would be relevant
+            - chitchat = Any general question that is not related to the environment or climate change or just conversational, or if you don't think searching the IPCC or IPBES reports would be relevant. If it can be interprated as a climate related question, please use the search intent.
         """,
             # - geo_info = Geolocated info about climate change: Any question where the user wants to know localized impacts of climate change, eg: "What will be the temperature in Marseille in 2050"
             # - esg = Any question about the ESG regulation, frameworks and standards like the CSRD, TCFD, SASB, GRI, CDP, etc.
@@ -57,6 +57,7 @@ def make_intent_categorization_node(llm):
     categorization_chain = make_intent_categorization_chain(llm)
 
     def categorize_message(state):
+        print("Input Message : ", state["user_input"])
         print("---- Categorize_message ----")
 
         output = categorization_chain.invoke({"input": state["user_input"]})

climateqa/engine/chains/prompts.py

@@ -66,10 +66,11 @@ You are ClimateQ&A, an AI Assistant created by Ekimetrics. You are given a quest
 Guidelines:
 - If the passages have useful facts or numbers, use them in your answer.
 - When you use information from a passage, mention where it came from by using [Doc i] at the end of the sentence. i stands for the number of the document.
-- You will receive passages from different reports, eg IPCC and PPCP, make separate paragraphs and specify the source of the information in your answer, eg "According to IPCC, ...".
-- The different sources are IPCC, IPBES, PPCP (for Plan Climat Air Energie Territorial de Paris), PBDP (for Plan Biodiversité de Paris), Acclimaterra.
+- You will receive passages from different reports, e.g., IPCC and PPCP. Make separate paragraphs and specify the source of the information in your answer, e.g., "According to IPCC, ...".
+- The different sources are IPCC, IPBES, PPCP (for Plan Climat Air Energie Territorial de Paris), PBDP (for Plan Biodiversité de Paris), Acclimaterra (Rapport scientifique de la région Nouvelle Aquitaine en France).
+- If the reports are local (like PPCP, PBDP, Acclimaterra), consider that the information is specific to the region and not global. If the document is about a nearby region (for example, an extract from Acclimaterra for a question about Britain), explicitly state the concerned region.
 - Do not mention that you are using specific extract documents, but mention only the source information. "According to IPCC, ..." rather than "According to the provided document from IPCC ..."
-- Make a clear distinction between information from IPCC, IPBES, Acclimaterra that are scientific reports and PPCP, PBDP that are strategic reports. Strategic reports should not be taken has verified facts, but as political or strategic decisions.
+- Make a clear distinction between information from IPCC, IPBES, Acclimaterra that are scientific reports and PPCP, PBDP that are strategic reports. Strategic reports should not be taken as verified facts, but as political or strategic decisions.
 - If the same thing is said in more than one document, you can mention all of them like this: [Doc i, Doc j, Doc k]
 - Do not just summarize each passage one by one. Group your summaries to highlight the key parts in the explanation.
 - If it makes sense, use bullet points and lists to make your answers easier to understand.
@@ -197,4 +198,58 @@ Graphs and their HTML embedding:
 {format_instructions}
 
 Output the result as json with a key "graphs" containing a list of dictionaries of the relevant graphs with keys 'embedding', 'category', and 'source'. Do not modify the graph HTML embedding, the category or the source. Do not put any message or text before or after the JSON output.
+"""
+
+retrieve_chapter_prompt_template = """A partir de la question de l'utilisateur et d'une liste de documents avec leurs tables des matières, retrouve les 5 chapitres de niveau 0 les plus pertinents qui pourraient aider à répondre à la question tout en prenant bien en compte leurs sous-chapitres. 
+
+
+La table des matières est structurée de cette façon : 
+{{
+  "level": 0,
+  "Chapitre 1": {{}},
+  "Chapitre 2" : {{
+    "level": 1,
+    "Chapitre 2.1": {{
+      ...
+    }}
+  }},
+}}
+
+Ici level correspond au niveau du chapitre. Ici par exemple Chapitre 1 et Chapitre 2 sont au niveau 0, et Chapitre 2.1 est au niveau 1
+
+-----------------------
+Suis impérativement cette guideline ci-dessous.
+
+### Guidelines ###
+- Retiens bien la liste complète des documents.
+- Chaque chapitre doit conserver **EXACTEMENT** le niveau qui lui est attribué dans la table des matières. **NE MODIFIE PAS LES NIVEAUX.**
+- Vérifie systématiquement le niveau d’un chapitre avant de l’inclure dans la réponse.
+- Retourne un résultat **JSON valide**.
+
+--------------------
+Question de l'utilisateur : 
+{query}
+
+Liste des documents avec leurs tables des matières : 
+{doc_list}
+
+--------------------
+
+Retourne le résultat en JSON contenant une liste des chapitres pertinents avec les clés suivantes sans l'indicateur markdown du json:
+- "document" : le document contenant le chapitre
+- "chapter" : le titre du chapitre
+
+**IMPORTANT : Assure-toi que les niveaux dans la réponse sont exactement ceux de la table des matières.**
+
+Exemple de réponse JSON :
+[
+  {{
+    "document": "Document A",
+    "chapter": "Chapitre 1",
+  }},
+  {{
+    "document": "Document B",
+    "chapter": "Chapitre 1.1",
+  }}
+]
 """

climateqa/engine/chains/query_transformation.py

@@ -293,6 +293,8 @@ def make_query_transform_node(llm,k_final=15):
             "n_questions":n_questions,
             "handled_questions_index":[],            
         }
+        print("New questions")
+        print(new_questions)
         return new_state
     
     return transform_query

climateqa/engine/chains/retrieve_documents.py

@@ -15,6 +15,14 @@ from ..utils import log_event
 from langchain_core.vectorstores import VectorStore
 from typing import List
 from langchain_core.documents.base import Document
+from ..llm import get_llm
+from .prompts import retrieve_chapter_prompt_template
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from ..vectorstore import get_pinecone_vectorstore
+from ..embeddings import get_embeddings_function
+
+
 import asyncio
 
 from typing import Any, Dict, List, Tuple
@@ -232,8 +240,7 @@ async def get_IPCC_relevant_documents(
             "chunk_type":"text",
             "report_type": { "$nin":["SPM"]},
         }
-        k_full = k_total - len(docs_summaries)
-        docs_full = vectorstore.similarity_search_with_score(query=query,filter = filters_full,k = k_full)
+        docs_full = vectorstore.similarity_search_with_score(query=query,filter = filters_full,k = k_total)
         
         if search_figures:
             # Images
@@ -280,6 +287,7 @@ async def retrieve_documents(
     source_type: str, 
     vectorstore: VectorStore,
     reranker: Any,
+    version: str = "",
     search_figures: bool = False,
     search_only: bool = False,
     reports: list = [],
@@ -287,7 +295,9 @@ async def retrieve_documents(
     k_images_by_question: int = 5,
     k_before_reranking: int = 100,
     k_by_question: int = 5,
-    k_summary_by_question: int = 3
+    k_summary_by_question: int = 3,
+    tocs: list = [],
+    by_toc=False
 ) -> Tuple[List[Document], List[Document]]:
     """
     Unpack the first question of the remaining questions, and retrieve and rerank corresponding documents, based on the question and selected_sources 
@@ -317,6 +327,7 @@ async def retrieve_documents(
 
     print(f"""---- Retrieve documents from {current_question["source_type"]}----""")
 
+    
     if source_type == "IPx":
         docs_question_dict = await get_IPCC_relevant_documents(
             query  = question,
@@ -332,19 +343,39 @@ async def retrieve_documents(
             reports = reports,
         )
     
-    if source_type == "POC":
-        docs_question_dict = await get_POC_relevant_documents(
-            query = question,
-            vectorstore=vectorstore,
-            search_figures = search_figures,
-            sources = sources,
-            threshold = 0.5,
-            search_only = search_only,
-            reports = reports,
-            min_size= 200,
-            k_documents= k_before_reranking,
-            k_images= k_by_question
-        )
+    # if source_type == "POC":
+    #     
+    
+    if source_type == 'POC':
+        if by_toc == True:
+            print("---- Retrieve documents by ToC----")
+            docs_question_dict = await get_POC_by_ToC_relevant_documents(
+                query=question,
+                tocs = tocs,
+                vectorstore=vectorstore,
+                version=version,
+                search_figures = search_figures,
+                sources = sources,
+                threshold = 0.5,
+                search_only = search_only,
+                reports = reports,
+                min_size= 200,
+                k_documents= k_before_reranking,
+                k_images= k_by_question
+            )
+        else : 
+            docs_question_dict = await get_POC_relevant_documents(
+                query = question,
+                vectorstore=vectorstore,
+                search_figures = search_figures,
+                sources = sources,
+                threshold = 0.5,
+                search_only = search_only,
+                reports = reports,
+                min_size= 200,
+                k_documents= k_before_reranking,
+                k_images= k_by_question
+            )
 
     # Rerank
     if reranker is not None and rerank_by_question:
@@ -370,24 +401,44 @@ async def retrieve_documents(
     return docs_question, images_question
     
 
-async def retrieve_documents_for_all_questions(state, config, source_type, to_handle_questions_index, vectorstore, reranker, rerank_by_question=True, k_final=15, k_before_reranking=100):
+async def retrieve_documents_for_all_questions(
+    search_figures,
+    search_only,
+    reports,
+    questions_list,
+    n_questions,
+    config, 
+    source_type, 
+    to_handle_questions_index,
+    vectorstore, 
+    reranker, 
+    rerank_by_question=True, 
+    k_final=15, 
+    k_before_reranking=100,
+    version: str = "",
+    tocs: list[dict] = [],
+    by_toc: bool = False
+):
     """
     Retrieve documents in parallel for all questions.
     """
     # to_handle_questions_index = [x for x in state["questions_list"] if x["source_type"] == "IPx"]
     
     # TODO split les questions selon le type de sources dans le state question + conditions sur le nombre de questions traités par type de source 
-    docs = state.get("documents", [])
-    related_content = state.get("related_content", [])
-    search_figures = "Figures (IPCC/IPBES)" in state["relevant_content_sources_selection"]
-    search_only = state["search_only"]
-    reports = state["reports"]
-    
-    k_by_question = k_final // state["n_questions"]["total"]
-    k_summary_by_question = _get_k_summary_by_question(state["n_questions"]["total"])
-    k_images_by_question = _get_k_images_by_question(state["n_questions"]["total"])
+    # search_figures = "Figures (IPCC/IPBES)" in state["relevant_content_sources_selection"]
+    # search_only = state["search_only"]
+    # reports = state["reports"]
+    # questions_list = state["questions_list"]
+    
+    # k_by_question = k_final // state["n_questions"]["total"]
+    # k_summary_by_question = _get_k_summary_by_question(state["n_questions"]["total"])
+    # k_images_by_question = _get_k_images_by_question(state["n_questions"]["total"])
+    k_by_question = k_final // n_questions
+    k_summary_by_question = _get_k_summary_by_question(n_questions)
+    k_images_by_question = _get_k_images_by_question(n_questions)
     k_before_reranking=100
     
+    print(f"Source type here is {source_type}")
     tasks = [
         retrieve_documents(
             current_question=question,
@@ -402,9 +453,12 @@ async def retrieve_documents_for_all_questions(state, config, source_type, to_ha
             k_images_by_question=k_images_by_question,
             k_before_reranking=k_before_reranking,
             k_by_question=k_by_question,
-            k_summary_by_question=k_summary_by_question
+            k_summary_by_question=k_summary_by_question,
+            tocs=tocs,
+            version=version,
+            by_toc=by_toc
         )
-        for i, question in enumerate(state["questions_list"]) if i in to_handle_questions_index
+        for i, question in enumerate(questions_list) if i in to_handle_questions_index
     ]
     results = await asyncio.gather(*tasks)
     # Combine results
@@ -420,10 +474,18 @@ def make_IPx_retriever_node(vectorstore,reranker,llm,rerank_by_question=True, k_
         source_type = "IPx"
         IPx_questions_index = [i for i, x in enumerate(state["questions_list"]) if x["source_type"] == "IPx"]
 
-        # return {"documents":[], "related_contents": [], "handled_questions_index": list(range(len(state["questions_list"])))} # TODO Remove
-
+        search_figures = "Figures (IPCC/IPBES)" in state["relevant_content_sources_selection"]
+        search_only = state["search_only"]
+        reports = state["reports"]
+        questions_list = state["questions_list"]
+        n_questions=state["n_questions"]["total"]
+        
         state = await retrieve_documents_for_all_questions(
-            state=state,
+            search_figures=search_figures,
+            search_only=search_only,
+            reports=reports,
+            questions_list=questions_list,
+            n_questions=n_questions,
             config=config,
             source_type=source_type,
             to_handle_questions_index=IPx_questions_index,
@@ -447,6 +509,171 @@ def make_POC_retriever_node(vectorstore,reranker,llm,rerank_by_question=True, k_
         source_type = "POC"
         POC_questions_index = [i for i, x in enumerate(state["questions_list"]) if x["source_type"] == "POC"]
         
+        search_figures = "Figures (IPCC/IPBES)" in state["relevant_content_sources_selection"]
+        search_only = state["search_only"]
+        reports = state["reports"]
+        questions_list = state["questions_list"]
+        n_questions=state["n_questions"]["total"]
+        
+        state = await retrieve_documents_for_all_questions(
+            search_figures=search_figures,
+            search_only=search_only,
+            reports=reports,
+            questions_list=questions_list,
+            n_questions=n_questions,
+            config=config,
+            source_type=source_type,
+            to_handle_questions_index=POC_questions_index,
+            vectorstore=vectorstore,
+            reranker=reranker,
+            rerank_by_question=rerank_by_question,
+            k_final=k_final,
+            k_before_reranking=k_before_reranking,
+        )
+        return state
+    
+    return retrieve_POC_docs_node
+
+
+# ToC Retriever
+async def get_relevant_toc_level_for_query(
+    query: str,
+    tocs: list[Document],
+) -> list[dict] : 
+
+    doc_list = []
+    for doc in tocs:
+        doc_name = doc[0].metadata['name']
+        toc = doc[0].page_content
+        doc_list.append({'document': doc_name, 'toc': toc})
+
+    llm = get_llm(provider="openai",max_tokens = 1024,temperature = 0.0)
+
+    prompt = ChatPromptTemplate.from_template(retrieve_chapter_prompt_template)
+    chain = prompt | llm | StrOutputParser()
+    response = chain.invoke({"query": query, "doc_list": doc_list})
+
+    try: 
+        relevant_tocs = eval(response)
+    except Exception as e:
+        print(f" Failed to parse the result because of : {e}")
+
+    return relevant_tocs
+
+
+async def get_POC_by_ToC_relevant_documents(
+    query: str,
+    tocs: list[str],
+    vectorstore:VectorStore,
+    version: str = "",
+    sources:list = ["Acclimaterra","PCAET","Plan Biodiversite"],
+    search_figures:bool = False,
+    search_only:bool = False,
+    k_documents:int = 10,
+    threshold:float = 0.6,
+    k_images: int = 5,
+    reports:list = [],
+    min_size:int = 200,
+    proportion: float = 0.5,
+) :
+    # Prepare base search kwargs
+    filters = {}
+    docs_question = []
+    docs_images = []
+
+    # TODO add source selection
+    # if len(reports) > 0:
+    #     filters["short_name"] = {"$in":reports}
+    # else:
+    #     filters["source"] = { "$in": sources}
+    
+    k_documents_toc = round(k_documents * proportion)
+    
+    relevant_tocs = await get_relevant_toc_level_for_query(query, tocs)
+    
+    print(f"Relevant ToCs : {relevant_tocs}")
+    # Transform the ToC dict {"document": str, "chapter": str} into a list of string 
+    toc_filters = [toc['chapter'] for toc in relevant_tocs]
+
+    filters_text_toc = {
+        **filters,
+        "chunk_type":"text",
+        "toc_level0": {"$in": toc_filters},
+        "version": version
+        # "report_type": {}, # TODO  to be completed to choose the right documents / chapters according to the analysis of the question
+    }
+    
+    docs_question = vectorstore.similarity_search_with_score(query=query,filter = filters_text_toc,k = k_documents_toc)
+
+    filters_text = {
+        **filters,
+        "chunk_type":"text",
+        "version": version
+        # "report_type": {}, # TODO  to be completed to choose the right documents / chapters according to the analysis of the question
+    }
+
+    docs_question += vectorstore.similarity_search_with_score(query=query,filter = filters_text,k = k_documents - k_documents_toc)
+
+    # remove duplicates or almost duplicates
+    docs_question = remove_duplicates_chunks(docs_question)
+    docs_question = [x for x in docs_question if x[1] > threshold]
+    
+    if search_figures:
+        # Images
+        filters_image = {
+            **filters,
+            "chunk_type":"image"
+        }
+        docs_images = vectorstore.similarity_search_with_score(query=query,filter = filters_image,k = k_images)
+        
+    docs_question, docs_images = _add_metadata_and_score(docs_question), _add_metadata_and_score(docs_images)
+    
+    docs_question = [x for x in docs_question if len(x.page_content) > min_size]
+    
+    return {
+        "docs_question" : docs_question,
+        "docs_images" : docs_images
+    }
+    
+
+def get_ToCs(version: str) :
+
+    filters_text = {
+        "chunk_type":"toc",
+        "version": version
+    }
+    embeddings_function = get_embeddings_function()
+    vectorstore = get_pinecone_vectorstore(embeddings_function, index_name="climateqa-v2")
+    tocs = vectorstore.similarity_search_with_score(query="",filter = filters_text)
+
+    # remove duplicates or almost duplicates
+    tocs = remove_duplicates_chunks(tocs)
+    
+    return tocs
+
+
+
+def make_POC_by_ToC_retriever_node(
+        vectorstore: VectorStore, 
+        reranker,
+        llm, 
+        version: str = "", 
+        rerank_by_question=True, 
+        k_final=15, 
+        k_before_reranking=100, 
+        k_summary=5,
+    ):
+    
+    async def retrieve_POC_docs_node(state, config):
+        if "POC region" not in state["relevant_content_sources_selection"]  :  
+            return {}
+        
+
+        tocs = get_ToCs(version=version)
+
+        source_type = "POC"
+        POC_questions_index = [i for i, x in enumerate(state["questions_list"]) if x["source_type"] == "POC"]
+        
         state = await retrieve_documents_for_all_questions(
             state=state,
             config=config,
@@ -457,6 +684,9 @@ def make_POC_retriever_node(vectorstore,reranker,llm,rerank_by_question=True, k_
             rerank_by_question=rerank_by_question,
             k_final=k_final,
             k_before_reranking=k_before_reranking,
+            tocs=tocs,
+            version=version,
+            by_toc=True
         )
         return state
     
@@ -464,3 +694,5 @@ def make_POC_retriever_node(vectorstore,reranker,llm,rerank_by_question=True, k_
 
 
 
+
+

climateqa/engine/graph.py

@@ -11,7 +11,7 @@ from typing import List, Dict
 
 import operator
 from typing import Annotated
-
+import pandas as pd
 from IPython.display import display, HTML, Image
 
 from .chains.answer_chitchat import make_chitchat_node
@@ -23,6 +23,7 @@ from .chains.retrieve_documents import make_IPx_retriever_node, make_POC_retriev
 from .chains.answer_rag import make_rag_node
 from .chains.graph_retriever import make_graph_retriever_node
 from .chains.chitchat_categorization import make_chitchat_intent_categorization_node
+from .chains.drias_retriever import make_drias_retriever_node
 # from .chains.set_defaults import set_defaults
 
 class GraphState(TypedDict):
@@ -39,16 +40,18 @@ class GraphState(TypedDict):
     n_questions : int
     answer: str
     audience: str = "experts"
-    sources_input: List[str] = ["IPCC","IPBES"]
+    sources_input: List[str] = ["IPCC","IPBES"] # Deprecated -> used only graphs that can only be OWID
     relevant_content_sources_selection: List[str] = ["Figures (IPCC/IPBES)"]
     sources_auto: bool = True
     min_year: int = 1960
     max_year: int = None
     documents: Annotated[List[Document], operator.add]
-    related_contents : Annotated[List[Document], operator.add]
-    recommended_content : List[Document]
+    related_contents : Annotated[List[Document], operator.add] # Images
+    recommended_content : List[Document] # OWID Graphs  # TODO merge with related_contents
     search_only : bool = False
     reports : List[str] = []
+    drias_data: pd.DataFrame
+    drias_sql_query : str
 
 def dummy(state):
     return 
@@ -72,7 +75,7 @@ def route_intent(state):
 def chitchat_route_intent(state):
     intent = state["search_graphs_chitchat"]
     if intent is True:
-        return "retrieve_graphs_chitchat"
+        return END #TODO 
     elif intent is False:
         return END
     
@@ -95,20 +98,10 @@ def route_based_on_relevant_docs(state,threshold_docs=0.2):
 def route_continue_retrieve_documents(state):
     index_question_ipx = [i for i, x in enumerate(state["questions_list"]) if x["source_type"] == "IPx"]
     questions_ipx_finished = all(elem in state["handled_questions_index"] for elem in index_question_ipx)
-    # if questions_ipx_finished and state["search_only"]:
-    #     return END
     if questions_ipx_finished:
         return "end_retrieve_IPx_documents"  
     else:
         return "retrieve_documents"
-
-    
-    # if state["n_questions"]["IPx"] == len(state["handled_questions_index"]) and state["search_only"] :
-    #     return END
-    # elif state["n_questions"]["IPx"] == len(state["handled_questions_index"]):
-    #     return "answer_search"
-    # else :
-    #     return "retrieve_documents"
     
 def route_continue_retrieve_local_documents(state):
     index_question_poc = [i for i, x in enumerate(state["questions_list"]) if x["source_type"] == "POC"]
@@ -120,20 +113,6 @@ def route_continue_retrieve_local_documents(state):
     else:
         return "retrieve_local_data"
     
-    # if state["n_questions"]["POC"] == len(state["handled_questions_index"]) and state["search_only"] :
-    #     return END
-    # elif state["n_questions"]["POC"] == len(state["handled_questions_index"]):
-    #     return "answer_search"
-    # else :
-    #     return "retrieve_local_data"
-    
-    # if len(state["remaining_questions"]) == 0 and state["search_only"] :
-        # return END
-    # elif len(state["remaining_questions"]) > 0:
-    #     return "retrieve_documents"
-    # else:
-    #     return "answer_search"
-    
 def route_retrieve_documents(state):
     sources_to_retrieve = []
     
@@ -248,6 +227,7 @@ def make_graph_agent_poc(llm, vectorstore_ipcc, vectorstore_graphs, vectorstore_
     answer_rag = make_rag_node(llm, with_docs=True)
     answer_rag_no_docs = make_rag_node(llm, with_docs=False)
     chitchat_categorize_intent = make_chitchat_intent_categorization_node(llm)
+    # retrieve_drias_data = make_drias_retriever_node(llm) # WIP
 
     # Define the nodes
     # workflow.add_node("set_defaults", set_defaults)
@@ -266,6 +246,7 @@ def make_graph_agent_poc(llm, vectorstore_ipcc, vectorstore_graphs, vectorstore_
     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)
+    # workflow.add_node("retrieve_drias_data", retrieve_drias_data)# WIP
 
     # Entry point
     workflow.set_entry_point("categorize_intent")
@@ -315,6 +296,10 @@ def make_graph_agent_poc(llm, vectorstore_ipcc, vectorstore_graphs, vectorstore_
     workflow.add_edge("retrieve_local_data", "answer_search")
     workflow.add_edge("retrieve_documents", "answer_search")
 
+    # workflow.add_edge("transform_query", "retrieve_drias_data")
+    # workflow.add_edge("retrieve_drias_data", END)
+
+
     # Compile
     app = workflow.compile()
     return app

climateqa/engine/talk_to_data/main.py

@@ -0,0 +1,60 @@
+from climateqa.engine.talk_to_data.myVanna import MyVanna
+from climateqa.engine.talk_to_data.utils import loc2coords, detect_location_with_openai, detectTable, nearestNeighbourSQL, detect_relevant_tables, replace_coordonates
+import sqlite3
+import os
+import pandas as pd
+from climateqa.engine.llm import get_llm
+
+from dotenv import load_dotenv
+import ast
+
+load_dotenv()
+
+
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+PC_API_KEY = os.getenv('VANNA_PINECONE_API_KEY')
+INDEX_NAME = os.getenv('VANNA_INDEX_NAME')
+VANNA_MODEL = os.getenv('VANNA_MODEL')
+
+
+#Vanna object
+vn = MyVanna(config = {"temperature": 0, "api_key": OPENAI_API_KEY, 'model': VANNA_MODEL, 'pc_api_key': PC_API_KEY, 'index_name': INDEX_NAME, "top_k" : 4})
+db_vanna_path = os.path.join(os.path.dirname(__file__), "database/drias.db")
+vn.connect_to_sqlite(db_vanna_path)
+
+llm = get_llm(provider="openai")
+
+def ask_llm_to_add_table_names(sql_query, llm):
+    sql_with_table_names = llm.invoke(f"Make the following sql query display the source table in the rows {sql_query}. Just answer the query. The answer should not include ```sql\n").content
+    return sql_with_table_names
+
+def ask_llm_column_names(sql_query, llm):
+    columns = llm.invoke(f"From the given sql query, list the columns that are being selected. The answer should only be a python list. Just answer the list. The SQL query : {sql_query}").content
+    columns_list = ast.literal_eval(columns.strip("```python\n").strip())
+    return columns_list
+
+def ask_vanna(query):
+    try :
+        location = detect_location_with_openai(OPENAI_API_KEY, query)
+        if location:
+
+            coords = loc2coords(location)
+            user_input = query.lower().replace(location.lower(), f"lat, long : {coords}")
+            
+            relevant_tables = detect_relevant_tables(user_input, llm)
+            coords_tables = [nearestNeighbourSQL(db_vanna_path, coords, relevant_tables[i]) for i in range(len(relevant_tables))]
+            user_input_with_coords = replace_coordonates(coords, user_input, coords_tables)
+
+            sql_query, result_dataframe, figure = vn.ask(user_input_with_coords, print_results=False, allow_llm_to_see_data=True, auto_train=False)
+
+            return sql_query, result_dataframe, figure
+
+        else : 
+            empty_df = pd.DataFrame()
+            empty_fig = {}
+            return "", empty_df, empty_fig
+    except Exception as e:
+        print(f"Error: {e}")
+        empty_df = pd.DataFrame()
+        empty_fig = {}
+        return "", empty_df, empty_fig

climateqa/engine/talk_to_data/myVanna.py

@@ -0,0 +1,13 @@
+from dotenv import load_dotenv
+from climateqa.engine.talk_to_data.vanna_class import MyCustomVectorDB
+from vanna.openai import OpenAI_Chat
+import os
+
+load_dotenv()
+
+OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
+
+class MyVanna(MyCustomVectorDB, OpenAI_Chat):
+    def __init__(self, config=None):
+        MyCustomVectorDB.__init__(self, config=config)
+        OpenAI_Chat.__init__(self, config=config)

climateqa/engine/talk_to_data/utils.py

@@ -0,0 +1,98 @@
+import re
+import openai
+import pandas as pd
+from geopy.geocoders import Nominatim
+import sqlite3
+import ast
+
+
+def detect_location_with_openai(api_key, sentence):
+    """
+    Detects locations in a sentence using OpenAI's API.
+    """
+    openai.api_key = api_key
+
+    prompt = f"""
+    Extract all locations (cities, countries, states, or geographical areas) mentioned in the following sentence.
+    Return the result as a Python list. If no locations are mentioned, return an empty list.
+    
+    Sentence: "{sentence}"
+    """
+
+    response = openai.chat.completions.create(
+        model="gpt-4o-mini",  
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant skilled in identifying locations in text."},
+            {"role": "user", "content": prompt}
+        ],
+        max_tokens=100,
+        temperature=0
+    )
+
+    return response.choices[0].message.content.split("\n")[1][2:-2]
+
+
+def detectTable(sql_query):
+    pattern = r'(?i)\bFROM\s+((?:`[^`]+`|"[^"]+"|\'[^\']+\'|\w+)(?:\.(?:`[^`]+`|"[^"]+"|\'[^\']+\'|\w+))*)'
+    matches = re.findall(pattern, sql_query)
+    return matches
+
+
+
+def loc2coords(location : str):
+    geolocator = Nominatim(user_agent="city_to_latlong")
+    location = geolocator.geocode(location)
+    return (location.latitude, location.longitude)
+
+
+def coords2loc(coords : tuple):
+    geolocator = Nominatim(user_agent="coords_to_city")
+    try:
+        location = geolocator.reverse(coords)
+        return location.address
+    except Exception as e:
+        print(f"Error: {e}")
+        return "Unknown Location"  
+
+
+def nearestNeighbourSQL(db: str, location: tuple, table : str):
+    conn = sqlite3.connect(db)
+    long = round(location[1], 3)
+    lat = round(location[0], 3)
+    cursor  = conn.cursor()
+    cursor.execute(f"SELECT lat, lon FROM {table} WHERE lat BETWEEN {lat - 0.3} AND {lat + 0.3} AND lon BETWEEN {long - 0.3} AND {long + 0.3}")
+    results = cursor.fetchall()
+    return results[0]
+
+def detect_relevant_tables(user_question, llm):
+    table_names_list = [
+        "Frequency_of_rainy_days_index",
+        "Winter_precipitation_total",
+        "Summer_precipitation_total",
+        "Annual_precipitation_total",
+        # "Remarkable_daily_precipitation_total_(Q99)",
+        "Frequency_of_remarkable_daily_precipitation",
+        "Extreme_precipitation_intensity",
+        "Mean_winter_temperature",
+        "Mean_summer_temperature",
+        "Number_of_tropical_nights",
+        "Maximum_summer_temperature",
+        "Number_of_days_with_Tx_above_30C",
+        "Number_of_days_with_Tx_above_35C",
+        "Drought_index"
+    ]
+    prompt = (
+        f"You are helping to build a sql query to retrieve relevant data for a user question."
+        f"The different tables are {table_names_list}."
+        f"The user question is {user_question}. Write the relevant tables to use. Answer only a python list of table name."
+    )
+    table_names = ast.literal_eval(llm.invoke(prompt).content.strip("```python\n").strip())
+    return table_names
+
+def replace_coordonates(coords, query, coords_tables):
+    n = query.count(str(coords[0]))
+
+    for i in range(n):
+        query = query.replace(str(coords[0]), str(coords_tables[i][0]),1)
+        query = query.replace(str(coords[1]), str(coords_tables[i][1]),1)
+    return query

climateqa/engine/talk_to_data/vanna_class.py

@@ -0,0 +1,325 @@
+from vanna.base import VannaBase
+from pinecone import Pinecone
+from climateqa.engine.embeddings import get_embeddings_function
+import pandas as pd
+import hashlib
+
+class MyCustomVectorDB(VannaBase):
+    
+    """
+    VectorDB class for storing and retrieving vectors from Pinecone.
+    
+    args : 
+        config (dict) : Configuration dictionary containing the Pinecone API key and the index name :
+            - pc_api_key (str) : Pinecone API key
+            - index_name (str) : Pinecone index name
+            - top_k (int) : Number of top results to return (default = 2)
+            
+    """
+    
+    def __init__(self,config):
+        super().__init__(config = config)
+        try : 
+            self.api_key = config.get('pc_api_key')
+            self.index_name = config.get('index_name')
+        except : 
+            raise Exception("Please provide the Pinecone API key and the index name")
+        
+        self.pc = Pinecone(api_key = self.api_key)
+        self.index = self.pc.Index(self.index_name)
+        self.top_k = config.get('top_k', 2)
+        self.embeddings = get_embeddings_function()
+        
+        
+    def check_embedding(self, id, namespace):
+        fetched = self.index.fetch(ids = [id], namespace = namespace)
+        if fetched['vectors'] == {}: 
+            return False
+        return True
+    
+    def generate_hash_id(self, data: str) -> str:
+        """
+        Generate a unique hash ID for the given data.
+        
+        Args:
+            data (str): The input data to hash (e.g., a concatenated string of user attributes).
+        
+        Returns:
+            str: A unique hash ID as a hexadecimal string.
+        """
+        
+        data_bytes = data.encode('utf-8')
+        hash_object = hashlib.sha256(data_bytes)
+        hash_id = hash_object.hexdigest()
+        
+        return hash_id
+    
+    def add_ddl(self, ddl: str, **kwargs) -> str:
+        id = self.generate_hash_id(ddl) + '_ddl'
+        
+        if self.check_embedding(id, 'ddl'):
+            print(f"DDL having id {id} already exists")
+            return id
+        
+        self.index.upsert(
+            vectors = [(id, self.embeddings.embed_query(ddl), {'ddl': ddl})],
+            namespace = 'ddl'
+        )
+        
+        return id
+
+    def add_documentation(self, doc: str, **kwargs) -> str:
+        id = self.generate_hash_id(doc) + '_doc'
+        
+        if self.check_embedding(id, 'documentation'):
+            print(f"Documentation having id {id} already exists")
+            return id
+        
+        self.index.upsert(
+            vectors = [(id, self.embeddings.embed_query(doc), {'doc': doc})],
+            namespace = 'documentation'
+        )
+        
+        return id
+
+    def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
+        id = self.generate_hash_id(question) + '_sql'
+        
+        if self.check_embedding(id, 'question_sql'):
+            print(f"Question-SQL pair having id {id} already exists")
+            return id
+        
+        self.index.upsert(
+            vectors = [(id, self.embeddings.embed_query(question + sql), {'question': question, 'sql': sql})],
+            namespace = 'question_sql'
+        )
+        
+        return id
+
+    def get_related_ddl(self, question: str, **kwargs) -> list:
+        res = self.index.query(
+            vector=self.embeddings.embed_query(question),
+            top_k=self.top_k,
+            namespace='ddl',
+            include_metadata=True
+        )
+        
+        return [match['metadata']['ddl'] for match in res['matches']]
+
+    def get_related_documentation(self, question: str, **kwargs) -> list:
+        res = self.index.query(
+            vector=self.embeddings.embed_query(question),
+            top_k=self.top_k,
+            namespace='documentation',
+            include_metadata=True
+        )
+        
+        return [match['metadata']['doc'] for match in res['matches']]
+
+    def get_similar_question_sql(self, question: str, **kwargs) -> list:
+        res = self.index.query(
+            vector=self.embeddings.embed_query(question),
+            top_k=self.top_k,
+            namespace='question_sql',
+            include_metadata=True
+        )
+        
+        return [(match['metadata']['question'], match['metadata']['sql']) for match in res['matches']]
+
+    def get_training_data(self, **kwargs) -> pd.DataFrame:
+        
+        list_of_data = []
+        
+        namespaces = ['ddl', 'documentation', 'question_sql']
+        
+        for namespace in namespaces:
+            
+            data = self.index.query(
+            top_k=10000,
+            namespace=namespace,
+            include_metadata=True,
+            include_values=False
+            )
+            
+            for match in data['matches']:
+                list_of_data.append(match['metadata'])
+                
+        return pd.DataFrame(list_of_data)
+            
+
+
+    def remove_training_data(self, id: str, **kwargs) -> bool:
+        if id.endswith("_ddl"):
+            self.Index.delete(ids=[id], namespace="_ddl")
+            return True
+        if id.endswith("_sql"):
+            self.index.delete(ids=[id], namespace="_sql")
+            return True
+        
+        if id.endswith("_doc"):
+            self.Index.delete(ids=[id], namespace="_doc")
+            return True
+        
+        return False
+    
+    def generate_embedding(self, text, **kwargs):
+        # Implement the method here
+        pass
+
+
+    def get_sql_prompt(
+            self,
+            initial_prompt : str,
+            question: str,
+            question_sql_list: list,
+            ddl_list: list,
+            doc_list: list,
+            **kwargs,
+        ):
+            """
+            Example:
+            ```python
+            vn.get_sql_prompt(
+                question="What are the top 10 customers by sales?",
+                question_sql_list=[{"question": "What are the top 10 customers by sales?", "sql": "SELECT * FROM customers ORDER BY sales DESC LIMIT 10"}],
+                ddl_list=["CREATE TABLE customers (id INT, name TEXT, sales DECIMAL)"],
+                doc_list=["The customers table contains information about customers and their sales."],
+            )
+
+            ```
+
+            This method is used to generate a prompt for the LLM to generate SQL.
+
+            Args:
+                question (str): The question to generate SQL for.
+                question_sql_list (list): A list of questions and their corresponding SQL statements.
+                ddl_list (list): A list of DDL statements.
+                doc_list (list): A list of documentation.
+
+            Returns:
+                any: The prompt for the LLM to generate SQL.
+            """
+
+            if initial_prompt is None:
+                initial_prompt = f"You are a {self.dialect} expert. " + \
+                "Please help to generate a SQL query to answer the question. Your response should ONLY be based on the given context and follow the response guidelines and format instructions. "
+
+            initial_prompt = self.add_ddl_to_prompt(
+                initial_prompt, ddl_list, max_tokens=self.max_tokens
+            )
+
+            if self.static_documentation != "":
+                doc_list.append(self.static_documentation)
+
+            initial_prompt = self.add_documentation_to_prompt(
+                initial_prompt, doc_list, max_tokens=self.max_tokens
+            )
+
+            # initial_prompt = self.add_sql_to_prompt(
+            #     initial_prompt, question_sql_list, max_tokens=self.max_tokens
+            # )
+
+
+            initial_prompt += (
+                "===Response Guidelines \n"
+                "1. If the provided context is sufficient, please generate a valid SQL query without any explanations for the question. \n"
+                "2. If the provided context is almost sufficient but requires knowledge of a specific string in a particular column, please generate an intermediate SQL query to find the distinct strings in that column. Prepend the query with a comment saying intermediate_sql \n"
+                "3. If the provided context is insufficient, please give a sql query based on your knowledge and the context provided. \n"
+                "4. Please use the most relevant table(s). \n"
+                "5. If the question has been asked and answered before, please repeat the answer exactly as it was given before. \n"
+                f"6. Ensure that the output SQL is {self.dialect}-compliant and executable, and free of syntax errors. \n"
+                f"7. Add a description of the table in the result of the sql query, if relevant. \n"
+                "8 Make sure to include the relevant KPI in the SQL query. The query should return impactfull data \n"
+                # f"8. If a set of latitude,longitude is provided, make a intermediate query to find the nearest value in the table and replace the coordinates in the sql query. \n"
+                # "7. Add a description of the table in the result of the sql query."
+                # "7. If the question is about a specific latitude, longitude, query an interval of 0.3 and keep only the first set of coordinate. \n"
+                # "7. Table names should be included in the result of the sql query. Use for example Mean_winter_temperature AS table_name in the query \n"
+            )
+
+
+            message_log = [self.system_message(initial_prompt)]
+
+            for example in question_sql_list:
+                if example is None:
+                    print("example is None")
+                else:
+                    if example is not None and "question" in example and "sql" in example:
+                        message_log.append(self.user_message(example["question"]))
+                        message_log.append(self.assistant_message(example["sql"]))
+
+            message_log.append(self.user_message(question))
+
+            return message_log
+        
+
+# def get_sql_prompt(
+#         self,
+#         initial_prompt : str,
+#         question: str,
+#         question_sql_list: list,
+#         ddl_list: list,
+#         doc_list: list,
+#         **kwargs,
+#     ):
+#         """
+#         Example:
+#         ```python
+#         vn.get_sql_prompt(
+#             question="What are the top 10 customers by sales?",
+#             question_sql_list=[{"question": "What are the top 10 customers by sales?", "sql": "SELECT * FROM customers ORDER BY sales DESC LIMIT 10"}],
+#             ddl_list=["CREATE TABLE customers (id INT, name TEXT, sales DECIMAL)"],
+#             doc_list=["The customers table contains information about customers and their sales."],
+#         )
+
+#         ```
+
+#         This method is used to generate a prompt for the LLM to generate SQL.
+
+#         Args:
+#             question (str): The question to generate SQL for.
+#             question_sql_list (list): A list of questions and their corresponding SQL statements.
+#             ddl_list (list): A list of DDL statements.
+#             doc_list (list): A list of documentation.
+
+#         Returns:
+#             any: The prompt for the LLM to generate SQL.
+#         """
+
+#         if initial_prompt is None:
+#             initial_prompt = f"You are a {self.dialect} expert. " + \
+#             "Please help to generate a SQL query to answer the question. Your response should ONLY be based on the given context and follow the response guidelines and format instructions. "
+
+#         initial_prompt = self.add_ddl_to_prompt(
+#             initial_prompt, ddl_list, max_tokens=self.max_tokens
+#         )
+
+#         if self.static_documentation != "":
+#             doc_list.append(self.static_documentation)
+
+#         initial_prompt = self.add_documentation_to_prompt(
+#             initial_prompt, doc_list, max_tokens=self.max_tokens
+#         )
+
+#         initial_prompt += (
+#             "===Response Guidelines \n"
+#             "1. If the provided context is sufficient, please generate a valid SQL query without any explanations for the question. \n"
+#             "2. If the provided context is almost sufficient but requires knowledge of a specific string in a particular column, please generate an intermediate SQL query to find the distinct strings in that column. Prepend the query with a comment saying intermediate_sql \n"
+#             "3. If the provided context is insufficient, please explain why it can't be generated. \n"
+#             "4. Please use the most relevant table(s). \n"
+#             "5. If the question has been asked and answered before, please repeat the answer exactly as it was given before. \n"
+#             f"6. Ensure that the output SQL is {self.dialect}-compliant and executable, and free of syntax errors. \n"
+#         )
+
+#         message_log = [self.system_message(initial_prompt)]
+
+#         for example in question_sql_list:
+#             if example is None:
+#                 print("example is None")
+#             else:
+#                 if example is not None and "question" in example and "sql" in example:
+#                     message_log.append(self.user_message(example["question"]))
+#                     message_log.append(self.assistant_message(example["sql"]))
+
+#         message_log.append(self.user_message(question))
+
+#         return message_log

front/tabs/chat_interface.py

@@ -20,12 +20,31 @@ Please note that we log your questions for meta-analysis purposes, so avoid shar
 What do you want to learn ?
 """
 
+init_prompt_poc = """
+Hello, I am ClimateQ&A, a conversational assistant designed to help you understand climate change and biodiversity loss. I will answer your questions by **sifting through the IPCC and IPBES scientific reports, PCAET of Paris, the Plan Biodiversité 2018-2024, and Acclimaterra reports from la Région Nouvelle-Aquitaine **.
+
+❓ How to use
+- **Language**: You can ask me your questions in any language. 
+- **Audience**: You can specify your audience (children, general public, experts) to get a more adapted answer.
+- **Sources**: You can choose to search in the IPCC or IPBES reports, and POC sources for local documents (PCAET, Plan Biodiversité, Acclimaterra).
+- **Relevant content sources**: You can choose to search for figures, papers, or graphs that can be relevant for your question.
+
+⚠️ Limitations
+*Please note that the AI is not perfect and may sometimes give irrelevant answers. If you are not satisfied with the answer, please ask a more specific question or report your feedback to help us improve the system.*
+
+🛈 Information
+Please note that we log your questions for meta-analysis purposes, so avoid sharing any sensitive or personal information.
+
+What do you want to learn ?
+"""
+
 
 
 # UI Layout Components
-def create_chat_interface():
+def create_chat_interface(tab):
+    init_prompt_message = init_prompt_poc if tab == "Beta - POC Adapt'Action" else init_prompt
     chatbot = gr.Chatbot(
-        value=[ChatMessage(role="assistant", content=init_prompt)],
+        value=[ChatMessage(role="assistant", content=init_prompt_message)],
         type="messages", 
         show_copy_button=True,
         show_label=False,

front/tabs/main_tab.py

@@ -3,7 +3,6 @@ from .chat_interface import create_chat_interface
 from .tab_examples import create_examples_tab
 from .tab_papers import create_papers_tab
 from .tab_figures import create_figures_tab
-from .chat_interface import create_chat_interface
 
 def cqa_tab(tab_name):
     # State variables
@@ -12,7 +11,7 @@ def cqa_tab(tab_name):
         with gr.Row(elem_id="chatbot-row"):
             # Left column - Chat interface
             with gr.Column(scale=2):
-                chatbot, textbox, config_button = create_chat_interface()
+                chatbot, textbox, config_button = create_chat_interface(tab_name)
 
             # Right column - Content panels
             with gr.Column(scale=2, variant="panel", elem_id="right-panel"):

front/tabs/tab_papers.py

@@ -3,6 +3,8 @@ from gradio_modal import Modal
 
 
 def create_papers_tab():
+    direct_search_textbox = gr.Textbox(label="Direct search for papers", placeholder= "What is climate change ?", elem_id="papers-search")
+
     with gr.Accordion(
         visible=True,
         elem_id="papers-summary-popup",
@@ -32,5 +34,5 @@ def create_papers_tab():
         papers_modal
     )
     
-    return papers_summary, papers_html, citations_network, papers_modal
+    return direct_search_textbox, papers_summary, papers_html, citations_network, papers_modal
 

requirements.txt

@@ -19,3 +19,5 @@ langchain-community==0.2
 msal==1.31
 matplotlib==3.9.2
 gradio-modal==0.0.4
+vanna==0.7.5
+geopy==2.4.1

sandbox/talk_to_data/20250306 - CQA - Drias.ipynb

@@ -0,0 +1,94 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import the function in main.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import os\n",
+    "sys.path.append(os.path.dirname(os.path.dirname(os.getcwd())))\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from climateqa.engine.talk_to_data.main import ask_vanna\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a human query"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# query = \"Compare the winter and summer precipitation in 2050 in Marseille\"\n",
+    "# query = \"What is the impact of climate  in Bordeaux?\"\n",
+    "# query = \"what is the number of days where the temperature above 35 in 2050 in Marseille\"\n",
+    "# query = \"Quelle sera la température à Marseille sur les prochaines années ?\"\n",
+    "# query = \"Comment vont évoluer les températures à Marseille ?\"\n",
+    "query = \"Comment vont évoluer les températures à marseille ?\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Call the function ask vanna, it gives an output of a the sql query and the dataframe of the result (tuple)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sql_query, df, fig = ask_vanna(query)\n",
+    "print(df.head())\n",
+    "fig.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "climateqa",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

sandbox/talk_to_data/20250306 - CQA - Step_by_step_vanna.ipynb

@@ -0,0 +1,201 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import os\n",
+    "sys.path.append(os.path.dirname(os.path.dirname(os.getcwd())))\n",
+    "\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from climateqa.engine.talk_to_data.main import ask_vanna\n",
+    "\n",
+    "import sqlite3\n",
+    "import os\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from climateqa.engine.talk_to_data.myVanna import MyVanna\n",
+    "from climateqa.engine.talk_to_data.utils import loc2coords, detect_location_with_openai, detectTable, nearestNeighbourSQL, detect_relevant_tables, replace_coordonates\n",
+    "\n",
+    "from climateqa.engine.llm import get_llm"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Vanna Ask\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()\n",
+    "\n",
+    "llm = get_llm(provider=\"openai\")\n",
+    "\n",
+    "OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')\n",
+    "PC_API_KEY = os.getenv('VANNA_PINECONE_API_KEY')\n",
+    "INDEX_NAME = os.getenv('VANNA_INDEX_NAME')\n",
+    "VANNA_MODEL = os.getenv('VANNA_MODEL')\n",
+    "\n",
+    "ROOT_PATH = os.path.dirname(os.path.dirname(os.getcwd()))\n",
+    "\n",
+    "#Vanna object\n",
+    "vn = MyVanna(config = {\"temperature\": 0, \"api_key\": OPENAI_API_KEY, 'model': VANNA_MODEL, 'pc_api_key': PC_API_KEY, 'index_name': INDEX_NAME, \"top_k\" : 4})\n",
+    "db_vanna_path = ROOT_PATH + \"/data/drias/drias.db\"\n",
+    "vn.connect_to_sqlite(db_vanna_path)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# User query"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# query = \"Quelle sera la température à Marseille sur les prochaines années ?\"\n",
+    "query = \"Comment vont évoluer les températures à marseille ?\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Detect location"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "location = detect_location_with_openai(OPENAI_API_KEY, query)\n",
+    "print(location)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Convert location to longitude, latitude coordonate"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "coords = loc2coords(location)\n",
+    "user_input = query.lower().replace(location.lower(), f\"lat, long : {coords}\")\n",
+    "print(user_input)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Find closest coordonates and replace lat,lon\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "relevant_tables = detect_relevant_tables(user_input, llm)            \n",
+    "coords_tables = [nearestNeighbourSQL(db_vanna_path, coords, relevant_tables[i]) for i in range(len(relevant_tables))]\n",
+    "user_input_with_coords = replace_coordonates(coords, user_input, coords_tables)\n",
+    "print(user_input_with_coords)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Ask Vanna with correct coordonates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sql_query, result_dataframe, figure = vn.ask(user_input_with_coords, print_results=False, allow_llm_to_see_data=True, auto_train=False)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result_dataframe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "figure"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "climateqa",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

style.css

@@ -481,14 +481,13 @@ a {
         max-height: calc(100vh - 190px) !important;
         overflow: hidden;
     }
-
     div#tab-examples,
     div#sources-textbox,
     div#tab-config {
         height: calc(100vh - 190px) !important;
         overflow-y: scroll !important;
     }
-
+    div#tab-vanna,
     div#sources-figures,
     div#graphs-container,
     div#tab-citations {
@@ -606,3 +605,16 @@ a {
 #checkbox-config:checked {
     display: block;
 }
+
+#vanna-display {
+    max-height: 300px;
+    /* overflow-y: scroll; */
+}
+#sql-query{
+    max-height: 100px;
+    overflow-y:scroll;
+}
+#vanna-details{
+    max-height: 500px;
+    overflow-y:scroll;
+}