talk_to_ipcc (#29)

- change local examples (3fa35bfc2ec4e3397b571eecc44a68b1a1d1152c)
- fix (c5c15575b0a549578448fa4ae916af294cd4bdc4)
- Upload drias.db (7ea3b8dc6dcc209c74ac86140c23c3f35356b271)
- feature/add_talk_to_data (#23) (dac62987820b2d821cda7ee86bca058bcf66a66b)
- Change openai_key (680ed1c172d20c1280a46077a72c2eb7be02bd10)
- update OpenAI usage from Vanna (3e75ed8cd2d2f444a43cc93c814d4392f991d8dc)
- Small clean POC Local (0327516552f1b9af184361e8594b7377a4e0bcb2)
- Clean configs (ecab0c839ce7fc8100121a0174409451dbb5dd50)
- fix : fix gradio component (1e74d1402fb3c834dc9c0163aeb5028dbd6764bd)
- take the last question as history to understand the question (676d17bd25bb4cbd8cf9396ee353aac7a7028af0)
- Add follow up questions (aaa4bbedbbdee9951a33c8d7bbfd7583fa441bc5)
- Fix : Dynamic follow up examples (a984d58b3e8cf8458eec39ed29d0267590f8e75a)
- Merged in feature/dynamic_conversation (pull request #1) (f684aff68309e2f14164cef7fd02a6da804dcef9)
- Update style.css (e8258aea3313f558bb0afa650464d740fa4b2da4)
- Merge branch 'dev' of https://bitbucket.org/ekimetrics/climate_qa into dev (03a8baf608fd8a639c96a661725c181660122aa1)
- feat: implemented talk to drias v1 (4df74e4b75096daf90548ae7eefe6c32df002bcd)
- feat: added 2 new talk to data plots (170018666950c1b7433f6baba17ad36042282a2e)
- feat: added drias model choice and changed TTD UI (1eae86b617a8336ee3e4b7b11e39dc0769731812)
- fix: fixed bugs and errors (e6e652c91a221b56eb508cc98b13d27b5785e803)
- Merge branch 'dev' into feat/talk_to_data_graph (561caf15f2fd2954b43a49064ac11a085d343151)
- update css for follow up examples (54e2358ad0444473be0ac8d6c436ef73cfcceb3b)
- ensure correct output language (723be3263bfd1a048f671b7ef11219de2c10b736)
- feat: model filtering and UI upgrade for TTD (6155a631718e808fb6622083848a5fc3bf231937)
- feat: added list of tables and reduced execution time of TTD (0bdf2f6f90901ed5cd65fc99d4de1da8eab1788a)
- add documentation (161aa8c18cb4be2d0c5df0dc64f3c202e55c582d)
- Move hardcoded configuration in a config file (45a93206d1c3507a622ba4f40df17a339d5a8bad)
- make ask drias asynchronous (5fe15430ebbb47868615f715c00d6274fad0e7a7)
- Add drias indicators (989d387afc62cb38ae239e5cc97664f702e3fa54)
- Add examples (d4fa76b2cb0a8ed1ae0f482254acfbd0242fdc73)
- UI improvment (1d710d6428b17b25b42e14fa494c2823b7e74e81)
- split front element and event listening (ca2c42949b3de84aeaaabf5879f107cd829523a0)
- Merged in feat/talk_to_data_graph (pull request #3) (f2baf8741a4c6b9712f2cd9cec2f86ddb4ca4274)
- Merge branch 'dev' of https://bitbucket.org/ekimetrics/climate_qa into dev (5c04812e26e5faa6ee2a85867f0155c1e56b96a0)
- add logs of drias interactions (bc43b45669dfd4740dc90d6daa1128278857d5d3)
- Merged in dev (pull request #4) (6af9e984b3a852db3414a96307040d2bbc031871)
- rename tabs for prod (b09184847c18b284fd0d08532a1572722f9159d5)
- V1.7 - Dynamic conversation & France local QA (#24) (6f13540b2041360bcd5d6eab4d699df28d96abce)
- Fix for python 3.10 (b142280be035c6ee3a6496f98cac37b23b38e18d)
- Fix requirements (f1b3e893c4b744376eec5ae30e3ed2e6c11fd8cf)
- update requirements (f46a24ac65bd569cad69d2281c5b5943a9a0830e)
- fixed requiremets (9ab8c871a2c9a8d6bf54d51d32666e973e46b4ee)
- Merge branch 'main' of https://huggingface.co/spaces/Ekimetrics/climate-question-answering (584bae4c2796688e9ecfdd393c693ce0e0d18fc5)
- fix tab name (0a2f32b117ce6289b5c49ab68a7aaedc502f5eca)
- Merge remote-tracking branch 'hf-origin/main' (0afa3dbe6042da779ac4911e23ce5cf7a4d40065)
- TTD : remove first unrelevant points (535d47236a99ebdc1e297eeb35b8833498214af2)
- Fixed follow up examples for local qa (c56c4345fd9484d8d43fd4ee36d8a4a0c3f6bd67)
- change init prompt to english (8c7a7fed7bddc7e672a257ab80f0840a6977de17)
- log to huggingface (f9c4c84a71d320c6db05ee099b9e35492ba7b184)
- Merged in feat/logs_on_huggingface (pull request #5) (261632833e7d939c321f208edfd6576e68947b4b)
- feat: added multithreading to run sql queries in talk to drias (705ccece7775c65a9c7b73b091cdddbc4246f2e7)
- chore: remove prints in talk to drias workflow (a967134f90c70d87bb3d786f2feb81f2e56fdb9f)
- Merged in feat/improve_drias_exeuction_time (pull request #6) (7c38528636ac19c1efa240a122e523ed0c34706a)
- fix import (05b8df9c9b74926459da70797b6852ff07a4d838)
- Merge branch 'main' into dev (8fb231c8beabf8a6406f05cf4cac564c5d81c7ce)
- Merged in dev (pull request #7) (6b9f71b1cf216eef0fd7973412f675d8633a5f4a)
- fix import (b35df2a8160723e43f74a040aa94983069066213)
- Merge branch 'main' of https://bitbucket.org/ekimetrics/climate_qa (f96cfd0715ec2b1ed7a78775ea7f8722f5793d8f)
- feature/drias_parallelization (#25) (47a68b0f6974850c8ec2465bdeda32c731e94568)
- feat: changed talk to drias UI (14d7085602602feef3ce51430f34221dadaa21df)
- temp fix : reranker switch to nano (99302fc182b3b15e3c15a03a633b46adf31e088f)
- Merged in dev (pull request #9) (bbc7806f08a3754842b0c228035c5fe985d45cc3)
- Merge remote-tracking branch 'hf-origin/main' (1b9b1eed6d3a82a9b23791df13f180181e6baa31)
- refactor: modularized talk to data (46c1e346e695ba31e91a6495a57a9063cf4dad54)
- Merge remote-tracking branch 'origin' into refactor/ttd_modularization (c25f6b1dd1d359574c77810933bcd01119f8a5b3)
- Standardize loggin (5b1b83bccbc4b9ae9021e29b43d822cf5b013e7d)
- Merge branch 'dev' into feat/logs_on_huggingface (32d594b10afd7196a7a83f9d9cb6a169a1c5ef51)
- Update constants.py (7a891a71dd288d985b940a61e3df26b34bb496e3)
- correct logs formating for dataviewer (2de91ee28e1168621896119cf65e44608f03000f)
- change logs repo (5f2bda40adc7025b6828daa3c8e65604f10cffaa)
- Merged in feat/logs_on_huggingface (pull request #11) (f52ad179f835a04bc5f6b9880699c7889cf0fc6c)
- Update logging.py (3ff380ff39b5417cda20a8f953301b6f1b833800)
- Merged in feat/logs_on_huggingface (pull request #12) (7c8dc1752e212554fba0a9bbf38d2552af5f72e1)
- Merged in main (pull request #13) (9a9ab642ce3a6361946f3d6ef5f8282d893d6a24)
- Merged in dev (pull request #14) (97d80b660352d1e09bfd697e86d4a7b4f6386571)
- add logs fallback on azure (58f35b70200236190bc8f57f5ec75a72573b31a1)
- Merged in feat/logs_on_huggingface (pull request #15) (e92e8dc1b629f6e9c61657683419e6585fd54261)
- Merged in dev (pull request #16) (eae39a6274f762fdfdfc49e86680d27ce7c6c8fc)
- feat: updated common talk to data for talk to ipcc and drias (c0fd277fca5091c51086af4aeaaa36f625531cef)
- feat: created queries for talk to ipcc (e8d5bc9410f6777c62dcacb77160ea08ac172e31)
- feat: created plots for talk to ipcc (3f85f963aef03ebf32f77836652ce1926778958b)
- feat: created config constants for talk to ipcc (c3398f4493e79a39702edcfa436a860312edf3e5)
- implemented talk to ipcc workflow and updated talk to data state object (45e1dba85d72fed8767b1e369934cf13639a3242)
- Merged in feature/talk_to_ipcc (pull request #17) (ac63459d9126fed1121796aaee4cb3adfbc955d9)
- feat: updated talk to drias based on talk to ipcc (c3024c3df719b25b6aee66dda3aed3927bb83077)
- Merge remote-tracking branch 'origin' into feature/talk_to_data (4af247227e85f9b72b159b213d3a1eccee7b6733)
- chore: added geojson to requirements (1a4f8680944e738da3237b7d6d03b0fd430f186c)
- fix: fix markdown bug in IPCC_UI_TEXT (d3040d364345ed73e9ac1657c5613e1062e728b7)
- chore: added geojson polygon function and custom colorscale per indicator (30f401b002885a71bb62069ec17bd2619f98961e)
- feat: added plot informations for each plot (DRIAS & IPCC) (bdeb1e525e4c80ce990329052a2c172ad9847113)
- feat: updated TTD UI (DRIAS & IPCC) (fdad3be2df6ab94da4b7847a081c3c0c1b67eaf2)
- fix: fixed graphs display bugs (a4206dc31d5e238ee26876faf91473a202eafec1)
- feat: updated sql query for not macro countries in talk to ipcc (ff653468b4f2bfe2e166ad572ca3c91cb5fb986f)
- refactor: changed choropleth map into map (f9508fce0c7db4822b33a8ba95fb048818fd0840)
- feat: changed marker opacity on map plots (7374d87d5c8521f7ff418eb04636558ee6dcfc14)
- chore: added information about grid point mapping to country inside plot information for map (29cf97a04f9def87a065f05139cdb2374b47d07d)
- feat: changed queries for macro countries in talk to ipcc (d0f045617aefd9a28811c567ecda0d1ff70ce548)
- fix: fixed submit bug in talk to drias (01a4939d78358d57f94232827cfe197c22678258)
- feat: added queries on huge countries in talk to ipcc (19905de878ff990f1beff50d76a8eb11541e46b9)
- chore: changed talk to ipcc how to use text (5bd3f8cdd51ef4bbd47b4524ab5406434801a048)
- replace eval by litteral eval (2d6b3b9f22416c157a60ecc2616346dc975d6861)
- fix retrieve documents error for search without reranker (0536821aa63e34759510b5d55505da8df32bae8f)
- Move vanna files in dedicated folder (fa2765ac9a08e5d00439ff752159cf2d22b10d1f)
- move path into config (0695fe4d36575aa5881f981e16897a7bc3a4d45d)
- remove unnecessary imports (819e3c05730ca9e4b1a6526f00d961f1509e3b0d)
- Merged in feature/talk_to_data (pull request #19) (11ab5fbc82c47ac8524b62d4c693eaa376dd149f)
- rename hf_token name (d78ea762bb16187b8755d5c07d90827c10ccf127)
- add lfs images (a9b4fcc0bd5fafd39104eae0074cad2b51bf1341)
- Add PNG assets (11910c77dff6e0795b7cbecb2e692645ef4e14f0)
- Merge hf-origin/main into main (1ed4e25589d82fe195eab13e7249e3889cecac4b)


Co-authored-by: Armand Demasson <[email protected]>

.gitattributes

@@ -45,3 +45,4 @@ documents/climate_gpt_v2.faiss filter=lfs diff=lfs merge=lfs -text
 climateqa_v3.db filter=lfs diff=lfs merge=lfs -text
 climateqa_v3.faiss filter=lfs diff=lfs merge=lfs -text
 data/drias/drias.db filter=lfs diff=lfs merge=lfs -text
+front/assets/*.png filter=lfs diff=lfs merge=lfs -text

app.py

@@ -16,6 +16,10 @@ from climateqa.chat import start_chat, chat_stream, finish_chat
 from front.tabs import create_config_modal, cqa_tab, create_about_tab
 from front.tabs import MainTabPanel, ConfigPanel
 from front.tabs.tab_drias import create_drias_tab
+<<<<<<< HEAD
+from front.tabs.tab_ipcc import create_ipcc_tab
+=======
+>>>>>>> hf-origin/main
 from front.utils import process_figures
 from gradio_modal import Modal
 
@@ -532,8 +536,13 @@ def main_ui():
         with gr.Tabs():
             cqa_components = cqa_tab(tab_name="ClimateQ&A")
             local_cqa_components = cqa_tab(tab_name="France - Local Q&A")
+<<<<<<< HEAD
+            drias_components = create_drias_tab(share_client=share_client, user_id=user_id)
+            ipcc_components = create_ipcc_tab(share_client=share_client, user_id=user_id)
+=======
             create_drias_tab(share_client=share_client, user_id=user_id)
 
+>>>>>>> hf-origin/main
             create_about_tab()
 
         event_handling(cqa_components, config_components, tab_name="ClimateQ&A")

climateqa/engine/chains/retrieve_documents.py

@@ -21,7 +21,7 @@ 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 ast
 
 import asyncio
 
@@ -477,8 +477,10 @@ async def retrieve_documents(
                 docs_question_dict[key] = rerank_and_sort_docs(reranker,docs_question_dict[key],question)
     else:
         # Add a default reranking score
-        for doc in docs_question:
-            doc.metadata["reranking_score"] = doc.metadata["similarity_score"]
+        for key in docs_question_dict.keys():
+            if isinstance(docs_question_dict[key], list) and len(docs_question_dict[key]) > 0:
+                for doc in docs_question_dict[key]:
+                    doc.metadata["reranking_score"] = doc.metadata["similarity_score"]
     
     # Keep the right number of documents    
     docs_question, images_question = concatenate_documents(index, source_type, docs_question_dict, k_by_question, k_summary_by_question, k_images_by_question)
@@ -580,7 +582,7 @@ async def get_relevant_toc_level_for_query(
     response = chain.invoke({"query": query, "doc_list": doc_list})
 
     try: 
-        relevant_tocs = eval(response)
+        relevant_tocs = ast.literal_eval(response)
     except Exception as e:
         print(f" Failed to parse the result because of : {e}")
 

climateqa/engine/talk_to_data/config.py

@@ -1,99 +1,11 @@
-DRIAS_TABLES = [
-    "total_winter_precipitation",
-    "total_summer_precipiation",
-    "total_annual_precipitation",
-    "total_remarkable_daily_precipitation",
-    "frequency_of_remarkable_daily_precipitation",
-    "extreme_precipitation_intensity",
-    "mean_winter_temperature",
-    "mean_summer_temperature",
-    "mean_annual_temperature",
-    "number_of_tropical_nights",
-    "maximum_summer_temperature",
-    "number_of_days_with_tx_above_30",
-    "number_of_days_with_tx_above_35",
-    "number_of_days_with_a_dry_ground",
-]
+# Path configuration for climateqa project
 
-INDICATOR_COLUMNS_PER_TABLE = {
-    "total_winter_precipitation": "total_winter_precipitation",
-    "total_summer_precipiation": "total_summer_precipitation",
-    "total_annual_precipitation": "total_annual_precipitation",
-    "total_remarkable_daily_precipitation": "total_remarkable_daily_precipitation",
-    "frequency_of_remarkable_daily_precipitation": "frequency_of_remarkable_daily_precipitation",
-    "extreme_precipitation_intensity": "extreme_precipitation_intensity",
-    "mean_winter_temperature": "mean_winter_temperature",
-    "mean_summer_temperature": "mean_summer_temperature",
-    "mean_annual_temperature": "mean_annual_temperature",
-    "number_of_tropical_nights": "number_tropical_nights",
-    "maximum_summer_temperature": "maximum_summer_temperature",
-    "number_of_days_with_tx_above_30": "number_of_days_with_tx_above_30",
-    "number_of_days_with_tx_above_35": "number_of_days_with_tx_above_35",
-    "number_of_days_with_a_dry_ground": "number_of_days_with_dry_ground"
-}
+# IPCC dataset path
+IPCC_DATASET_URL = "hf://datasets/ekimetrics/ipcc-atlas"
 
-DRIAS_MODELS = [
-    'ALL',
-    'RegCM4-6_MPI-ESM-LR',
-    'RACMO22E_EC-EARTH',
-    'RegCM4-6_HadGEM2-ES',
-    'HadREM3-GA7_EC-EARTH',
-    'HadREM3-GA7_CNRM-CM5',
-    'REMO2015_NorESM1-M',
-    'SMHI-RCA4_EC-EARTH',
-    'WRF381P_NorESM1-M',
-    'ALADIN63_CNRM-CM5',
-    'CCLM4-8-17_MPI-ESM-LR',
-    'HIRHAM5_IPSL-CM5A-MR',
-    'HadREM3-GA7_HadGEM2-ES',
-    'SMHI-RCA4_IPSL-CM5A-MR',
-    'HIRHAM5_NorESM1-M',
-    'REMO2009_MPI-ESM-LR',
-    'CCLM4-8-17_HadGEM2-ES'
-]
-# Mapping between indicator columns and their units
-INDICATOR_TO_UNIT = {
-    "total_winter_precipitation": "mm",
-    "total_summer_precipitation": "mm",
-    "total_annual_precipitation": "mm",
-    "total_remarkable_daily_precipitation": "mm",
-    "frequency_of_remarkable_daily_precipitation": "days",
-    "extreme_precipitation_intensity": "mm",
-    "mean_winter_temperature": "°C",
-    "mean_summer_temperature": "°C",
-    "mean_annual_temperature": "°C",
-    "number_tropical_nights": "days",
-    "maximum_summer_temperature": "°C",
-    "number_of_days_with_tx_above_30": "days",
-    "number_of_days_with_tx_above_35": "days",
-    "number_of_days_with_dry_ground": "days"
-}
+# DRIAS dataset paths
+DRIAS_DATASET_URL = "hf://datasets/timeki/drias_db"
 
-DRIAS_UI_TEXT = """
-Hi, I'm **Talk to Drias**, designed to answer your questions using [**DRIAS - TRACC 2023**](https://www.drias-climat.fr/accompagnement/sections/401) data.  
-I'll answer by displaying a list of SQL queries, graphs and data most relevant to your question.
-
-❓ **How to use?**  
-You can ask me anything about these climate indicators: **temperature**, **precipitation** or **drought**.  
-You can specify **location** and/or **year**.  
-You can choose from a list of climate models. By default, we take the **average of each model**.
-
-For example, you can ask:  
-- What will the temperature be like in Paris?  
-- What will be the total rainfall in France in 2030?  
-- How frequent will extreme events be in Lyon?  
-
-**Example of indicators in the data**:  
-- Mean temperature (annual, winter, summer)  
-- Total precipitation (annual, winter, summer)  
-- Number of days with remarkable precipitations, with dry ground, with temperature above 30°C  
-
-⚠️ **Limitations**:  
-- You can't ask anything that isn't related to **DRIAS - TRACC 2023** data.  
-- You can only ask about **locations in France**.  
-- If you specify a year, there may be **no data for that year for some models**.  
-- You **cannot compare two models**.  
-
-🛈 **Information**  
-Please note that we **log your questions for meta-analysis purposes**, so avoid sharing any sensitive or personal information.
-"""
+# Table paths
+DRIAS_MEAN_ANNUAL_TEMPERATURE_PATH = f"{DRIAS_DATASET_URL}/mean_annual_temperature.parquet"
+IPCC_COORDINATES_PATH = f"{IPCC_DATASET_URL}/coordinates.parquet"

climateqa/engine/talk_to_data/drias/config.py

@@ -0,0 +1,124 @@
+
+from climateqa.engine.talk_to_data.ui_config import PRECIPITATION_COLORSCALE, TEMPERATURE_COLORSCALE
+
+
+DRIAS_TABLES = [
+    "total_winter_precipitation",
+    "total_summer_precipitation",
+    "total_annual_precipitation",
+    "total_remarkable_daily_precipitation",
+    "frequency_of_remarkable_daily_precipitation",
+    "extreme_precipitation_intensity",
+    "mean_winter_temperature",
+    "mean_summer_temperature",
+    "mean_annual_temperature",
+    "number_of_tropical_nights",
+    "maximum_summer_temperature",
+    "number_of_days_with_tx_above_30",
+    "number_of_days_with_tx_above_35",
+    "number_of_days_with_a_dry_ground",
+]
+
+DRIAS_INDICATOR_COLUMNS_PER_TABLE = {
+    "total_winter_precipitation": "total_winter_precipitation",
+    "total_summer_precipitation": "total_summer_precipitation",
+    "total_annual_precipitation": "total_annual_precipitation",
+    "total_remarkable_daily_precipitation": "total_remarkable_daily_precipitation",
+    "frequency_of_remarkable_daily_precipitation": "frequency_of_remarkable_daily_precipitation",
+    "extreme_precipitation_intensity": "extreme_precipitation_intensity",
+    "mean_winter_temperature": "mean_winter_temperature",
+    "mean_summer_temperature": "mean_summer_temperature",
+    "mean_annual_temperature": "mean_annual_temperature",
+    "number_of_tropical_nights": "number_tropical_nights",
+    "maximum_summer_temperature": "maximum_summer_temperature",
+    "number_of_days_with_tx_above_30": "number_of_days_with_tx_above_30",
+    "number_of_days_with_tx_above_35": "number_of_days_with_tx_above_35",
+    "number_of_days_with_a_dry_ground": "number_of_days_with_dry_ground"
+}
+
+DRIAS_MODELS = [
+    'ALL',
+    'RegCM4-6_MPI-ESM-LR',
+    'RACMO22E_EC-EARTH',
+    'RegCM4-6_HadGEM2-ES',
+    'HadREM3-GA7_EC-EARTH',
+    'HadREM3-GA7_CNRM-CM5',
+    'REMO2015_NorESM1-M',
+    'SMHI-RCA4_EC-EARTH',
+    'WRF381P_NorESM1-M',
+    'ALADIN63_CNRM-CM5',
+    'CCLM4-8-17_MPI-ESM-LR',
+    'HIRHAM5_IPSL-CM5A-MR',
+    'HadREM3-GA7_HadGEM2-ES',
+    'SMHI-RCA4_IPSL-CM5A-MR',
+    'HIRHAM5_NorESM1-M',
+    'REMO2009_MPI-ESM-LR',
+    'CCLM4-8-17_HadGEM2-ES'
+]
+# Mapping between indicator columns and their units
+DRIAS_INDICATOR_TO_UNIT = {
+    "total_winter_precipitation": "mm",
+    "total_summer_precipitation": "mm",
+    "total_annual_precipitation": "mm",
+    "total_remarkable_daily_precipitation": "mm",
+    "frequency_of_remarkable_daily_precipitation": "days",
+    "extreme_precipitation_intensity": "mm",
+    "mean_winter_temperature": "°C",
+    "mean_summer_temperature": "°C",
+    "mean_annual_temperature": "°C",
+    "number_tropical_nights": "days",
+    "maximum_summer_temperature": "°C",
+    "number_of_days_with_tx_above_30": "days",
+    "number_of_days_with_tx_above_35": "days",
+    "number_of_days_with_dry_ground": "days"
+}
+
+DRIAS_PLOT_PARAMETERS = [
+    'year',
+    'location'
+]
+
+DRIAS_INDICATOR_TO_COLORSCALE = {
+    "total_winter_precipitation": PRECIPITATION_COLORSCALE,
+    "total_summer_precipitation": PRECIPITATION_COLORSCALE,
+    "total_annual_precipitation": PRECIPITATION_COLORSCALE,
+    "total_remarkable_daily_precipitation": PRECIPITATION_COLORSCALE,
+    "frequency_of_remarkable_daily_precipitation": PRECIPITATION_COLORSCALE,
+    "extreme_precipitation_intensity": PRECIPITATION_COLORSCALE,
+    "mean_winter_temperature":TEMPERATURE_COLORSCALE,
+    "mean_summer_temperature":TEMPERATURE_COLORSCALE,
+    "mean_annual_temperature":TEMPERATURE_COLORSCALE,
+    "number_tropical_nights": TEMPERATURE_COLORSCALE,
+    "maximum_summer_temperature":TEMPERATURE_COLORSCALE,
+    "number_of_days_with_tx_above_30": TEMPERATURE_COLORSCALE,
+    "number_of_days_with_tx_above_35": TEMPERATURE_COLORSCALE,
+    "number_of_days_with_dry_ground": TEMPERATURE_COLORSCALE
+}
+
+DRIAS_UI_TEXT = """
+Hi, I'm **Talk to Drias**, designed to answer your questions using [**DRIAS - TRACC 2023**](https://www.drias-climat.fr/accompagnement/sections/401) data.  
+I'll answer by displaying a list of SQL queries, graphs and data most relevant to your question.
+
+You can ask me anything about these climate indicators: **temperature**, **precipitation** or **drought**.  
+You can specify **location** and/or **year**.  
+You can choose from a list of climate models. By default, we take the **average of each model**.
+
+For example, you can ask:  
+- What will the temperature be like in Paris?  
+- What will be the total rainfall in France in 2030?  
+- How frequent will extreme events be in Lyon?  
+
+**Example of indicators in the data**:  
+- Mean temperature (annual, winter, summer)  
+- Total precipitation (annual, winter, summer)  
+- Number of days with remarkable precipitations, with dry ground, with temperature above 30°C  
+
+⚠️ **Limitations**:  
+- You can't ask anything that isn't related to **DRIAS - TRACC 2023** data.  
+- You can only ask about **locations in France**.  
+- If you specify a year, there may be **no data for that year for some models**.  
+- You **cannot compare two models**.  
+
+🛈 **Information**  
+Please note that we **log your questions for meta-analysis purposes**, so avoid sharing any sensitive or personal information.
+"""

climateqa/engine/talk_to_data/drias/plot_informations.py

@@ -0,0 +1,88 @@
+from climateqa.engine.talk_to_data.drias.config import DRIAS_INDICATOR_TO_UNIT
+
+def indicator_evolution_informations(
+        indicator: str,
+        params: dict[str, str]
+) -> str:
+    unit = DRIAS_INDICATOR_TO_UNIT[indicator]
+    if "location" not in params:
+        raise ValueError('"location" must be provided in params')
+    location = params["location"]
+    return f"""
+This plot shows how the climate indicator **{indicator}** evolves over time in **{location}**.
+
+It combines both historical observations and future projections according to the climate scenario RCP8.5.
+
+The x-axis represents the years, and the y-axis shows the value of the indicator ({unit}).
+
+A 10-year rolling average curve is displayed to give a better idea of the overall trend.
+
+**Data source:**
+- The data come from the DRIAS TRACC data. The data were initially extracted from [the DRIAS website](https://www.drias-climat.fr/drias_prod/accueil/okapiWebDrias/index.jsp?iddrias=climat) and then preprocessed to a tabular format and uploaded as parquet in this [Hugging Face dataset](https://huggingface.co/datasets/timeki/drias_db).
+- For each year and climate model, the value of {indicator} in {location} is collected, to build the time series.
+- The coordinates used for {location} correspond to the closest available point in the DRIAS database, which uses a regular grid with a spatial resolution of 8 km.
+- The indicator values shown are those for the selected climate model.
+- If ALL climate model is selected, the average value of the indicator between all the climate models is used. 
+"""
+
+def indicator_number_of_days_per_year_informations(
+        indicator: str,
+        params: dict[str, str]
+) -> str:
+    unit = DRIAS_INDICATOR_TO_UNIT[indicator]
+    if "location" not in params:
+        raise ValueError('"location" must be provided in params')
+    location = params["location"]
+    return f"""
+This plot displays a bar chart showing the yearly frequency of the climate indicator **{indicator}** in **{location}**.
+
+The x-axis represents the years, and the y-axis shows the frequency of {indicator} ({unit}) per year.
+
+**Data source:**  
+- The data come from the DRIAS TRACC data. The data were initially extracted from [the DRIAS website](https://www.drias-climat.fr/drias_prod/accueil/okapiWebDrias/index.jsp?iddrias=climat) and then preprocessed to a tabular format and uploaded as parquet in this [Hugging Face dataset](https://huggingface.co/datasets/timeki/drias_db).
+- For each year and climate model, the value of {indicator} in {location} is collected, to build the time series.
+- The coordinates used for {location} correspond to the closest available point in the DRIAS database, which uses a regular grid with a spatial resolution of 8 km.
+- The indicator values shown are those for the selected climate model.
+- If ALL climate model is selected, the average value of the indicator between all the climate models is used. 
+"""
+
+def distribution_of_indicator_for_given_year_informations(
+        indicator: str,
+        params: dict[str, str]
+) -> str:
+    unit = DRIAS_INDICATOR_TO_UNIT[indicator]
+    year = params["year"]
+    if year is None:
+        year = 2030
+    return f"""
+This plot shows a histogram of the distribution of the climate indicator **{indicator}** across all locations for the year **{year}**.
+
+It allows you to visualize how the values of {indicator} ({unit}) are spread for a given year.
+
+**Data source:**  
+- The data come from the DRIAS TRACC data. The data were initially extracted from [the DRIAS website](https://www.drias-climat.fr/drias_prod/accueil/okapiWebDrias/index.jsp?iddrias=climat) and then preprocessed to a tabular format and uploaded as parquet in this [Hugging Face dataset](https://huggingface.co/datasets/timeki/drias_db).
+- For each grid point in the dataset and climate model, the value of {indicator} for the year {year} is extracted.
+- The indicator values shown are those for the selected climate model.
+- If ALL climate model is selected, the average value of the indicator between all the climate models is used. 
+"""
+
+def map_of_france_of_indicator_for_given_year_informations(
+        indicator: str,
+        params: dict[str, str]
+) -> str:
+    unit = DRIAS_INDICATOR_TO_UNIT[indicator]
+    year = params["year"]
+    if year is None:
+        year = 2030
+    return f"""
+This plot displays a choropleth map showing the spatial distribution of **{indicator}** across all regions of France for the year **{year}**.
+
+Each region is colored according to the value of the indicator ({unit}), allowing you to visually compare how {indicator} varies geographically within France for the selected year and climate model.
+
+**Data source:**  
+- The data come from the DRIAS TRACC data. The data were initially extracted from [the DRIAS website](https://www.drias-climat.fr/drias_prod/accueil/okapiWebDrias/index.jsp?iddrias=climat) and then preprocessed to a tabular format and uploaded as parquet in this [Hugging Face dataset](https://huggingface.co/datasets/timeki/drias_db).
+- For each region of France, the value of {indicator} in {year} and for the selected climate model is extracted and mapped to its geographic coordinates.
+- The regions correspond to 8 km squares centered on the grid points of the DRIAS dataset.
+- The indicator values shown are those for the selected climate model.
+- If ALL climate model is selected, the average value of the indicator between all the climate models is used.
+"""

climateqa/engine/talk_to_data/drias/plots.py

@@ -0,0 +1,434 @@
+import os
+import geojson
+from math import cos, radians
+from typing import Callable
+import pandas as pd
+from plotly.graph_objects import Figure
+import plotly.graph_objects as go
+from climateqa.engine.talk_to_data.drias.plot_informations import distribution_of_indicator_for_given_year_informations, indicator_evolution_informations, indicator_number_of_days_per_year_informations, map_of_france_of_indicator_for_given_year_informations
+from climateqa.engine.talk_to_data.objects.plot import Plot
+from climateqa.engine.talk_to_data.drias.queries import (
+    indicator_for_given_year_query,
+    indicator_per_year_at_location_query,
+)
+from climateqa.engine.talk_to_data.drias.config import DRIAS_INDICATOR_TO_COLORSCALE, DRIAS_INDICATOR_TO_UNIT
+
+def generate_geojson_polygons(latitudes: list[float], longitudes: list[float], indicators: list[float]) -> geojson.FeatureCollection:
+    side_km = 8
+    delta_lat = side_km / 111
+    features = []
+    for idx, (lat, lon, val) in enumerate(zip(latitudes, longitudes, indicators)):
+        delta_lon  = side_km / (111 * cos(radians(lat)))
+        half_lat = delta_lat / 2
+        half_lon = delta_lon / 2
+        features.append(geojson.Feature(
+                geometry=geojson.Polygon([[
+                    [lon - half_lon, lat - half_lat],
+                    [lon + half_lon, lat - half_lat],
+                    [lon + half_lon, lat + half_lat],
+                    [lon - half_lon, lat + half_lat],
+                    [lon - half_lon, lat - half_lat]
+                ]]),
+                properties={"value": val},
+                id=str(idx)
+            ))
+
+    return geojson.FeatureCollection(features)
+
+def plot_indicator_evolution_at_location(params: dict) -> Callable[..., Figure]:
+    """Generates a function to plot indicator evolution over time at a location.
+    
+    This function creates a line plot showing how a climate indicator changes
+    over time at a specific location. It handles temperature, precipitation,
+    and other climate indicators.
+    
+    Args:
+        params (dict): Dictionary containing:
+            - indicator_column (str): The column name for the indicator
+            - location (str): The location to plot
+            - model (str): The climate model to use
+            
+    Returns:
+        Callable[..., Figure]: A function that takes a DataFrame and returns a plotly Figure
+        
+    Example:
+        >>> plot_func = plot_indicator_evolution_at_location({
+        ...     'indicator_column': 'mean_temperature',
+        ...     'location': 'Paris',
+        ...     'model': 'ALL'
+        ... })
+        >>> fig = plot_func(df)
+    """
+    indicator = params["indicator_column"]
+    location = params["location"]
+    indicator_label = " ".join([word.capitalize() for word in indicator.split("_")])
+    unit = DRIAS_INDICATOR_TO_UNIT.get(indicator, "")
+
+    def plot_data(df: pd.DataFrame) -> Figure:
+        """Generates the actual plot from the data.
+        
+        Args:
+            df (pd.DataFrame): DataFrame containing the data to plot
+            
+        Returns:
+            Figure: A plotly Figure object showing the indicator evolution
+        """
+        fig = go.Figure()
+        if df['model'].nunique() != 1:
+            df_avg = df.groupby("year", as_index=False)[indicator].mean()
+
+            # Transform to list to avoid pandas encoding
+            indicators = df_avg[indicator].astype(float).tolist()
+            years = df_avg["year"].astype(int).tolist()
+
+            # Compute the 10-year rolling average
+            rolling_window = 10
+            sliding_averages = (
+                df_avg[indicator]
+                .rolling(window=rolling_window, min_periods=rolling_window)
+                .mean()
+                .astype(float)
+                .tolist()
+            )
+            model_label = "Model Average"
+
+            # Only add rolling average if we have enough data points
+            if len([x for x in sliding_averages if pd.notna(x)]) > 0:
+                # Sliding average dashed line
+                fig.add_scatter(
+                    x=years,
+                    y=sliding_averages,
+                    mode="lines",
+                    name="10 years rolling average",
+                    line=dict(dash="dash"),
+                    marker=dict(color="#d62728"),
+                    hovertemplate=f"10-year average: %{{y:.2f}} {unit}<br>Year: %{{x}}<extra></extra>"
+                )
+
+        else:
+            df_model = df
+
+            # Transform to list to avoid pandas encoding
+            indicators = df_model[indicator].astype(float).tolist()
+            years = df_model["year"].astype(int).tolist()
+
+            # Compute the 10-year rolling average
+            rolling_window = 10
+            sliding_averages = (
+                df_model[indicator]
+                .rolling(window=rolling_window, min_periods=rolling_window)
+                .mean()
+                .astype(float)
+                .tolist()
+            )
+            model_label = f"Model : {df['model'].unique()[0]}"
+
+            # Only add rolling average if we have enough data points
+            if len([x for x in sliding_averages if pd.notna(x)]) > 0:
+                # Sliding average dashed line
+                fig.add_scatter(
+                    x=years,
+                    y=sliding_averages,
+                    mode="lines",
+                    name="10 years rolling average",
+                    line=dict(dash="dash"),
+                    marker=dict(color="#d62728"),
+                    hovertemplate=f"10-year average: %{{y:.2f}} {unit}<br>Year: %{{x}}<extra></extra>"
+                )
+
+        # Indicator per year plot
+        fig.add_scatter(
+            x=years,
+            y=indicators,
+            name=f"Yearly {indicator_label}",
+            mode="lines",
+            marker=dict(color="#1f77b4"),
+            hovertemplate=f"{indicator_label}: %{{y:.2f}} {unit}<br>Year: %{{x}}<extra></extra>"
+        )
+        fig.update_layout(
+            title=f"Evolution of {indicator_label} in {location} ({model_label})",
+            xaxis_title="Year",
+            yaxis_title=f"{indicator_label} ({unit})",
+            template="plotly_white",
+            height=900,
+        )
+        return fig
+
+    return plot_data
+
+
+indicator_evolution_at_location: Plot = {
+    "name": "Indicator evolution at location",
+    "description": "Plot an evolution of the indicator at a certain location",
+    "params": ["indicator_column", "location", "model"],
+    "plot_function": plot_indicator_evolution_at_location,
+    "sql_query": indicator_per_year_at_location_query,
+    "plot_information": indicator_evolution_informations,
+    'short_name': 'Evolution'
+}
+
+
+def plot_indicator_number_of_days_per_year_at_location(
+    params: dict,
+) -> Callable[..., Figure]:
+    """Generates a function to plot the number of days per year for an indicator.
+    
+    This function creates a bar chart showing the frequency of certain climate
+    events (like days above a temperature threshold) per year at a specific location.
+    
+    Args:
+        params (dict): Dictionary containing:
+            - indicator_column (str): The column name for the indicator
+            - location (str): The location to plot
+            - model (str): The climate model to use
+            
+    Returns:
+        Callable[..., Figure]: A function that takes a DataFrame and returns a plotly Figure
+    """
+    indicator = params["indicator_column"]
+    location = params["location"]
+    indicator_label = " ".join([word.capitalize() for word in indicator.split("_")])
+    unit = DRIAS_INDICATOR_TO_UNIT.get(indicator, "")
+
+    def plot_data(df: pd.DataFrame) -> Figure:
+        """Generate the figure thanks to the dataframe
+
+        Args:
+            df (pd.DataFrame): pandas dataframe with the required data
+
+        Returns:
+            Figure: Plotly figure
+        """
+        fig = go.Figure()
+        if df['model'].nunique() != 1:
+            df_avg = df.groupby("year", as_index=False)[indicator].mean()
+
+            # Transform to list to avoid pandas encoding
+            indicators = df_avg[indicator].astype(float).tolist()
+            years = df_avg["year"].astype(int).tolist()
+            model_label = "Model Average"
+
+        else:
+            df_model = df
+            # Transform to list to avoid pandas encoding
+            indicators = df_model[indicator].astype(float).tolist()
+            years = df_model["year"].astype(int).tolist()
+            model_label = f"Model : {df['model'].unique()[0]}"
+
+
+        # Bar plot
+        fig.add_trace(
+            go.Bar(
+                x=years,
+                y=indicators,
+                width=0.5,
+                marker=dict(color="#1f77b4"),
+                hovertemplate=f"{indicator_label}: %{{y:.2f}} {unit}<br>Year: %{{x}}<extra></extra>"
+            )
+        )
+
+        fig.update_layout(
+            title=f"{indicator_label} in {location} ({model_label})",
+            xaxis_title="Year",
+            yaxis_title=f"{indicator_label} ({unit})",
+            yaxis=dict(range=[0, max(indicators)]),
+            bargap=0.5,
+            height=900,
+            template="plotly_white",
+        )
+
+        return fig
+
+    return plot_data
+
+
+indicator_number_of_days_per_year_at_location: Plot = {
+    "name": "Indicator number of days per year at location",
+    "description": "Plot a barchart of the number of days per year of a certain indicator at a certain location. It is appropriate for frequency indicator.",
+    "params": ["indicator_column", "location", "model"],
+    "plot_function": plot_indicator_number_of_days_per_year_at_location,
+    "sql_query": indicator_per_year_at_location_query,
+    "plot_information": indicator_number_of_days_per_year_informations,
+    "short_name": "Yearly Frequency",
+}
+
+
+def plot_distribution_of_indicator_for_given_year(
+    params: dict,
+) -> Callable[..., Figure]:
+    """Generates a function to plot the distribution of an indicator for a year.
+    
+    This function creates a histogram showing the distribution of a climate
+    indicator across different locations for a specific year.
+    
+    Args:
+        params (dict): Dictionary containing:
+            - indicator_column (str): The column name for the indicator
+            - year (str): The year to plot
+            - model (str): The climate model to use
+            
+    Returns:
+        Callable[..., Figure]: A function that takes a DataFrame and returns a plotly Figure
+    """
+    indicator = params["indicator_column"]
+    year = params["year"]
+    if year is None:
+        year = 2030
+    indicator_label = " ".join([word.capitalize() for word in indicator.split("_")])
+    unit = DRIAS_INDICATOR_TO_UNIT.get(indicator, "")
+
+    def plot_data(df: pd.DataFrame) -> Figure:
+        """Generate the figure thanks to the dataframe
+
+        Args:
+            df (pd.DataFrame): pandas dataframe with the required data
+
+        Returns:
+            Figure: Plotly figure
+        """
+        fig = go.Figure()
+        if df['model'].nunique() != 1:
+            df_avg = df.groupby(["latitude", "longitude"], as_index=False)[
+                indicator
+            ].mean()
+
+            # Transform to list to avoid pandas encoding
+            indicators = df_avg[indicator].astype(float).tolist()
+            model_label = "Model Average"
+
+        else:
+            df_model = df
+
+            # Transform to list to avoid pandas encoding
+            indicators = df_model[indicator].astype(float).tolist()
+            model_label = f"Model : {df['model'].unique()[0]}"
+
+
+        fig.add_trace(
+            go.Histogram(
+                x=indicators,
+                opacity=0.8,
+                histnorm="percent",
+                marker=dict(color="#1f77b4"),
+                hovertemplate=f"{indicator_label}: %{{x:.2f}} {unit}<br>Frequency: %{{y:.2f}}%<extra></extra>"
+            )
+        )
+
+        fig.update_layout(
+            title=f"Distribution of {indicator_label} in {year} ({model_label})",
+            xaxis_title=f"{indicator_label} ({unit})",
+            yaxis_title="Frequency (%)",
+            plot_bgcolor="rgba(0, 0, 0, 0)",
+            showlegend=False,
+            height=900,
+        )
+
+        return fig
+
+    return plot_data
+
+
+distribution_of_indicator_for_given_year: Plot = {
+    "name": "Distribution of an indicator for a given year",
+    "description": "Plot an histogram of the distribution for a given year of the values of an indicator",
+    "params": ["indicator_column", "model", "year"],
+    "plot_function": plot_distribution_of_indicator_for_given_year,
+    "sql_query": indicator_for_given_year_query,
+    "plot_information": distribution_of_indicator_for_given_year_informations,
+    'short_name': 'Distribution'
+}
+
+
+def plot_map_of_france_of_indicator_for_given_year(
+    params: dict,
+) -> Callable[..., Figure]:
+    """Generates a function to plot a map of France for an indicator.
+    
+    This function creates a choropleth map of France showing the spatial
+    distribution of a climate indicator for a specific year.
+    
+    Args:
+        params (dict): Dictionary containing:
+            - indicator_column (str): The column name for the indicator
+            - year (str): The year to plot
+            - model (str): The climate model to use
+            
+    Returns:
+        Callable[..., Figure]: A function that takes a DataFrame and returns a plotly Figure
+    """
+    indicator = params["indicator_column"]
+    year = params["year"]
+    if year is None:
+        year = 2030
+    indicator_label = " ".join([word.capitalize() for word in indicator.split("_")])
+    unit = DRIAS_INDICATOR_TO_UNIT.get(indicator, "")
+
+    def plot_data(df: pd.DataFrame) -> Figure:
+        fig = go.Figure()
+        if df['model'].nunique() != 1:
+            df_avg = df.groupby(["latitude", "longitude"], as_index=False)[
+                indicator
+            ].mean()
+
+            indicators = df_avg[indicator].astype(float).tolist()
+            latitudes = df_avg["latitude"].astype(float).tolist()
+            longitudes = df_avg["longitude"].astype(float).tolist()
+            model_label = "Model Average"
+
+        else:
+            df_model = df
+
+            # Transform to list to avoid pandas encoding
+            indicators = df_model[indicator].astype(float).tolist()
+            latitudes = df_model["latitude"].astype(float).tolist()
+            longitudes = df_model["longitude"].astype(float).tolist()
+            model_label = f"Model : {df['model'].unique()[0]}"
+
+
+
+        geojson_data = generate_geojson_polygons(latitudes, longitudes, indicators)
+
+        fig = go.Figure(go.Choroplethmapbox(
+            geojson=geojson_data,
+            locations=[str(i) for i in range(len(indicators))],
+            featureidkey="id",
+            z=indicators,
+            colorscale=DRIAS_INDICATOR_TO_COLORSCALE[indicator],
+            zmin=min(indicators),
+            zmax=max(indicators),
+            marker_opacity=0.7,
+            marker_line_width=0,
+            colorbar_title=f"{indicator_label} ({unit})",
+            text=[f"{indicator_label}: {value:.2f} {unit}" for value in indicators],  # Add hover text showing the indicator value
+            hoverinfo="text" 
+        ))
+
+        fig.update_layout(
+            mapbox_style="open-street-map",  # Use OpenStreetMap
+            mapbox_zoom=5,
+            height=900,
+            mapbox_center={"lat": 46.6, "lon": 2.0},
+            coloraxis_colorbar=dict(title=f"{indicator_label} ({unit})"),  # Add legend
+            title=f"{indicator_label} in {year} in France ({model_label}) " # Title
+        )
+        return fig
+
+    return plot_data
+
+
+map_of_france_of_indicator_for_given_year: Plot = {
+    "name": "Map of France of an indicator for a given year",
+    "description": "Heatmap on the map of France of the values of an indicator for a given year",
+    "params": ["indicator_column", "year", "model"],
+    "plot_function": plot_map_of_france_of_indicator_for_given_year,
+    "sql_query": indicator_for_given_year_query,
+    "plot_information": map_of_france_of_indicator_for_given_year_informations,
+    'short_name': 'Map of France'
+}
+
+DRIAS_PLOTS = [
+    indicator_evolution_at_location,
+    indicator_number_of_days_per_year_at_location,
+    distribution_of_indicator_for_given_year,
+    map_of_france_of_indicator_for_given_year,
+]

climateqa/engine/talk_to_data/drias/queries.py

@@ -0,0 +1,83 @@
+from typing import TypedDict
+from climateqa.engine.talk_to_data.config import DRIAS_DATASET_URL
+
+class IndicatorPerYearAtLocationQueryParams(TypedDict, total=False):
+    """Parameters for querying an indicator's values over time at a location.
+    
+    This class defines the parameters needed to query climate indicator data
+    for a specific location over multiple years.
+    
+    Attributes:
+        indicator_column (str): The column name for the climate indicator
+        latitude (str): The latitude coordinate of the location
+        longitude (str): The longitude coordinate of the location
+        model (str): The climate model to use (optional)
+    """
+    indicator_column: str
+    latitude: str
+    longitude: str
+    model: str
+
+def indicator_per_year_at_location_query(
+    table: str, params: IndicatorPerYearAtLocationQueryParams
+) -> str:
+    """SQL Query to get the evolution of an indicator per year at a certain location
+
+    Args:
+        table (str): sql table of the indicator
+        params (IndicatorPerYearAtLocationQueryParams) : dictionary with the required params for the query
+
+    Returns:
+        str: the sql query
+    """
+    indicator_column = params.get("indicator_column")
+    latitude = params.get("latitude")
+    longitude = params.get("longitude")
+    
+    if indicator_column is None or latitude is None or longitude is None: # If one parameter is missing, returns an empty query
+        return ""
+    
+    table = f"'{DRIAS_DATASET_URL}/{table.lower()}.parquet'"
+
+    sql_query = f"SELECT year, {indicator_column}, model\nFROM {table}\nWHERE latitude = {latitude} \nAnd longitude = {longitude} \nOrder by Year"
+
+    return sql_query
+
+class IndicatorForGivenYearQueryParams(TypedDict, total=False):
+    """Parameters for querying an indicator's values across locations for a year.
+    
+    This class defines the parameters needed to query climate indicator data
+    across different locations for a specific year.
+    
+    Attributes:
+        indicator_column (str): The column name for the climate indicator
+        year (str): The year to query
+        model (str): The climate model to use (optional)
+    """
+    indicator_column: str
+    year: str
+    model: str
+
+def indicator_for_given_year_query(
+        table:str, params: IndicatorForGivenYearQueryParams 
+) -> str:
+    """SQL Query to get the values of an indicator with their latitudes, longitudes and models for a given year
+
+    Args:
+        table (str): sql table of the indicator
+        params (IndicatorForGivenYearQueryParams): dictionarry with the required params for the query
+
+    Returns:
+        str: the sql query
+    """
+    indicator_column = params.get("indicator_column")
+    year = params.get('year')
+    if year is None:
+        year = 2050
+    if year is None or indicator_column is None: # If one parameter is missing, returns an empty query
+        return ""
+    
+    table = f"'{DRIAS_DATASET_URL}/{table.lower()}.parquet'"
+
+    sql_query = f"Select {indicator_column}, latitude, longitude, model\nFrom {table}\nWhere year = {year}"
+    return sql_query    

climateqa/engine/talk_to_data/input_processing.py

@@ -0,0 +1,257 @@
+from typing import Any, Literal, Optional, cast
+import ast
+from langchain_core.prompts import ChatPromptTemplate
+from geopy.geocoders import Nominatim
+from climateqa.engine.llm import get_llm
+import duckdb
+import os 
+from climateqa.engine.talk_to_data.config import DRIAS_MEAN_ANNUAL_TEMPERATURE_PATH, IPCC_COORDINATES_PATH
+from climateqa.engine.talk_to_data.objects.llm_outputs import ArrayOutput
+from climateqa.engine.talk_to_data.objects.location import Location
+from climateqa.engine.talk_to_data.objects.plot import Plot
+from climateqa.engine.talk_to_data.objects.states import State
+
+async def detect_location_with_openai(sentence: str) -> str:
+    """
+    Detects locations in a sentence using OpenAI's API via LangChain.
+    """
+    llm = get_llm()
+
+    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 = await llm.ainvoke(prompt)
+    location_list = ast.literal_eval(response.content.strip("```python\n").strip())
+    if location_list:
+        return location_list[0]
+    else:
+        return ""
+
+def loc_to_coords(location: str) -> tuple[float, float]:
+    """Converts a location name to geographic coordinates.
+    
+    This function uses the Nominatim geocoding service to convert
+    a location name (e.g., city name) to its latitude and longitude.
+    
+    Args:
+        location (str): The name of the location to geocode
+        
+    Returns:
+        tuple[float, float]: A tuple containing (latitude, longitude)
+        
+    Raises:
+        AttributeError: If the location cannot be found
+    """
+    geolocator = Nominatim(user_agent="city_to_latlong")
+    coords = geolocator.geocode(location)
+    return (coords.latitude, coords.longitude)
+
+def coords_to_country(coords: tuple[float, float]) -> tuple[str,str]:
+    """Converts geographic coordinates to a country name.
+    
+    This function uses the Nominatim reverse geocoding service to convert
+    latitude and longitude coordinates to a country name.
+    
+    Args:
+        coords (tuple[float, float]): A tuple containing (latitude, longitude)
+        
+    Returns:
+        tuple[str,str]: A tuple containg (country_code, country_name, admin1)
+        
+    Raises:
+        AttributeError: If the coordinates cannot be found
+    """
+    geolocator = Nominatim(user_agent="latlong_to_country")
+    location = geolocator.reverse(coords)
+    address = location.raw['address']
+    return address['country_code'].upper(), address['country']
+
+def nearest_neighbour_sql(location: tuple, mode: Literal['DRIAS', 'IPCC']) -> tuple[str, str, Optional[str]]:
+    long = round(location[1], 3)
+    lat = round(location[0], 3)
+    conn = duckdb.connect()
+
+    if mode == 'DRIAS':
+        table_path = f"'{DRIAS_MEAN_ANNUAL_TEMPERATURE_PATH}'"
+        results = conn.sql(
+            f"SELECT latitude, longitude FROM {table_path} WHERE latitude BETWEEN {lat - 0.3} AND {lat + 0.3} AND longitude BETWEEN {long - 0.3} AND {long + 0.3}"
+        ).fetchdf()
+    else:
+        table_path = f"'{IPCC_COORDINATES_PATH}'"
+        results = conn.sql(
+            f"SELECT latitude, longitude, admin1 FROM {table_path} WHERE latitude BETWEEN {lat - 0.5} AND {lat + 0.5} AND longitude BETWEEN {long - 0.5} AND {long + 0.5}"
+        ).fetchdf()
+    
+
+    if len(results) == 0:
+        return "", "", ""
+
+    if 'admin1' in results.columns:
+        admin1 = results['admin1'].iloc[0]
+    else:
+        admin1 = None
+    return results['latitude'].iloc[0], results['longitude'].iloc[0], admin1
+
+async def detect_year_with_openai(sentence: str) -> str:
+    """
+    Detects years in a sentence using OpenAI's API via LangChain.
+    """
+    llm = get_llm()
+
+    prompt = """
+    Extract all years mentioned in the following sentence.
+    Return the result as a Python list. If no year are mentioned, return an empty list.
+    
+    Sentence: "{sentence}"
+    """
+
+    prompt = ChatPromptTemplate.from_template(prompt)
+    structured_llm = llm.with_structured_output(ArrayOutput)
+    chain = prompt | structured_llm
+    response: ArrayOutput = await chain.ainvoke({"sentence": sentence})
+    years_list = ast.literal_eval(response['array'])
+    if len(years_list) > 0:
+        return years_list[0]
+    else:
+        return ""
+    
+
+async def detect_relevant_tables(user_question: str, plot: Plot, llm, table_names_list: list[str]) -> list[str]:
+    """Identifies relevant tables for a plot based on user input.
+    
+    This function uses an LLM to analyze the user's question and the plot
+    description to determine which tables in the DRIAS database would be
+    most relevant for generating the requested visualization.
+    
+    Args:
+        user_question (str): The user's question about climate data
+        plot (Plot): The plot configuration object
+        llm: The language model instance to use for analysis
+        
+    Returns:
+        list[str]: A list of table names that are relevant for the plot
+        
+    Example:
+        >>> detect_relevant_tables(
+        ...     "What will the temperature be like in Paris?",
+        ...     indicator_evolution_at_location,
+        ...     llm
+        ... )
+        ['mean_annual_temperature', 'mean_summer_temperature']
+    """
+    # Get all table names
+
+    prompt = (
+        f"You are helping to build a plot following this description : {plot['description']}."
+        f"You are given a list of tables and a user question."
+        f"Based on the description of the plot, which table are appropriate for that kind of plot."
+        f"Write the 3 most relevant tables to use. Answer only a python list of table name."
+        f"### List of tables : {table_names_list}"
+        f"### User question : {user_question}"
+        f"### List of table name : "
+    )
+
+    table_names = ast.literal_eval(
+        (await llm.ainvoke(prompt)).content.strip("```python\n").strip()
+    )
+    return table_names
+
+async def detect_relevant_plots(user_question: str, llm, plot_list: list[Plot]) -> list[str]:
+    plots_description = ""
+    for plot in plot_list:
+        plots_description += "Name: " + plot["name"]
+        plots_description += " - Description: " + plot["description"] + "\n"
+
+    prompt = (
+        "You are helping to answer a question with insightful visualizations.\n"
+        "You are given a user question and a list of plots with their name and description.\n"
+        "Based on the descriptions of the plots, select ALL plots that could provide a useful answer to this question. "
+        "Include any plot that could show relevant information, even if their perspectives (such as time series or spatial distribution) are different.\n"
+        "For example, for a question like 'What will be the total rainfall in China in 2050?', both a time series plot and a spatial map plot could be relevant.\n"
+        "Return only a Python list of plot names sorted from the most relevant one to the less relevant one.\n"
+        f"### Descriptions of the plots : {plots_description}"
+        f"### User question : {user_question}\n"
+        f"### Names of the plots : "
+    )
+
+    plot_names = ast.literal_eval(
+        (await llm.ainvoke(prompt)).content.strip("```python\n").strip()
+    )
+    return plot_names
+
+async def find_location(user_input: str, mode: Literal['DRIAS', 'IPCC'] = 'DRIAS') -> Location:
+    print(f"---- Find location in user input ----")
+    location = await detect_location_with_openai(user_input)
+    output: Location = {
+        'location' : location,
+        'longitude' : None,
+        'latitude' : None,
+        'country_code' : None,
+        'country_name' : None,
+        'admin1' : None
+        }
+    
+    if location:
+        coords = loc_to_coords(location)
+        country_code, country_name = coords_to_country(coords)
+        neighbour = nearest_neighbour_sql(coords, mode)
+        output.update({
+            "latitude": neighbour[0],
+            "longitude": neighbour[1],
+            "country_code": country_code,
+            "country_name": country_name,
+            "admin1": neighbour[2]
+        })
+    output = cast(Location, output)
+    return output
+
+async def find_year(user_input: str) -> str| None:
+    """Extracts year information from user input using LLM.
+    
+    This function uses an LLM to identify and extract year information from the
+    user's query, which is used to filter data in subsequent queries.
+    
+    Args:
+        user_input (str): The user's query text
+        
+    Returns:
+        str: The extracted year, or empty string if no year found
+    """
+    print(f"---- Find year ---")
+    year = await detect_year_with_openai(user_input)
+    if year == "":
+        return None
+    return year
+
+async def find_relevant_plots(state: State, llm, plots: list[Plot]) -> list[str]:
+    print("---- Find relevant plots ----")
+    relevant_plots = await detect_relevant_plots(state['user_input'], llm, plots)
+    return relevant_plots
+
+async def find_relevant_tables_per_plot(state: State, plot: Plot, llm, tables: list[str]) -> list[str]:
+    print(f"---- Find relevant tables for {plot['name']} ----")
+    relevant_tables = await detect_relevant_tables(state['user_input'], plot, llm, tables)
+    return relevant_tables
+
+async def find_param(state: State, param_name:str, mode: Literal['DRIAS', 'IPCC'] = 'DRIAS') -> dict[str, Optional[str]] | Location | None:
+    """Perform the good method to retrieve the desired parameter
+
+    Args:
+        state (State): state of the workflow
+        param_name (str): name of the desired parameter
+        table (str): name of the table
+
+    Returns:
+        dict[str, Any] | None: 
+    """
+    if param_name == 'location':
+        location = await find_location(state['user_input'], mode)
+        return location
+    if param_name == 'year':
+        year = await find_year(state['user_input'])
+        return {'year': year}
+    return None

climateqa/engine/talk_to_data/ipcc/config.py

@@ -0,0 +1,98 @@
+from climateqa.engine.talk_to_data.ui_config import PRECIPITATION_COLORSCALE, TEMPERATURE_COLORSCALE
+from climateqa.engine.talk_to_data.config import IPCC_DATASET_URL
+
+
+# IPCC_DATASET_URL = "hf://datasets/ekimetrics/ipcc-atlas"
+IPCC_TABLES = [
+    "mean_temperature",
+    "total_precipitation",
+]
+
+IPCC_INDICATOR_COLUMNS_PER_TABLE = {
+    "mean_temperature": "mean_temperature",
+    "total_precipitation": "total_precipitation"
+}
+
+IPCC_INDICATOR_TO_UNIT = {
+    "mean_temperature": "°C",
+    "total_precipitation": "mm/day"
+}
+
+IPCC_SCENARIO = [
+    "historical",
+    "ssp126",
+    "ssp245",
+    "ssp370",
+    "ssp585",
+]
+
+IPCC_MODELS = []
+
+IPCC_PLOT_PARAMETERS = [
+    'year',
+    'location'
+]
+
+MACRO_COUNTRIES = ['JP',
+ 'IN',
+ 'MH',
+ 'PT',
+ 'ID',
+ 'SJ',
+ 'MX',
+ 'CN',
+ 'GL',
+ 'PN',
+ 'AR',
+ 'AQ',
+ 'PF',
+ 'BR',
+ 'SH',
+ 'GS',
+ 'ZA',
+ 'NZ',
+ 'TF',
+]
+
+HUGE_MACRO_COUNTRIES = ['CL',
+ 'CA',
+ 'AU',
+ 'US',
+ 'RU'
+]
+
+IPCC_INDICATOR_TO_COLORSCALE = {
+    "mean_temperature": TEMPERATURE_COLORSCALE,
+    "total_precipitation": PRECIPITATION_COLORSCALE
+}
+
+IPCC_UI_TEXT = """
+Hi, I'm **Talk to IPCC**, designed to answer your questions using [**IPCC - ATLAS**](https://interactive-atlas.ipcc.ch/regional-information#eyJ0eXBlIjoiQVRMQVMiLCJjb21tb25zIjp7ImxhdCI6OTc3MiwibG5nIjo0MDA2OTIsInpvb20iOjQsInByb2oiOiJFUFNHOjU0MDMwIiwibW9kZSI6ImNvbXBsZXRlX2F0bGFzIn0sInByaW1hcnkiOnsic2NlbmFyaW8iOiJzc3A1ODUiLCJwZXJpb2QiOiIyIiwic2Vhc29uIjoieWVhciIsImRhdGFzZXQiOiJDTUlQNiIsInZhcmlhYmxlIjoidGFzIiwidmFsdWVUeXBlIjoiQU5PTUFMWSIsImhhdGNoaW5nIjoiU0lNUExFIiwicmVnaW9uU2V0IjoiYXI2IiwiYmFzZWxpbmUiOiJwcmVJbmR1c3RyaWFsIiwicmVnaW9uc1NlbGVjdGVkIjpbXX0sInBsb3QiOnsiYWN0aXZlVGFiIjoicGx1bWUiLCJtYXNrIjoibm9uZSIsInNjYXR0ZXJZTWFnIjpudWxsLCJzY2F0dGVyWVZhciI6bnVsbCwic2hvd2luZyI6ZmFsc2V9fQ==) data.  
+I'll answer by displaying a list of SQL queries, graphs and data most relevant to your question.
+
+You can ask me anything about these climate indicators: **temperature** or **precipitation**.  
+You can specify **location** and/or **year**.  
+By default, we take the **mediane of each climate model**.
+
+Current available charts : 
+- Yearly evolution of an indicator at a specific location (historical + SSP Projections)
+- Yearly spatial distribution of an indicator in a specific country 
+
+Current available indicators :
+- Mean temperature 
+- Total precipitation
+
+For example, you can ask:  
+- What will the temperature be like in Paris?  
+- What will be the total rainfall in the USA in 2030?  
+- How will the average temperature evolve in China ? 
+
+⚠️ **Limitations**:  
+- You can't ask anything that isn't related to **IPCC - ATLAS** data.  
+- You can not ask about **several locations at the same time**.  
+- If you specify a year **before 1850 or over 2100**, there will be **no data**.  
+- You **cannot compare two models**.  
+
+🛈 **Information**  
+Please note that we **log your questions for meta-analysis purposes**, so avoid sharing any sensitive or personal information.
+"""

climateqa/engine/talk_to_data/ipcc/plot_informations.py

@@ -0,0 +1,50 @@
+from climateqa.engine.talk_to_data.ipcc.config import IPCC_INDICATOR_TO_UNIT
+
+def indicator_evolution_informations(
+        indicator: str,
+        params: dict[str,str],
+) -> str:
+    if "location" not in params:
+        raise ValueError('"location" must be provided in params')
+    location = params["location"]
+
+    unit = IPCC_INDICATOR_TO_UNIT[indicator]
+    return f"""
+This plot shows how the climate indicator **{indicator}** evolves over time in **{location}**.
+
+It combines both historical (from 1950 to 2015) observations and future (from 2016 to 2100) projections for the different SSP climate scenarios (SSP126, SSP245, SSP370 and SSP585).
+
+The x-axis represents the years (from 1950 to 2100), and the y-axis shows the value of the {indicator} ({unit}).
+
+Each line corresponds to a different scenario, allowing you to compare how {indicator} might change under various future conditions.
+
+**Data source:**  
+- The data comes from the CMIP6 IPCC ATLAS data. The data were initially extracted from [this referenced website](https://digital.csic.es/handle/10261/332744) and then preprocessed to a tabular format and uploaded as parquet in this [Hugging Face dataset](https://huggingface.co/datasets/Ekimetrics/ipcc-atlas).
+- The underlying data is retrieved by aggregating yearly values of {indicator} for the selected location, across all available scenarios. This means the system collects, for each year, the value of {indicator} in {location}, both for the historical period and for each scenario, to build the time series.
+- The coordinates used for {location} correspond to the closest available point in the IPCC database, which uses a regular grid with a spatial resolution of 1 degree.
+"""
+
+def choropleth_map_informations(
+        indicator: str,
+        params: dict[str, str],
+) -> str:
+    unit = IPCC_INDICATOR_TO_UNIT[indicator]
+    if "location" not in params:
+        raise ValueError('"location" must be provided in params')
+    location = params["location"]
+    country_name = params["country_name"]
+    year = params["year"]
+    if year is None:
+        year = 2050
+
+    return f"""
+This plot displays a choropleth map showing the spatial distribution of **{indicator}** across all regions of **{location}** country ({country_name}) for the year **{year}** and the chosen scenario.
+
+Each grid point is colored according to the value of the indicator ({unit}), allowing you to visually compare how {indicator} varies geographically within the country for the selected year and scenario.
+
+**Data source:**  
+- The data come from the CMIP6 IPCC ATLAS data. The data were initially extracted from [this referenced website](https://digital.csic.es/handle/10261/332744) and then preprocessed to a tabular format and uploaded as parquet in this [Hugging Face dataset](https://huggingface.co/datasets/Ekimetrics/ipcc-atlas).
+- For each grid point of {location} country ({country_name}), the value of {indicator} in {year} and for the selected scenario is extracted and mapped to its geographic coordinates.
+- The grid points correspond to 1-degree squares centered on the grid points of the IPCC dataset. Each grid point has been mapped to a country using [**reverse_geocoder**](https://github.com/thampiman/reverse-geocoder). 
+- The coordinates used for each region are those of the closest available grid point in the IPCC database, which uses a regular grid with a spatial resolution of 1 degree.
+"""

climateqa/engine/talk_to_data/ipcc/plots.py

@@ -0,0 +1,189 @@
+from typing import Callable
+from plotly.graph_objects import Figure
+import plotly.graph_objects as go
+import pandas as pd
+import geojson
+
+from climateqa.engine.talk_to_data.ipcc.config import IPCC_INDICATOR_TO_COLORSCALE, IPCC_INDICATOR_TO_UNIT, IPCC_SCENARIO
+from climateqa.engine.talk_to_data.ipcc.plot_informations import choropleth_map_informations, indicator_evolution_informations
+from climateqa.engine.talk_to_data.ipcc.queries import indicator_for_given_year_query, indicator_per_year_at_location_query
+from climateqa.engine.talk_to_data.objects.plot import Plot
+
+def generate_geojson_polygons(latitudes: list[float], longitudes: list[float], indicators: list[float]) -> geojson.FeatureCollection:
+    features = [
+        geojson.Feature(
+            geometry=geojson.Polygon([[
+                [lon - 0.5, lat - 0.5],
+                [lon + 0.5, lat - 0.5],
+                [lon + 0.5, lat + 0.5],
+                [lon - 0.5, lat + 0.5],
+                [lon - 0.5, lat - 0.5]
+            ]]),
+            properties={"value": val},
+            id=str(idx)
+        )
+        for idx, (lat, lon, val) in enumerate(zip(latitudes, longitudes, indicators))
+    ]
+
+    geojson_data = geojson.FeatureCollection(features)
+    return geojson_data
+
+def plot_indicator_evolution_at_location_historical_and_projections(
+    params: dict,
+) -> Callable[[pd.DataFrame], Figure]:
+    """
+    Returns a function that generates a line plot showing the evolution of a climate indicator
+    (e.g., temperature, rainfall) over time at a specific location, including both historical data
+    and future projections for different climate scenarios.
+
+    Args:
+        params (dict): Dictionary with:
+            - indicator_column (str): Name of the climate indicator column to plot.
+            - location (str): Location (e.g., country, city) for which to plot the indicator.
+
+    Returns:
+        Callable[[pd.DataFrame], Figure]: Function that takes a DataFrame and returns a Plotly Figure
+        showing the indicator's evolution over time, with scenario lines and historical data.
+    """
+    indicator = params["indicator_column"]
+    location = params["location"]
+    indicator_label = " ".join(word.capitalize() for word in indicator.split("_"))
+    unit = IPCC_INDICATOR_TO_UNIT.get(indicator, "")
+
+    def plot_data(df: pd.DataFrame) -> Figure:
+        df = df.sort_values(by='year')
+        years = df['year'].astype(int).tolist()
+        indicators = df[indicator].astype(float).tolist()
+        scenarios = df['scenario'].astype(str).tolist()
+
+        # Find last historical value for continuity
+        last_historical = [(y, v) for y, v, s in zip(years, indicators, scenarios) if s == 'historical']
+        last_historical_year, last_historical_indicator = last_historical[-1] if last_historical else (None, None)
+
+        fig = go.Figure()
+        for scenario in IPCC_SCENARIO:
+            x = [y for y, s in zip(years, scenarios) if s == scenario]
+            y = [v for v, s in zip(indicators, scenarios) if s == scenario]
+            # Connect historical to scenario
+            if scenario != 'historical' and last_historical_indicator is not None:
+                x = [last_historical_year] + x
+                y = [last_historical_indicator] + y
+            fig.add_trace(go.Scatter(
+                x=x,
+                y=y,
+                mode='lines',
+                name=scenario
+            ))
+
+        fig.update_layout(
+            title=f'Yearly Evolution of {indicator_label} in {location} (Historical + SSP Scenarios)',
+            xaxis_title='Year',
+            yaxis_title=f'{indicator_label} ({unit})',
+            legend_title='Scenario',
+            height=800,
+        )
+        return fig
+
+    return plot_data
+
+indicator_evolution_at_location_historical_and_projections: Plot = {
+    "name": "Indicator Evolution at Location (Historical + Projections)",
+    "description": (
+        "Shows how a climate indicator (e.g., rainfall, temperature) changes over time at a specific location, "
+        "including historical data and future projections. "
+        "Useful for questions about the value or trend of an indicator at a location for any year, "
+        "such as 'What will be the total rainfall in China in 2050?' or 'How does rainfall evolve in China over time?'. "
+        "Parameters: indicator_column (the climate variable), location (e.g., country, city)."
+    ),
+    "params": ["indicator_column", "location"],
+    "plot_function": plot_indicator_evolution_at_location_historical_and_projections,
+    "sql_query": indicator_per_year_at_location_query,
+    "plot_information": indicator_evolution_informations,
+    "short_name": "Evolution"
+}
+
+def plot_choropleth_map_of_country_indicator_for_specific_year(
+    params: dict,
+) -> Callable[[pd.DataFrame], Figure]:
+    """
+    Returns a function that generates a choropleth map (heatmap) showing the spatial distribution
+    of a climate indicator (e.g., temperature, rainfall) across all regions of a country for a specific year.
+
+    Args:
+        params (dict): Dictionary with:
+            - indicator_column (str): Name of the climate indicator column to plot.
+            - year (str or int, optional): Year for which to plot the indicator (default: 2050).
+            - country_name (str): Name of the country.
+            - location (str): Location (country or region) for the map.
+
+    Returns:
+        Callable[[pd.DataFrame], Figure]: Function that takes a DataFrame and returns a Plotly Figure
+        showing the indicator's spatial distribution as a choropleth map for the specified year.
+    """
+    indicator = params["indicator_column"]
+    year = params.get('year')
+    if year is None: 
+        year = 2050
+    country_name = params['country_name']
+    location = params['location']
+    indicator_label = " ".join(word.capitalize() for word in indicator.split("_"))
+    unit = IPCC_INDICATOR_TO_UNIT.get(indicator, "")
+
+    def plot_data(df: pd.DataFrame) -> Figure:
+
+        indicators = df[indicator].astype(float).tolist()
+        latitudes = df["latitude"].astype(float).tolist()
+        longitudes = df["longitude"].astype(float).tolist()
+
+        geojson_data = generate_geojson_polygons(latitudes, longitudes, indicators)
+
+        fig = go.Figure(go.Choroplethmapbox(
+            geojson=geojson_data,
+            locations=[str(i) for i in range(len(indicators))],
+            featureidkey="id",
+            z=indicators,
+            colorscale=IPCC_INDICATOR_TO_COLORSCALE[indicator],
+            zmin=min(indicators),
+            zmax=max(indicators),
+            marker_opacity=0.7,
+            marker_line_width=0,
+            colorbar_title=f"{indicator_label} ({unit})",
+            text=[f"{indicator_label}: {value:.2f} {unit}" for value in indicators],  # Add hover text showing the indicator value
+            hoverinfo="text" 
+        ))
+
+        fig.update_layout(
+            mapbox_style="open-street-map",
+            mapbox_zoom=2,
+            height=800,
+            mapbox_center={
+                "lat": latitudes[len(latitudes)//2] if latitudes else 0,
+                "lon": longitudes[len(longitudes)//2] if longitudes else 0
+            },
+            coloraxis_colorbar=dict(title=f"{indicator_label} ({unit})"),
+            title=f"{indicator_label} in {year} in {location} ({country_name})"
+        )
+        return fig
+
+    return plot_data
+
+choropleth_map_of_country_indicator_for_specific_year: Plot = {
+    "name": "Choropleth Map of a Country's Indicator Distribution for a Specific Year",
+    "description": (
+        "Displays a map showing the spatial distribution of a climate indicator (e.g., rainfall, temperature) "
+        "across all regions of a country for a specific year. "
+        "Can answer questions about the value of an indicator in a country or region for a given year, "
+        "such as 'What will be the total rainfall in China in 2050?' or 'How is rainfall distributed across China in 2050?'. "
+        "Parameters: indicator_column (the climate variable), year, location (country name)."
+    ),
+    "params": ["indicator_column", "year", "location"],
+    "plot_function": plot_choropleth_map_of_country_indicator_for_specific_year,
+    "sql_query": indicator_for_given_year_query,
+    "plot_information": choropleth_map_informations,
+    "short_name": "Map",
+}
+
+IPCC_PLOTS = [
+    indicator_evolution_at_location_historical_and_projections,
+    choropleth_map_of_country_indicator_for_specific_year
+]

climateqa/engine/talk_to_data/ipcc/queries.py

@@ -0,0 +1,143 @@
+from typing import TypedDict, Optional
+
+from climateqa.engine.talk_to_data.ipcc.config import HUGE_MACRO_COUNTRIES, MACRO_COUNTRIES
+from climateqa.engine.talk_to_data.config import IPCC_DATASET_URL
+class IndicatorPerYearAtLocationQueryParams(TypedDict, total=False):
+    """
+    Parameters for querying the evolution of an indicator per year at a specific location.
+
+    Attributes:
+        indicator_column (str): Name of the climate indicator column.
+        latitude (str): Latitude of the location.
+        longitude (str): Longitude of the location.
+        country_code (str): Country code.
+        admin1 (str): Administrative region (optional).
+    """
+    indicator_column: str
+    latitude: str
+    longitude: str
+    country_code: str
+    admin1: Optional[str]
+
+def indicator_per_year_at_location_query(
+    table: str, params: IndicatorPerYearAtLocationQueryParams
+) -> str:
+    """
+    Builds an SQL query to get the evolution of an indicator per year at a specific location.
+
+    Args:
+        table (str): SQL table of the indicator.
+        params (IndicatorPerYearAtLocationQueryParams): Dictionary with the required params for the query.
+
+    Returns:
+        str: The SQL query string, or an empty string if required parameters are missing.
+    """
+    indicator_column = params.get("indicator_column")
+    latitude = params.get("latitude")
+    longitude = params.get("longitude")
+    country_code = params.get("country_code")
+    admin1 = params.get("admin1")
+
+    if not all([indicator_column, latitude, longitude, country_code]):
+        return ""
+
+    if country_code in MACRO_COUNTRIES:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        sql_query = f"""
+        SELECT year, scenario, AVG({indicator_column}) as {indicator_column}
+        FROM {table_path}
+        WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950
+        GROUP BY scenario, year
+        ORDER BY year, scenario
+        """
+    elif country_code in HUGE_MACRO_COUNTRIES:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        sql_query = f"""
+        SELECT year, scenario, {indicator_column},
+        FROM {table_path}
+        WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950
+        ORDER year, scenario
+        """
+    else:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}.parquet'"
+        sql_query = f"""
+        WITH medians_per_month AS (
+            SELECT year, scenario, month, MEDIAN({indicator_column}) AS median_value
+            FROM {table_path}
+            WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950
+            GROUP BY scenario, year, month
+        )
+        SELECT year, scenario, AVG(median_value) AS {indicator_column}
+        FROM medians_per_month
+        GROUP BY scenario, year
+        ORDER BY year, scenario
+        """
+    return sql_query.strip()
+
+class IndicatorForGivenYearQueryParams(TypedDict, total=False):
+    """
+    Parameters for querying an indicator's values across locations for a specific year.
+
+    Attributes:
+        indicator_column (str): The column name for the climate indicator.
+        year (str): The year to query.
+        country_code (str): The country code.
+    """
+    indicator_column: str
+    year: str
+    country_code: str
+
+def indicator_for_given_year_query(
+    table: str, params: IndicatorForGivenYearQueryParams
+) -> str:
+    """
+    Builds an SQL query to get the values of an indicator with their latitudes, longitudes,
+    and scenarios for a given year.
+
+    Args:
+        table (str): SQL table of the indicator.
+        params (IndicatorForGivenYearQueryParams): Dictionary with the required params for the query.
+
+    Returns:
+        str: The SQL query string, or an empty string if required parameters are missing.
+    """
+    indicator_column = params.get("indicator_column")
+    year = params.get("year") or 2050
+    country_code = params.get("country_code")
+
+    if not all([indicator_column, year, country_code]):
+        return ""
+
+    if country_code in MACRO_COUNTRIES:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        sql_query = f"""
+        SELECT latitude, longitude, scenario, AVG({indicator_column}) as {indicator_column}
+        FROM {table_path}
+        WHERE year = {year}
+        GROUP BY latitude, longitude, scenario
+        ORDER BY latitude, longitude, scenario
+        """
+    elif country_code in HUGE_MACRO_COUNTRIES:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        sql_query = f"""
+        SELECT latitude, longitude, scenario, {indicator_column},
+        FROM {table_path}
+        WHERE year = {year}
+        ORDER BY latitude, longitude, scenario
+        """
+    else:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}.parquet'"
+        sql_query = f"""
+        WITH medians_per_month AS (
+            SELECT latitude, longitude, scenario, month, MEDIAN({indicator_column}) AS median_value
+            FROM {table_path}
+            WHERE year = {year}
+            GROUP BY latitude, longitude, scenario, month
+        )
+        SELECT latitude, longitude, scenario, AVG(median_value) AS {indicator_column}
+        FROM medians_per_month
+        GROUP BY latitude, longitude, scenario
+        ORDER BY latitude, longitude, scenario
+        """
+
+    return sql_query.strip()

climateqa/engine/talk_to_data/main.py

@@ -1,44 +1,70 @@
-from climateqa.engine.talk_to_data.talk_to_drias import drias_workflow
-from climateqa.engine.llm import get_llm
+from climateqa.engine.talk_to_data.workflow.drias import drias_workflow
+from climateqa.engine.talk_to_data.workflow.ipcc import ipcc_workflow
 from climateqa.logging import log_drias_interaction_to_huggingface
-import ast
 
-llm = get_llm(provider="openai")
-
-def ask_llm_to_add_table_names(sql_query: str, llm) -> str:
-    """Adds table names to the SQL query result rows using LLM.
+async def ask_drias(query: str, index_state: int = 0, user_id: str | None = None) -> tuple:
+    """Main function to process a DRIAS query and return results.
     
-    This function modifies the SQL query to include the source table name in each row
-    of the result set, making it easier to track which data comes from which table.
+    This function orchestrates the DRIAS workflow, processing a user query to generate
+    SQL queries, dataframes, and visualizations. It handles multiple results and allows
+    pagination through them.
     
     Args:
-        sql_query (str): The original SQL query to modify
-        llm: The language model instance to use for generating the modified query
+        query (str): The user's question about climate data
+        index_state (int, optional): The index of the result to return. Defaults to 0.
         
     Returns:
-        str: The modified SQL query with table names included in the result rows
+        tuple: A tuple containing:
+            - sql_query (str): The SQL query used
+            - dataframe (pd.DataFrame): The resulting data
+            - figure (Callable): Function to generate the visualization
+            - sql_queries (list): All generated SQL queries
+            - result_dataframes (list): All resulting dataframes
+            - figures (list): All figure generation functions
+            - index_state (int): Current result index
+            - table_list (list): List of table names used
+            - error (str): Error message if any
     """
-    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
+    final_state = await drias_workflow(query)
+    sql_queries = []
+    result_dataframes = []
+    figures = []
+    plot_title_list = []
+    plot_informations = []
+
+    for output_title, output in final_state['outputs'].items():
+        if output['status'] == 'OK':
+            if output['table'] is not None: 
+                plot_title_list.append(output_title)
+            
+            if output['plot_information'] is not None:
+                plot_informations.append(output['plot_information'])
+
+            if output['sql_query'] is not None:
+                sql_queries.append(output['sql_query'])
+            
+            if output['dataframe'] is not None:
+                result_dataframes.append(output['dataframe'])
+                if output['figure'] is not None:
+                    figures.append(output['figure'])
+
+    if "error" in final_state and final_state["error"] != "":
+        # No Sql query, no dataframe, no figure, no plot information, empty sql queries list, empty result dataframes list, empty figures list, empty plot information list, index state = 0, empty table list, error message
+        return None, None, None, None, [], [], [], 0, [], final_state["error"]
 
-def ask_llm_column_names(sql_query: str, llm) -> list[str]:
-    """Extracts column names from a SQL query using LLM.
+    sql_query = sql_queries[index_state]
+    dataframe = result_dataframes[index_state]
+    figure = figures[index_state](dataframe)
+    plot_information = plot_informations[index_state] 
     
-    This function analyzes a SQL query to identify which columns are being selected
-    in the result set.
     
-    Args:
-        sql_query (str): The SQL query to analyze
-        llm: The language model instance to use for column extraction
-        
-    Returns:
-        list[str]: A list of column names being selected in the query
-    """
-    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
+    log_drias_interaction_to_huggingface(query, sql_query, user_id)
+
+    return sql_query, dataframe, figure, plot_information, sql_queries, result_dataframes, figures, plot_informations, index_state, plot_title_list, ""
 
-async def ask_drias(query: str, index_state: int = 0, user_id: str = None) -> tuple:
+
+
+async def ask_ipcc(query: str, index_state: int = 0, user_id: str | None = None) -> tuple:
     """Main function to process a DRIAS query and return results.
     
     This function orchestrates the DRIAS workflow, processing a user query to generate
@@ -61,58 +87,38 @@ async def ask_drias(query: str, index_state: int = 0, user_id: str = None) -> tu
             - table_list (list): List of table names used
             - error (str): Error message if any
     """
-    final_state = await drias_workflow(query)
+    final_state = await ipcc_workflow(query)
     sql_queries = []
     result_dataframes = []
     figures = []
-    table_list = []
+    plot_title_list = []
+    plot_informations = []
 
-    for plot_state in final_state['plot_states'].values():
-        for table_state in plot_state['table_states'].values():
-            if table_state['status'] == 'OK':
-                if 'table_name' in table_state: 
-                    table_list.append(' '.join(table_state['table_name'].capitalize().split('_')))
-                if 'sql_query' in table_state and table_state['sql_query'] is not None:
-                    sql_queries.append(table_state['sql_query'])
-                
-                if 'dataframe' in table_state and table_state['dataframe'] is not None:
-                    result_dataframes.append(table_state['dataframe'])
-                    if 'figure' in table_state and table_state['figure'] is not None:
-                        figures.append(table_state['figure'])
+    for output_title, output in final_state['outputs'].items():
+        if output['status'] == 'OK':
+            if output['table'] is not None: 
+                plot_title_list.append(output_title)
+            
+            if output['plot_information'] is not None:
+                plot_informations.append(output['plot_information'])
+
+            if output['sql_query'] is not None:
+                sql_queries.append(output['sql_query'])
+            
+            if output['dataframe'] is not None:
+                result_dataframes.append(output['dataframe'])
+                if output['figure'] is not None:
+                    figures.append(output['figure'])
 
     if "error" in final_state and final_state["error"] != "":
-        return None, None, None, [], [], [], 0, final_state["error"]
+        # No Sql query, no dataframe, no figure, no plot information, empty sql queries list, empty result dataframes list, empty figures list, empty plot information list, index state = 0, empty table list, error message
+        return None, None, None, None, [], [], [], 0, [], final_state["error"]
 
     sql_query = sql_queries[index_state]
     dataframe = result_dataframes[index_state]
     figure = figures[index_state](dataframe)
+    plot_information = plot_informations[index_state]    
     
     log_drias_interaction_to_huggingface(query, sql_query, user_id)
 
-    return sql_query, dataframe, figure, sql_queries, result_dataframes, figures, index_state, table_list, ""
-
-# def ask_vanna(vn,db_vanna_path, query):
-
-#     try :
-#         location = detect_location_with_openai(query)
-#         if location:
-
-#             coords = loc2coords(location)
-#             user_input = query.lower().replace(location.lower(), f"lat, long : {coords}")
-            
-#             relevant_tables = detect_relevant_tables(db_vanna_path, 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 = None
-#             return "", empty_df, empty_fig
-#     except Exception as e:
-#         print(f"Error: {e}")
-#         empty_df = pd.DataFrame()
-#         empty_fig = None
-#         return "", empty_df, empty_fig
+    return sql_query, dataframe, figure, plot_information, sql_queries, result_dataframes, figures, plot_informations, index_state, plot_title_list, ""

climateqa/engine/talk_to_data/objects/llm_outputs.py

@@ -0,0 +1,13 @@
+from typing import Annotated, TypedDict
+
+
+class ArrayOutput(TypedDict):
+    """Represents the output of a function that returns an array.
+    
+    This class is used to type-hint functions that return arrays,
+    ensuring consistent return types across the codebase.
+    
+    Attributes:
+        array (str): A syntactically valid Python array string
+    """
+    array: Annotated[str, "Syntactically valid python array."]

climateqa/engine/talk_to_data/objects/location.py

@@ -0,0 +1,12 @@
+from token import OP
+from typing import Optional, TypedDict
+
+
+
+class Location(TypedDict):
+    location: str
+    latitude: Optional[str]
+    longitude: Optional[str]
+    country_code: Optional[str]
+    country_name: Optional[str]
+    admin1: Optional[str]

climateqa/engine/talk_to_data/objects/plot.py

@@ -0,0 +1,23 @@
+from typing import Callable, TypedDict, Optional
+from plotly.graph_objects import Figure
+
+class Plot(TypedDict):
+    """Represents a plot configuration in the DRIAS system.
+    
+    This class defines the structure for configuring different types of plots
+    that can be generated from climate data.
+    
+    Attributes:
+        name (str): The name of the plot type
+        description (str): A description of what the plot shows
+        params (list[str]): List of required parameters for the plot
+        plot_function (Callable[..., Callable[..., Figure]]): Function to generate the plot
+        sql_query (Callable[..., str]): Function to generate the SQL query for the plot
+    """
+    name: str
+    description: str
+    params: list[str]
+    plot_function: Callable[..., Callable[..., Figure]]
+    sql_query: Callable[..., str]
+    plot_information: Callable[..., str]
+    short_name: str

climateqa/engine/talk_to_data/objects/states.py

@@ -0,0 +1,19 @@
+from typing import Any, Callable, Optional, TypedDict
+from plotly.graph_objects import Figure
+import pandas as pd
+from climateqa.engine.talk_to_data.objects.plot import Plot
+
+class TTDOutput(TypedDict):
+    status: str
+    plot: Plot
+    table: str
+    sql_query: Optional[str]
+    dataframe: Optional[pd.DataFrame]
+    figure: Optional[Callable[..., Figure]]
+    plot_information: Optional[str]
+class State(TypedDict):
+    user_input: str
+    plots: list[str]
+    outputs: dict[str, TTDOutput]
+    error: Optional[str]
+

climateqa/engine/talk_to_data/prompt.py

@@ -0,0 +1,44 @@
+query_prompt_template = """You are an expert SQL query generator. Given an input question, database schema, SQL dialect and relevant tables to answer the question, generate an optimized and syntactically correct SQL query which can provide useful insights to the question.
+
+### Instructions:
+1. **Use only relevant tables**: The following tables are relevant to answering the question: {relevant_tables}. Do not use any other tables.
+2. **Relevant columns only**: Never select `*`. Only include necessary columns based on the input question.
+3. **Schema Awareness**:  
+   - Use only columns present in the given schema.  
+   - **If a column name appears in multiple tables, always use the format `table_name.column_name` to avoid ambiguity.**
+   - Select only the column which are insightful for the question.
+4. **Dialect Compliance**: Follow `{dialect}` syntax rules.
+5. **Ordering**: Order the results by a relevant column if applicable (e.g., timestamp for recent records).
+6. **Valid query**: Make sure the query is syntactically and functionally correct.
+7. **Conditions** : For the common columns, the same condition should be applied to all the tables (e.g. latitude, longitude, model, year...)
+9. **Join tables** : If you need to join table, you should join them with year feature.
+10. **Model** : For each table, you need to add a condition on the model to be equal to {model}
+
+### Provided Database Schema:
+{table_info}
+
+### Relevant Tables:
+{relevant_tables}
+
+**Question:** {input}
+
+**SQL Query:**"""
+
+plot_prompt_template = """You are a data visualization expert. Given an input question and an SQL Query, generate an insightful plot according to the question.
+
+### Instructions
+1. **Use only the column names provided**. The data will be provided as a Pandas DataFrame `df` with the columns present in the SELECT.
+2. Generate the Python Plotly code to chart the results using `df` and the column names.
+3. Make as complete a graph as possible to answer the question, and make it as easy to understand as possible.
+4. **Response with only Python code**. Do not answer with any explanations -- just the code.
+5. **Specific cases** :
+- For a question about the evolution of something, it is also relevant to plot the data with also the sliding average for a period of 20 years for example.
+
+### SQL Query:
+{sql_query}
+
+**Question:** {input}
+
+**Python code:**
+"""
+

climateqa/engine/talk_to_data/query.py

@@ -0,0 +1,57 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import duckdb
+import pandas as pd
+import os
+
+def find_indicator_column(table: str, indicator_columns_per_table: dict[str,str]) -> str:
+    """Retrieves the name of the indicator column within a table.
+    
+    This function maps table names to their corresponding indicator columns
+    using the predefined mapping in INDICATOR_COLUMNS_PER_TABLE.
+    
+    Args:
+        table (str): Name of the table in the database
+        
+    Returns:
+        str: Name of the indicator column for the specified table
+        
+    Raises:
+        KeyError: If the table name is not found in the mapping
+    """
+    print(f"---- Find indicator column in table {table} ----")
+    return indicator_columns_per_table[table]
+
+async def execute_sql_query(sql_query: str) -> pd.DataFrame:
+    """Executes a SQL query on the DRIAS database and returns the results.
+    
+    This function connects to the DuckDB database containing DRIAS climate data
+    and executes the provided SQL query. It handles the database connection and
+    returns the results as a pandas DataFrame.
+    
+    Args:
+        sql_query (str): The SQL query to execute
+        
+    Returns:
+        pd.DataFrame: A DataFrame containing the query results
+        
+    Raises:
+        duckdb.Error: If there is an error executing the SQL query
+    """
+    def _execute_query():
+        # Execute the query
+        con = duckdb.connect()
+        HF_TTD_TOKEN = os.getenv("HF_TTD_TOKEN")
+        con.execute(f"""CREATE SECRET hf_token (
+            TYPE huggingface,
+            TOKEN '{HF_TTD_TOKEN}'
+        );""")
+        results = con.execute(sql_query).fetchdf()
+        # return fetched data
+        return results
+
+    # Run the query in a thread pool to avoid blocking
+    loop = asyncio.get_event_loop()
+    with ThreadPoolExecutor() as executor:
+        return await loop.run_in_executor(executor, _execute_query)
+

climateqa/engine/talk_to_data/ui_config.py

@@ -0,0 +1,27 @@
+TEMPERATURE_COLORSCALE = [
+    [0.0, "rgb(5, 48, 97)"],
+    [0.10, "rgb(33, 102, 172)"],
+    [0.20, "rgb(67, 147, 195)"],
+    [0.30, "rgb(146, 197, 222)"],
+    [0.40, "rgb(209, 229, 240)"],
+    [0.50, "rgb(247, 247, 247)"],
+    [0.60, "rgb(253, 219, 199)"],
+    [0.75, "rgb(244, 165, 130)"],
+    [0.85, "rgb(214, 96, 77)"],
+    [0.90, "rgb(178, 24, 43)"],
+    [1.0, "rgb(103, 0, 31)"]
+]
+
+PRECIPITATION_COLORSCALE = [
+    [0.0, "rgb(84, 48, 5)"],
+    [0.10, "rgb(140, 81, 10)"],
+    [0.20, "rgb(191, 129, 45)"],
+    [0.30, "rgb(223, 194, 125)"],
+    [0.40, "rgb(246, 232, 195)"],
+    [0.50, "rgb(245, 245, 245)"],
+    [0.60, "rgb(199, 234, 229)"],
+    [0.75, "rgb(128, 205, 193)"],
+    [0.85, "rgb(53, 151, 143)"],
+    [0.90, "rgb(1, 102, 94)"],
+    [1.0, "rgb(0, 60, 48)"]
+]

climateqa/engine/talk_to_data/vanna/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('THEO_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/vanna/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

climateqa/engine/talk_to_data/workflow/drias.py

@@ -0,0 +1,163 @@
+import os
+
+from typing import Any
+import asyncio
+from climateqa.engine.llm import get_llm
+from climateqa.engine.talk_to_data.input_processing import find_param, find_relevant_plots, find_relevant_tables_per_plot
+from climateqa.engine.talk_to_data.query import execute_sql_query, find_indicator_column
+from climateqa.engine.talk_to_data.objects.plot import Plot
+from climateqa.engine.talk_to_data.objects.states import State, TTDOutput
+from climateqa.engine.talk_to_data.drias.config import DRIAS_TABLES, DRIAS_INDICATOR_COLUMNS_PER_TABLE, DRIAS_PLOT_PARAMETERS
+from climateqa.engine.talk_to_data.drias.plots import DRIAS_PLOTS
+
+ROOT_PATH = os.path.dirname(os.path.dirname(os.getcwd()))
+
+async def process_output(
+    output_title: str,
+    table: str,
+    plot: Plot,
+    params: dict[str, Any]
+) -> tuple[str, TTDOutput, dict[str, bool]]:
+    """
+    Processes a table for a given plot and parameters: builds the SQL query, executes it,
+    and generates the corresponding figure.
+
+    Args:
+        output_title (str): Title for the output (used as key in outputs dict).
+        table (str): The name of the table to process.
+        plot (Plot): The plot object containing SQL query and visualization function.
+        params (dict[str, Any]): Parameters used for querying the table.
+
+    Returns:
+        tuple: (output_title, results dict, errors dict)
+    """
+    results: TTDOutput = {
+        'status': 'OK',
+        'plot': plot,
+        'table': table,
+        'sql_query': None,
+        'dataframe': None,
+        'figure': None,
+        'plot_information': None
+    }
+    errors = {
+        'have_sql_query': False,
+        'have_dataframe': False
+    }
+
+    # Find the indicator column for this table
+    indicator_column = find_indicator_column(table, DRIAS_INDICATOR_COLUMNS_PER_TABLE)
+    if indicator_column:
+        params['indicator_column'] = indicator_column
+
+    # Build the SQL query
+    sql_query = plot['sql_query'](table, params)
+    if not sql_query:
+        results['status'] = 'ERROR'
+        return output_title, results, errors
+
+    results['plot_information'] = plot['plot_information'](table, params)
+
+    results['sql_query'] = sql_query
+    errors['have_sql_query'] = True
+
+    # Execute the SQL query
+    df = await execute_sql_query(sql_query)
+    if df is not None and len(df) > 0:
+        results['dataframe'] = df
+        errors['have_dataframe'] = True
+    else:
+        results['status'] = 'NO_DATA'
+
+    # Generate the figure (always, even if df is empty, for consistency)
+    results['figure'] = plot['plot_function'](params)
+
+    return output_title, results, errors
+
+async def drias_workflow(user_input: str) -> State:
+    """
+    Orchestrates the DRIAS workflow: from user input to SQL queries, dataframes, and figures.
+
+    Args:
+        user_input (str): The user's question.
+
+    Returns:
+        State: Final state with all results and error messages if any.
+    """
+    state: State = {
+        'user_input': user_input,
+        'plots': [],
+        'outputs': {},
+        'error': ''
+    }
+
+    llm = get_llm(provider="openai")
+    plots = await find_relevant_plots(state, llm, DRIAS_PLOTS)
+
+    if not plots:
+        state['error'] = 'There is no plot to answer to the question'
+        return state
+
+    plots = plots[:2]  # limit to 2 types of plots
+    state['plots'] = plots
+
+    errors = {
+        'have_relevant_table': False,
+        'have_sql_query': False,
+        'have_dataframe': False
+    }
+    outputs = {}
+
+    # Find relevant tables for each plot and prepare outputs
+    for plot_name in plots:
+        plot = next((p for p in DRIAS_PLOTS if p['name'] == plot_name), None)
+        if plot is None:
+            continue
+
+        relevant_tables = await find_relevant_tables_per_plot(state, plot, llm, DRIAS_TABLES)
+        if relevant_tables:
+            errors['have_relevant_table'] = True
+
+        for table in relevant_tables:
+            output_title = f"{plot['short_name']} - {' '.join(table.capitalize().split('_'))}"
+            outputs[output_title] = {
+                'table': table,
+                'plot': plot,
+                'status': 'OK'
+            }
+
+    # Gather all required parameters
+    params = {}
+    for param_name in DRIAS_PLOT_PARAMETERS:
+        param = await find_param(state, param_name, mode='DRIAS')
+        if param:
+            params.update(param)
+
+    # Process all outputs in parallel using process_output
+    tasks = [
+        process_output(output_title, output['table'], output['plot'], params.copy())
+        for output_title, output in outputs.items()
+    ]
+    results = await asyncio.gather(*tasks)
+
+    # Update outputs with results and error flags
+    for output_title, task_results, task_errors in results:
+        outputs[output_title]['sql_query'] = task_results['sql_query']
+        outputs[output_title]['dataframe'] = task_results['dataframe']
+        outputs[output_title]['figure'] = task_results['figure']
+        outputs[output_title]['plot_information'] = task_results['plot_information']
+        outputs[output_title]['status'] = task_results['status']
+        errors['have_sql_query'] |= task_errors['have_sql_query']
+        errors['have_dataframe'] |= task_errors['have_dataframe']
+
+    state['outputs'] = outputs
+
+    # Set error messages if needed
+    if not errors['have_relevant_table']:
+        state['error'] = "There is no relevant table in our database to answer your question"
+    elif not errors['have_sql_query']:
+        state['error'] = "There is no relevant sql query on our database that can help to answer your question"
+    elif not errors['have_dataframe']:
+        state['error'] = "There is no data in our table that can answer to your question"
+
+    return state

climateqa/engine/talk_to_data/workflow/ipcc.py

@@ -0,0 +1,161 @@
+import os
+
+from typing import Any
+import asyncio
+from climateqa.engine.llm import get_llm
+from climateqa.engine.talk_to_data.input_processing import find_param, find_relevant_plots, find_relevant_tables_per_plot
+from climateqa.engine.talk_to_data.query import execute_sql_query, find_indicator_column
+from climateqa.engine.talk_to_data.objects.plot import Plot
+from climateqa.engine.talk_to_data.objects.states import State, TTDOutput
+from climateqa.engine.talk_to_data.ipcc.config import IPCC_TABLES, IPCC_INDICATOR_COLUMNS_PER_TABLE, IPCC_PLOT_PARAMETERS
+from climateqa.engine.talk_to_data.ipcc.plots import IPCC_PLOTS
+
+ROOT_PATH = os.path.dirname(os.path.dirname(os.getcwd()))
+
+async def process_output(
+    output_title: str,
+    table: str,
+    plot: Plot,
+    params: dict[str, Any]
+) -> tuple[str, TTDOutput, dict[str, bool]]:
+    """
+    Process a table for a given plot and parameters: builds the SQL query, executes it,
+    and generates the corresponding figure.
+
+    Args:
+        output_title (str): Title for the output (used as key in outputs dict).
+        table (str): The name of the table to process.
+        plot (Plot): The plot object containing SQL query and visualization function.
+        params (dict[str, Any]): Parameters used for querying the table.
+
+    Returns:
+        tuple: (output_title, results dict, errors dict)
+    """
+    results: TTDOutput = {
+        'status': 'OK',
+        'plot': plot,
+        'table': table,
+        'sql_query': None,
+        'dataframe': None,
+        'figure': None, 
+        'plot_information': None,
+    }
+    errors = {
+        'have_sql_query': False,
+        'have_dataframe': False
+    }
+
+    # Find the indicator column for this table
+    indicator_column = find_indicator_column(table, IPCC_INDICATOR_COLUMNS_PER_TABLE)
+    if indicator_column:
+        params['indicator_column'] = indicator_column
+
+    # Build the SQL query
+    sql_query = plot['sql_query'](table, params)
+    if not sql_query:
+        results['status'] = 'ERROR'
+        return output_title, results, errors
+
+    results['plot_information'] = plot['plot_information'](table, params)
+
+    results['sql_query'] = sql_query
+    errors['have_sql_query'] = True
+
+    # Execute the SQL query
+    df = await execute_sql_query(sql_query)
+    if df is not None and not df.empty:
+        results['dataframe'] = df
+        errors['have_dataframe'] = True
+    else:
+        results['status'] = 'NO_DATA'
+
+    # Generate the figure (always, even if df is empty, for consistency)
+    results['figure'] = plot['plot_function'](params)
+
+    return output_title, results, errors
+
+async def ipcc_workflow(user_input: str) -> State:
+    """
+    Performs the complete workflow of Talk To IPCC: from user input to SQL queries, dataframes, and figures.
+
+    Args:
+        user_input (str): The user's question.
+
+    Returns:
+        State: Final state with all the results and error messages if any.
+    """
+    state: State = {
+        'user_input': user_input,
+        'plots': [],
+        'outputs': {},
+        'error': ''
+    }
+
+    llm = get_llm(provider="openai")
+    plots = await find_relevant_plots(state, llm, IPCC_PLOTS)
+    state['plots'] = plots
+
+    if not plots:
+        state['error'] = 'There is no plot to answer to the question'
+        return state
+
+    errors = {
+        'have_relevant_table': False,
+        'have_sql_query': False,
+        'have_dataframe': False
+    }
+    outputs = {}
+
+    # Find relevant tables for each plot and prepare outputs
+    for plot_name in plots:
+        plot = next((p for p in IPCC_PLOTS if p['name'] == plot_name), None)
+        if plot is None:
+            continue
+
+        relevant_tables = await find_relevant_tables_per_plot(state, plot, llm, IPCC_TABLES)
+        if relevant_tables:
+            errors['have_relevant_table'] = True
+
+        for table in relevant_tables:
+            output_title = f"{plot['short_name']} - {' '.join(table.capitalize().split('_'))}"
+            outputs[output_title] = {
+                'table': table,
+                'plot': plot,
+                'status': 'OK'
+            }
+
+    # Gather all required parameters
+    params = {}
+    for param_name in IPCC_PLOT_PARAMETERS:
+        param = await find_param(state, param_name, mode='IPCC')
+        if param:
+            params.update(param)
+
+    # Process all outputs in parallel using process_output
+    tasks = [
+        process_output(output_title, output['table'], output['plot'], params.copy())
+        for output_title, output in outputs.items()
+    ]
+    results = await asyncio.gather(*tasks)
+
+    # Update outputs with results and error flags
+    for output_title, task_results, task_errors in results:
+        outputs[output_title]['sql_query'] = task_results['sql_query']
+        outputs[output_title]['dataframe'] = task_results['dataframe']
+        outputs[output_title]['figure'] = task_results['figure']
+        outputs[output_title]['plot_information'] = task_results['plot_information']
+        outputs[output_title]['status'] = task_results['status']
+        errors['have_sql_query'] |= task_errors['have_sql_query']
+        errors['have_dataframe'] |= task_errors['have_dataframe']
+
+    state['outputs'] = outputs
+
+    # Set error messages if needed
+    if not errors['have_relevant_table']:
+        state['error'] = "There is no relevant table in our database to answer your question"
+    elif not errors['have_sql_query']:
+        state['error'] = "There is no relevant sql query on our database that can help to answer your question"
+    elif not errors['have_dataframe']:
+        state['error'] = "There is no data in our table that can answer to your question"
+
+    return state

front/tabs/tab_drias.py

@@ -4,26 +4,25 @@ import os
 import pandas as pd
 
 from climateqa.engine.talk_to_data.main import ask_drias
-from climateqa.engine.talk_to_data.config import DRIAS_MODELS, DRIAS_UI_TEXT
+from climateqa.engine.talk_to_data.drias.config import DRIAS_MODELS, DRIAS_UI_TEXT
 
 class DriasUIElements(TypedDict):
     tab: gr.Tab
     details_accordion: gr.Accordion
     examples_hidden: gr.Textbox
     examples: gr.Examples
+    image_examples: gr.Row
     drias_direct_question: gr.Textbox
     result_text: gr.Textbox
-    table_names_display: gr.DataFrame
+    table_names_display: gr.Radio
     query_accordion: gr.Accordion
     drias_sql_query: gr.Textbox
     chart_accordion: gr.Accordion
+    plot_information: gr.Markdown
     model_selection: gr.Dropdown
     drias_display: gr.Plot
     table_accordion: gr.Accordion
     drias_table: gr.DataFrame
-    pagination_display: gr.Markdown
-    prev_button: gr.Button
-    next_button: gr.Button
 
 
 async def ask_drias_query(query: str, index_state: int, user_id: str):
@@ -31,7 +30,7 @@ async def ask_drias_query(query: str, index_state: int, user_id: str):
     return result
 
 
-def show_results(sql_queries_state, dataframes_state, plots_state):
+def show_results(sql_queries_state, dataframes_state, plots_state, table_names):
     if not sql_queries_state or not dataframes_state or not plots_state:
         # If all results are empty, show "No result"
         return (
@@ -40,9 +39,6 @@ def show_results(sql_queries_state, dataframes_state, plots_state):
             gr.update(visible=False),
             gr.update(visible=False),
             gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
         )
     else:
         # Show the appropriate components with their data
@@ -51,10 +47,7 @@ def show_results(sql_queries_state, dataframes_state, plots_state):
             gr.update(visible=True),
             gr.update(visible=True),
             gr.update(visible=True),
-            gr.update(visible=True),
-            gr.update(visible=True),
-            gr.update(visible=True),
-            gr.update(visible=True),
+            gr.update(choices=table_names, value=table_names[0], visible=True),
         )
 
 
@@ -72,44 +65,14 @@ def filter_by_model(dataframes, figures, index_state, model_selection):
     return df, figure
 
 
-def update_pagination(index, sql_queries):
-    pagination = f"{index + 1}/{len(sql_queries)}" if sql_queries else ""
-    return pagination
-
-
-def show_previous(index, sql_queries, dataframes, plots):
-    if index > 0:
-        index -= 1
-    return (
-        sql_queries[index],
-        dataframes[index],
-        plots[index](dataframes[index]),
-        index,
-    )
-
-
-def show_next(index, sql_queries, dataframes, plots):
-    if index < len(sql_queries) - 1:
-        index += 1
-    return (
-        sql_queries[index],
-        dataframes[index],
-        plots[index](dataframes[index]),
-        index,
-    )
-
-
-def display_table_names(table_names):
-    return [table_names]
-
-
-def on_table_click(evt: gr.SelectData, table_names, sql_queries, dataframes, plots):
-    index = evt.index[1]
+def on_table_click(selected_label, table_names, sql_queries, dataframes, plot_informations, plots):
+    index = table_names.index(selected_label)
     figure = plots[index](dataframes[index])
     return (
         sql_queries[index],
         dataframes[index],
         figure,
+        plot_informations[index],
         index,
     )
 
@@ -117,7 +80,7 @@ def on_table_click(evt: gr.SelectData, table_names, sql_queries, dataframes, plo
 def create_drias_ui() -> DriasUIElements:
     """Create and return all UI elements for the DRIAS tab."""
     with gr.Tab("France - Talk to DRIAS", elem_id="tab-vanna", id=6) as tab:
-        with gr.Accordion(label="Details") as details_accordion:
+        with gr.Accordion(label="❓ How to use?", elem_id="details") as details_accordion:
             gr.Markdown(DRIAS_UI_TEXT)
             
         # Add examples for common questions
@@ -141,24 +104,43 @@ def create_drias_ui() -> DriasUIElements:
                 elem_id="direct-question",
                 interactive=True,
             )
+        
+        
+        with gr.Row(visible=True, elem_id="example-img-container") as image_examples:
+            gr.Markdown("### Examples of possible visualizations")
+
+            with gr.Row():
+                gr.Image("./front/assets/talk_to_drias_winter_temp_paris_example.png", label="Evolution of Mean Winter Temperature in Paris", elem_classes=["example-img"])
+                gr.Image("./front/assets/talk_to_drias_annual_temperature_france_example.png", label="Mean Annual Temperature in 2030 in France", elem_classes=["example-img"])
+                gr.Image("./front/assets/talk_to_drias_frequency_remarkable_precipitation_lyon_example.png", label="Frequency of Remarkable Daily Precipitation in Lyon", elem_classes=["example-img"])
 
         result_text = gr.Textbox(
             label="", elem_id="no-result-label", interactive=False, visible=True
         )
-
-        table_names_display = gr.DataFrame(
-            [], label="List of relevant indicators", headers=None, interactive=False, elem_id="table-names", visible=False
-        )
-
-        with gr.Accordion(label="SQL Query Used", visible=False) as query_accordion:
-            drias_sql_query = gr.Textbox(
-                label="", elem_id="sql-query", interactive=False
+        
+        with gr.Row():
+            table_names_display = gr.Radio(
+                choices=[], 
+                label="Relevant figures created",
+                interactive=True,
+                elem_id="table-names",
+                visible=False
             )
 
+            with gr.Accordion(label="SQL Query Used", visible=False) as query_accordion:
+                drias_sql_query = gr.Textbox(
+                    label="", elem_id="sql-query", interactive=False
+                )
+
+    
         with gr.Accordion(label="Chart", visible=False) as chart_accordion:
-            model_selection = gr.Dropdown(
-                label="Model", choices=DRIAS_MODELS, value="ALL", interactive=True
-            )
+            with gr.Row():
+                model_selection = gr.Dropdown(
+                    label="Model", choices=DRIAS_MODELS, value="ALL", interactive=True
+                )
+                with gr.Accordion(label="Informations about the plot", open=False):
+                    plot_information = gr.Markdown(value = "")
+                
             drias_display = gr.Plot(elem_id="vanna-plot")
 
         with gr.Accordion(
@@ -166,32 +148,23 @@ def create_drias_ui() -> DriasUIElements:
         ) as table_accordion:
             drias_table = gr.DataFrame([], elem_id="vanna-table")
 
-        pagination_display = gr.Markdown(
-            value="", visible=False, elem_id="pagination-display"
-        )
-
-        with gr.Row():
-            prev_button = gr.Button("Previous", visible=False)
-            next_button = gr.Button("Next", visible=False)
-
         return DriasUIElements(
             tab=tab,
             details_accordion=details_accordion,
             examples_hidden=examples_hidden,
             examples=examples,
+            image_examples=image_examples,
             drias_direct_question=drias_direct_question,
             result_text=result_text,
             table_names_display=table_names_display,
             query_accordion=query_accordion,
             drias_sql_query=drias_sql_query,
             chart_accordion=chart_accordion,
+            plot_information=plot_information,
             model_selection=model_selection,
             drias_display=drias_display,
             table_accordion=table_accordion,
             drias_table=drias_table,
-            pagination_display=pagination_display,
-            prev_button=prev_button,
-            next_button=next_button
         )
 
 
@@ -202,94 +175,56 @@ def setup_drias_events(ui_elements: DriasUIElements, share_client=None, user_id=
     sql_queries_state = gr.State([])
     dataframes_state = gr.State([])
     plots_state = gr.State([])
+    plot_informations_state = gr.State([])
     index_state = gr.State(0)
     table_names_list = gr.State([])
     user_id = gr.State(user_id)
 
+    # Handle direct question submission - trigger the same workflow by setting examples_hidden
+    ui_elements["drias_direct_question"].submit(
+        lambda x: gr.update(value=x),
+        inputs=[ui_elements["drias_direct_question"]],
+        outputs=[ui_elements["examples_hidden"]],
+    )
+
     # Handle example selection
     ui_elements["examples_hidden"].change(
         lambda x: (gr.Accordion(open=False), gr.Textbox(value=x)),
         inputs=[ui_elements["examples_hidden"]],
         outputs=[ui_elements["details_accordion"], ui_elements["drias_direct_question"]]
     ).then(
-        ask_drias_query,
-        inputs=[ui_elements["examples_hidden"], index_state, user_id],
-        outputs=[
-            ui_elements["drias_sql_query"],
-            ui_elements["drias_table"],
-            ui_elements["drias_display"],
-            sql_queries_state,
-            dataframes_state,
-            plots_state,
-            index_state,
-            table_names_list,
-            ui_elements["result_text"],
-        ],
-    ).then(
-        show_results,
-        inputs=[sql_queries_state, dataframes_state, plots_state],
-        outputs=[
-            ui_elements["result_text"],
-            ui_elements["query_accordion"],
-            ui_elements["table_accordion"],
-            ui_elements["chart_accordion"],
-            ui_elements["prev_button"],
-            ui_elements["next_button"],
-            ui_elements["pagination_display"],
-            ui_elements["table_names_display"],
-        ],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    ).then(
-        display_table_names,
-        inputs=[table_names_list],
-        outputs=[ui_elements["table_names_display"]],
-    )
-
-    # Handle direct question submission
-    ui_elements["drias_direct_question"].submit(
-        lambda: gr.Accordion(open=False),
+        lambda : gr.update(visible=False),
         inputs=None,
-        outputs=[ui_elements["details_accordion"]]
+        outputs=ui_elements["image_examples"]
     ).then(
         ask_drias_query,
-        inputs=[ui_elements["drias_direct_question"], index_state, user_id],
+        inputs=[ui_elements["examples_hidden"], index_state, user_id],
         outputs=[
             ui_elements["drias_sql_query"],
             ui_elements["drias_table"],
             ui_elements["drias_display"],
+            ui_elements["plot_information"],
             sql_queries_state,
             dataframes_state,
             plots_state,
+            plot_informations_state,
             index_state,
             table_names_list,
             ui_elements["result_text"],
         ],
     ).then(
         show_results,
-        inputs=[sql_queries_state, dataframes_state, plots_state],
+        inputs=[sql_queries_state, dataframes_state, plots_state, table_names_list],
         outputs=[
             ui_elements["result_text"],
             ui_elements["query_accordion"],
             ui_elements["table_accordion"],
             ui_elements["chart_accordion"],
-            ui_elements["prev_button"],
-            ui_elements["next_button"],
-            ui_elements["pagination_display"],
             ui_elements["table_names_display"],
         ],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    ).then(
-        display_table_names,
-        inputs=[table_names_list],
-        outputs=[ui_elements["table_names_display"]],
     )
 
+   
     # Handle model selection change
     ui_elements["model_selection"].change(
         filter_by_model,
@@ -297,36 +232,12 @@ def setup_drias_events(ui_elements: DriasUIElements, share_client=None, user_id=
         outputs=[ui_elements["drias_table"], ui_elements["drias_display"]],
     )
 
-    # Handle pagination buttons
-    ui_elements["prev_button"].click(
-        show_previous,
-        inputs=[index_state, sql_queries_state, dataframes_state, plots_state],
-        outputs=[ui_elements["drias_sql_query"], ui_elements["drias_table"], ui_elements["drias_display"], index_state],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    )
-
-    ui_elements["next_button"].click(
-        show_next,
-        inputs=[index_state, sql_queries_state, dataframes_state, plots_state],
-        outputs=[ui_elements["drias_sql_query"], ui_elements["drias_table"], ui_elements["drias_display"], index_state],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
-    )
 
     # Handle table selection
-    ui_elements["table_names_display"].select(
+    ui_elements["table_names_display"].change(
         fn=on_table_click,
-        inputs=[table_names_list, sql_queries_state, dataframes_state, plots_state],
-        outputs=[ui_elements["drias_sql_query"], ui_elements["drias_table"], ui_elements["drias_display"], index_state],
-    ).then(
-        update_pagination,
-        inputs=[index_state, sql_queries_state],
-        outputs=[ui_elements["pagination_display"]],
+        inputs=[ui_elements["table_names_display"], table_names_list, sql_queries_state, dataframes_state, plot_informations_state, plots_state],
+        outputs=[ui_elements["drias_sql_query"], ui_elements["drias_table"], ui_elements["drias_display"], ui_elements["plot_information"], index_state],
     )
 
 def create_drias_tab(share_client=None, user_id=None):

front/tabs/tab_ipcc.py

@@ -0,0 +1,300 @@
+from random import choices
+import gradio as gr
+from typing import TypedDict
+from climateqa.engine.talk_to_data.main import ask_ipcc
+from climateqa.engine.talk_to_data.ipcc.config import IPCC_MODELS, IPCC_SCENARIO, IPCC_UI_TEXT
+import uuid
+
+class ipccUIElements(TypedDict):
+    tab: gr.Tab
+    details_accordion: gr.Accordion
+    examples_hidden: gr.Textbox
+    examples: gr.Examples
+    image_examples: gr.Row
+    ipcc_direct_question: gr.Textbox
+    result_text: gr.Textbox
+    table_names_display: gr.Radio
+    query_accordion: gr.Accordion
+    ipcc_sql_query: gr.Textbox
+    chart_accordion: gr.Accordion
+    plot_information: gr.Markdown
+    scenario_selection: gr.Dropdown
+    ipcc_display: gr.Plot
+    table_accordion: gr.Accordion
+    ipcc_table: gr.DataFrame
+
+
+async def ask_ipcc_query(query: str, index_state: int, user_id: str):
+    result = await ask_ipcc(query, index_state, user_id)
+    return result
+
+def hide_outputs():
+    """Hide all outputs initially."""
+    return (
+        gr.update(visible=True),  # Show the result text
+        gr.update(visible=False),  # Hide the query accordion
+        gr.update(visible=False),  # Hide the table accordion
+        gr.update(visible=False),  # Hide the chart accordion
+        gr.update(visible=False),  # Hide table names
+    )
+
+def show_results(sql_queries_state, dataframes_state, plots_state, table_names):
+    if not sql_queries_state or not dataframes_state or not plots_state:
+        # If all results are empty, show "No result"
+        return (
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+            gr.update(visible=False),
+        )
+    else:
+        # Show the appropriate components with their data
+        return (
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=True),
+            gr.update(visible=True),
+            gr.update(choices=table_names, value=table_names[0], visible=True),
+        )
+
+
+def show_filter_by_scenario(table_names, index_state, dataframes):
+    if len(table_names) > 0 and table_names[index_state].startswith("Map"):
+        df = dataframes[index_state]
+        scenarios = sorted(df["scenario"].unique())
+        return gr.update(visible=True, choices=scenarios, value=scenarios[0])
+    else:
+        return gr.update(visible=False)
+        
+def filter_by_scenario(dataframes, figures, table_names, index_state, scenario):
+    df = dataframes[index_state]
+    if not table_names[index_state].startswith("Map"):
+        return df, figures[index_state](df)
+    if df.empty:
+        return df, None
+    if "scenario" not in df.columns:
+        return df, figures[index_state](df)
+    else:
+        df = df[df["scenario"] == scenario]
+        if df.empty:
+            return df, None
+    figure = figures[index_state](df)
+    return df, figure
+
+
+def display_table_names(table_names, index_state):
+    return [
+        [name]
+        for name in table_names
+    ]
+
+def on_table_click(selected_label, table_names, sql_queries, dataframes, plot_informations, plots):
+    index = table_names.index(selected_label)
+    figure = plots[index](dataframes[index])
+
+    return (
+        sql_queries[index],
+        dataframes[index],
+        figure,
+        plot_informations[index],
+        index,
+    )
+
+
+def create_ipcc_ui() -> ipccUIElements:
+
+    """Create and return all UI elements for the ipcc tab."""
+    with gr.Tab("(Beta) Talk to IPCC", elem_id="tab-vanna", id=7) as tab:
+        with gr.Accordion(label="❓ How to use?", elem_id="details") as details_accordion:
+            gr.Markdown(IPCC_UI_TEXT)
+            
+        # Add examples for common questions
+        examples_hidden = gr.Textbox(visible=False, elem_id="ipcc-examples-hidden")
+        examples = gr.Examples(
+            examples=[
+                ["What will the temperature be like in Paris?"],
+                ["What will be the total rainfall in the USA in 2030?"],
+                ["How will the average temperature evolve in China?"],
+                ["What will be the average total precipitation in London ?"]
+            ],
+            label="Example Questions",
+            inputs=[examples_hidden],
+            outputs=[examples_hidden],
+        )
+        
+        with gr.Row():
+            ipcc_direct_question = gr.Textbox(
+                label="Direct Question",
+                placeholder="You can write direct question here",
+                elem_id="direct-question",
+                interactive=True,
+            )
+
+        with gr.Row(visible=True, elem_id="example-img-container") as image_examples:
+            gr.Markdown("### Examples of possible visualizations")
+
+            with gr.Row():
+                gr.Image("./front/assets/talk_to_ipcc_france_example.png", label="Total Precipitation in 2030 in France", elem_classes=["example-img"])
+                gr.Image("./front/assets/talk_to_ipcc_new_york_example.png", label="Yearly Evolution of Mean Temperature in New York (Historical + SSP Scenarios)", elem_classes=["example-img"])
+                gr.Image("./front/assets/talk_to_ipcc_china_example.png", label="Mean Temperature in 2050 in China", elem_classes=["example-img"])
+
+        result_text = gr.Textbox(
+            label="", elem_id="no-result-label", interactive=False, visible=True
+        )
+        with gr.Row():
+            table_names_display = gr.Radio(
+                choices=[],  
+                label="Relevant figures created",
+                interactive=True,
+                elem_id="table-names",
+                visible=False
+            )
+
+            with gr.Accordion(label="SQL Query Used", visible=False) as query_accordion:
+                ipcc_sql_query = gr.Textbox(
+                    label="", elem_id="sql-query", interactive=False
+                )
+
+        with gr.Accordion(label="Chart", visible=False) as chart_accordion:
+            
+            with gr.Row():
+                scenario_selection = gr.Dropdown(
+                    label="Scenario", choices=IPCC_SCENARIO, value=IPCC_SCENARIO[0], interactive=True, visible=False
+                )
+
+                with gr.Accordion(label="Informations about the plot", open=False):
+                    plot_information = gr.Markdown(value = "")
+
+            ipcc_display = gr.Plot(elem_id="vanna-plot")
+
+        with gr.Accordion(
+            label="Data used", open=False, visible=False
+        ) as table_accordion:
+            ipcc_table = gr.DataFrame([], elem_id="vanna-table")
+
+
+        return ipccUIElements(
+            tab=tab,
+            details_accordion=details_accordion,
+            examples_hidden=examples_hidden,
+            examples=examples,
+            image_examples=image_examples,
+            ipcc_direct_question=ipcc_direct_question,
+            result_text=result_text,
+            table_names_display=table_names_display,
+            query_accordion=query_accordion,
+            ipcc_sql_query=ipcc_sql_query,
+            chart_accordion=chart_accordion,
+            plot_information=plot_information,
+            scenario_selection=scenario_selection,
+            ipcc_display=ipcc_display,
+            table_accordion=table_accordion,
+            ipcc_table=ipcc_table,
+        )
+
+
+
+def setup_ipcc_events(ui_elements: ipccUIElements, share_client=None, user_id=None) -> None:
+    """Set up all event handlers for the ipcc tab."""
+    # Create state variables
+    sql_queries_state = gr.State([])
+    dataframes_state = gr.State([])
+    plots_state = gr.State([])
+    plot_informations_state = gr.State([])
+    index_state = gr.State(0)
+    table_names_list = gr.State([])
+    user_id = gr.State(user_id)
+
+    # Handle direct question submission - trigger the same workflow by setting examples_hidden
+    ui_elements["ipcc_direct_question"].submit(
+        lambda x: gr.update(value=x),
+        inputs=[ui_elements["ipcc_direct_question"]],
+        outputs=[ui_elements["examples_hidden"]],
+    )
+
+    # Handle example selection
+    ui_elements["examples_hidden"].change(
+        lambda x: (gr.Accordion(open=False), gr.Textbox(value=x)),
+        inputs=[ui_elements["examples_hidden"]],
+        outputs=[ui_elements["details_accordion"], ui_elements["ipcc_direct_question"]]
+    ).then(
+        lambda : gr.update(visible=False),
+        inputs=None,
+        outputs=ui_elements["image_examples"]
+    ).then(
+        hide_outputs,
+        inputs=None,
+        outputs=[
+            ui_elements["result_text"],
+            ui_elements["query_accordion"],
+            ui_elements["table_accordion"],
+            ui_elements["chart_accordion"],
+            ui_elements["table_names_display"],
+        ]
+    ).then(
+        ask_ipcc_query,
+        inputs=[ui_elements["examples_hidden"], index_state, user_id],
+        outputs=[
+            ui_elements["ipcc_sql_query"],
+            ui_elements["ipcc_table"],
+            ui_elements["ipcc_display"],
+            ui_elements["plot_information"],
+            sql_queries_state,
+            dataframes_state,
+            plots_state,
+            plot_informations_state,
+            index_state,
+            table_names_list,
+            ui_elements["result_text"],
+        ],
+    ).then(
+        show_results,
+        inputs=[sql_queries_state, dataframes_state, plots_state, table_names_list],
+        outputs=[
+            ui_elements["result_text"],
+            ui_elements["query_accordion"],
+            ui_elements["table_accordion"],
+            ui_elements["chart_accordion"],
+            ui_elements["table_names_display"],
+        ],
+    ).then(
+        show_filter_by_scenario,
+        inputs=[table_names_list, index_state, dataframes_state],
+        outputs=[ui_elements["scenario_selection"]],
+    ).then(
+        filter_by_scenario,
+        inputs=[dataframes_state, plots_state, table_names_list, index_state, ui_elements["scenario_selection"]],
+        outputs=[ui_elements["ipcc_table"], ui_elements["ipcc_display"]],
+    )
+
+
+    # Handle model selection change
+    ui_elements["scenario_selection"].change(
+        filter_by_scenario,
+        inputs=[dataframes_state, plots_state, table_names_list, index_state, ui_elements["scenario_selection"]],
+        outputs=[ui_elements["ipcc_table"], ui_elements["ipcc_display"]],
+    )
+
+    # Handle table selection
+    ui_elements["table_names_display"].change(
+        fn=on_table_click,
+        inputs=[ui_elements["table_names_display"], table_names_list, sql_queries_state, dataframes_state, plot_informations_state, plots_state],
+        outputs=[ui_elements["ipcc_sql_query"], ui_elements["ipcc_table"], ui_elements["ipcc_display"], ui_elements["plot_information"], index_state],
+    ).then(
+        show_filter_by_scenario,
+        inputs=[table_names_list, index_state, dataframes_state],
+        outputs=[ui_elements["scenario_selection"]],
+    ).then(
+        filter_by_scenario,
+        inputs=[dataframes_state, plots_state, table_names_list, index_state, ui_elements["scenario_selection"]],
+        outputs=[ui_elements["ipcc_table"], ui_elements["ipcc_display"]],
+    )
+
+
+def create_ipcc_tab(share_client=None, user_id=None):
+    """Create the ipcc tab with all its components and event handlers."""
+    ui_elements = create_ipcc_ui()
+    setup_ipcc_events(ui_elements, share_client=share_client, user_id=user_id)
+    
+        

requirements.txt

@@ -25,4 +25,5 @@ geopy==2.4.1
 duckdb==1.2.1
 openai==1.61.1
 pydantic==2.9.2
-pydantic-settings==2.2.1
+pydantic-settings==2.2.1
+geojson==3.2.0

style.css

@@ -656,12 +656,20 @@ a {
     /* overflow-y: scroll; */
 }
 #sql-query{
+<<<<<<< HEAD
+    max-height: 100%;
+}
+
+#sql-query textarea{
+    min-height: 200px !important;
+=======
     max-height: 300px;
     overflow-y:scroll;
 }
 
 #sql-query textarea{
     min-height: 100px !important;
+>>>>>>> hf-origin/main
 }
 
 #sql-query span{
@@ -671,8 +679,11 @@ div#tab-vanna{
     max-height: 100¨vh;
     overflow-y: hidden;
 } 
+#details button span{
+    font-weight: bold;
+}
 #vanna-plot{
-    max-height:500px
+    max-height:1000px
 }
 
 #pagination-display{
@@ -681,13 +692,33 @@ div#tab-vanna{
     font-size: 16px;
 }
 
-#table-names table{
-    overflow: hidden;
+
+#table-names label {
+    display: block;              
+    width: 100%;                 
+    box-sizing: border-box;
+    padding: 8px 12px;
+    margin-bottom: 4px;
+    border: 1px solid #ccc;
+    border-radius: 6px;
+    background-color: white;
+    cursor: pointer;
+    text-align: center;
 }
-#table-names thead{
+
+#table-names label:hover {
+    background-color: #f0f8ff;
+}
+
+#table-names input[type="radio"] {
     display: none;
 }
 
+#table-names input[type="radio"]:checked + label {
+    background-color: #d0eaff;
+    border-color: #2196f3;
+}
+
 /* DRIAS Data Table Styles */
 #vanna-table {
     height: 400px !important;
@@ -710,3 +741,13 @@ div#tab-vanna{
     background: white;
     z-index: 1;
 }
+
+.example-img{
+    height: 250px;
+    object-fit: contain;
+}
+
+#example-img-container {
+    flex-direction: column;
+    align-items: left;
+}