switch_vectorstore_to_azure_ai_search (#30)

- initial commit (5999013f4b21ae9752007771c4e265a4831f3e10)
- Adding necessary files for V0 (29f3cf9d9ef0d5b58b4069452459efc7805a5f53)
- Add app.py & requirements (88b346d939ed4b6b18eec500b5d412e5244868b5)
- correcting path (b37e492b30598e4500c86dea1dbdbd9134c615e8)
- error mixed version files during update (3549f0011605dc3e5180f65c98049a12321310d7)
- Replaced previous files with new files and correct folder organization (4d3e8c02adab31e3dcac1fdca947959eb2f42238)
- add db file (1f05721246cfce83ceca67b180d6de5ee24310d8)
- Correct path (473dcdc77ed812bff6412b3bae2218237f5c1db2)
- delete share because not supported by spaces (ef86508271b1cc86656c5ec4524c42599001dc30)
- Display api key (f7c08a6ee7930a4f564298d94ede4ec9f5e7ec81)
- test correcting openai api key (fc8d922f488a6ffc46f9135a7ad0ad88a0b2b323)
- Changing emoji (42dfe73c6f58d8a25d668faf65d64500d37a196c)
- Correct api key cache (f1d8d2baddbfb182533dbe9396d4e5aeae71ff83)
- Correcting import (3d6fd1bccd5fc377133da36f9d75438e89ec2a20)
- Edit text (73cb5fe63038e43312279c1ea8680a7821093f95)
- Correction indentation error (6f3b001c178c04b25c0f18297dbb3794c980f770)
- Fix indentation bug (00d66b96782500ae359646d677efb862fbbe7c8b)
- Add to secret manager api_key and system (17a978f556ec12c905530e3312a2dca9d994f2b6)
- correcting default api key and secret manager (8b276aaf2daeaff4e388f0161ef42d93d2593ca6)
- test correcting manager secret issue with api key (fd8b8bd3079a0fa556189e398301eaf148126ba7)
- adding sources as secret manager (fd6149f85358646a74a0385a1de48709167e6b0d)
- change to complete api_key as option (a17343b15c2729a472d058bb8f6036ccdb80f203)
- Change color (2dcef4362c33145993dcf7c39413d606b9568673)
- Adding explanation & background & utils file (8685e43cc07ab8f4e5c4ac52f0a1ccff21fe239e)
- Adding background image (7f10fa8fcdccf88b0b3405f4840c5a500334ef8e)
- Merge branch 'main' of https://huggingface.co/spaces/ekimetrics/climategpt (547525dcc8fca1b37aac824c3706aa362442e47b)
- Add Eki logo (470caf5a0bd2feff60f8dd944e0e8fd6d58ae943)
- deleting background & adding logo (03c61a87efa57def426a3841b1fd8e4ecc542b0f)
- Merge branch 'main' of https://huggingface.co/spaces/ekimetrics/climategpt (a757956a0c46cb8c6599b1bc88106546c5e5f91d)
- test background with logo (65d6f70adbc4c9aa04102c07bcf11e760df321df)
- test new background with logo (2a7515a5350bf01073fb88f9a2e057b9dafb8611)
- clean repo & add report selection (affc874a759f1ae536bdc14c61c7a07f595f06e8)
- add giec only files (21da7ea7a5d06ebc1fd362998322d2d9439b31b5)
- add giec only db (ec09a9e73cc162a80ddac46b37a2efc3757278eb)
- Cleaning & wording (2d4b96be6c33d34b69c032eb71125de7ca69015c)
- Correct wording (5b8b52a975b8ca6e7437338f9917424ac9fff83f)
- Merge branch 'main' of https://huggingface.co/spaces/ekimetrics/climategpt (676ad8ddcb4bb0834c6c75571c642d184ba7b035)
- test layout in huggingface (7249e3fb259bdd2a56217fd93e76a90b32b775cd)
- Correct ux design (166d2108229b7da9e9edda090c839588f8d0a367)
- add userid random (d312d8c7adb24811dfe17904cd5590eb127c034d)
- correcting markdown (51d6e66d2d44e3ccde7b9771f36f251cba5aabf2)
- add textbox for feedback (65067f0ce2e1f50217d6ad55b39735faccee5f75)
- tst (69b7bbaa9d567bb76bc9a80c0a42df3674da52f0)
- doc str (75bd17d1df6e17a8cefaf0594d13364557d9ce75)
- ds (0425cb629d7e7748bf86e6bf64d6efc6e9bec836)
- cleaner app (dd909e01f414272396009f59d5cd3817fbd3710a)
- var outside of func (878a987992048be05545e7da673ab976646f3f5c)
- 2 (e2b705f72a8d84faabe1e72d558673117f7fc11d)
- auto update text box + stream (c1e72d1c33335782c6406f5174b334a34e00f0aa)
- queue (49544ee4451eb1ddac6bdaa0b8dd40d38c03d1e4)
- added launch... (db454028eec53f53a6cd6f6bb52448aa94b9f4ce)
- only str in messages content (9ba500ae2826c6a9b4c8fd9ca51eeaca8f900980)
- hopefully this time it works (aeaf522749060e419881bc6155d1889049da7518)
- complete doc string for chat (63bb6284742e7f7a2c168f10511537d73f56b16c)
- safer args + better doc strings (48b7f35b0d1bd741c25c19e1727e531dd99e5a02)
- simpler description (27bb2e17a752fd1f39e9d423bc07510c1045cd15)
- prompt ing pour no docs (66e2136d1aca19bb4a3c455aebd1b2bbc3042ec7)
- no docs prompt ing (8a856ac3d85562040c228353608bc4c3adedc15c)
- try less req (6a20797eb7708cf1eddb6e004fb7312c13edda60)
- better req (0923c05a50bbd030595824e07490a817da96c25a)
- gradio 3.22 (ae77af425e891897096f0e1c2fd03dae668f4c3c)
- - pandas req (8bdb208d9ba1bf07646361b33da5795831c6f584)
- hopefully gradio fixed 3.22 (5fbb7f083fc615523ecf0175437601efdad46670)
- add feedbacks and logs to azure (3afc54c6a317e97c3efdd60530be5960f99e011b)
- create anonymous user_id (5bba46e503a467a65de8776bf36f68b886960e92)
- add azure storage file share lib (8598bf90301d9de15b1bc4ed27b0d49690d79ca2)
- correct spelling azure (14e4b14e16b9d966f8623fc287d09e6ff329b6a7)
- clé azure ekimetrics (0980c4b6db5981883fcf5b6e52ef9c955cba4371)
- eki api key (4c809c51e97ab5019cfbb9f1b5e6f7f8f8264a89)
- usage read me (e873211989ab664dccb49aaf95782cddea90de76)
- delete coms (e944ee08d3b5cdbecc16198782ba4f71ff1149a1)
- change user id (b7409698a33ea0acb083c72dd4111748a3d277a3)
- Update app.py (c49f785dccfdbfc15e65fac661e8911f949247ed)
- minor changes (9c7bf8665d4a373b61f94a3396401d6c832bf8c1)
- Added examples (08fe8f1d09a8490e6a4ca8b42a05ca6fa830a1b0)
- test new background (51aaf6fdcd7dbfcc65288ca437f335efd91e506d)
- change background test (23df579fb56f30350d7e86148bdb50ea462af371)
- fail background with pdf (98a01c107ab8ab8d35d9383d121c477812340705)
- test 2 background as page (2b2fb4307b94118344667c1d7b484eaf89c89b6a)
- change background sauvage (91d84131b03ca3252609afa34ec02eaa4ad0fbe7)
- Delete background_test.jpg (0cc46244bd0b25b619244629078ca6c44910b14d)
- back to previous backgound - test failed (65247c9d001b58757af65c5e640b008015137d6a)
- fix jpg to png (c8f61c0e604cbfe3f9b0dd57d93c5df3fd3fe612)
- Create style.css (d3f68b154ff6a57ce6d7e493d23718e7699fbd98)
- Update app.py (337b70c54d20f394a99396949cb6351ce44d034b)
- Update app.py (f25ba110c3b89419bc1b094cc6bc06650ffd8364)
- Update app.py (7972c2d23ab36cf1ecb1548eeab9b7eced3b14c4)
- Update app.py (3f5636a66997cf1b6df5391ea8febf3c9c5eddba)
- add feedback status (aee88fcba13d6fac402ca48530b0aec1a3f956a5)
- Update app.py (7514e4a1177a023c9228e9a542eec206dfc12dbb)
- Update app.py (0a9558a113d83f10b7261decbc1a3a975b1a9f72)
- Update app.py (5a498af4e1be4c0b939abf1732fdc93aa6232116)
- Update app.py (4ce1abef01e864810507e57a42b82f5ed2f84b88)
- Update app.py (78d3669956449994beb0d6a9e38fed7a758e21fd)
- Update app.py (77796eb54dd53ff24b3f50a992d43e00fa497bbf)
- Update style.css (ed0e6320c71102adbf791aed1793b8e3fcdbe502)
- Update app.py (fe7fa80827e04dbf763b98bf50339d38aff74096)
- Update app.py (6db0fffc1a0b7061cb27fa743b540da5f4f8540a)
- Update app.py (8c1bf4f246260375161aa5fda85e19e57716e3a8)
- Update README.md (01e72a4e33ba3a01eb3e450f100c5526e30af5a2)
- Update app.py (9abbaca4f4e815f76b9dc277160e156a1e589d7b)
- Update app.py (bc15b875b7822fed72b2b2aacd99c3b986224cb0)
- Update app.py (aff6e5711314f48bfc16c0ec813b13fd8a1b2b3e)
- Update app.py (0d9507a5ff0336902aad66edebd25c6509682dd0)
- Safety check on non sourced answers + theme (a22f5f7be311711e474940a0ec74dcaed0ef63ca)
- query reformulation (03cc572798f823bff471f76433b48ffb013516a0)
- Update app.py (b295cc12a7a1f10f2589706ea0c55635de6f27f8)
- Update app.py (89213214884e2f7b1896f444835dfd038daf1a9f)
- reformulation (909dc6d3f4813ad18949a70b778a747c6fae2b96)
- Merge branch 'main' of https://huggingface.co/spaces/Ekimetrics/climate-question-answering (2ed2c26198ce89e632888d6371b885ca079ba884)
- reformulation (e8e3a582ae44b230db09467ace6e7539121e706a)
- BUG FIX: remove custom key option (9c3b10a39f10555ace3e2e58110b075d7c870e17)
- ceci n'est pas un commit (1acb4eba7a80e68be9b32afa7b72cc8a314db085)
- commit non (1b0d9c9e2304bc5d236b1db8a6465831717ac623)
- prompt are now open source (8275289fe27917f6bc7681a1a693d20e658dca7e)
- name change + prompts open source (ebd7fc12539a93255cb919bafb81dbea37be1412)
- Update app.py (9e7c7bed501e205839f401d032bee9165dfd955d)
- Adding translation in (9bc1cf7177418734efabeb776590f3121a74ead7)
- Translation in all languages (f650b513a8e1ad7afbf3e2d7fc6497b0db34115a)
- Update app.py (6fab01ece8f40265f036dd160ba12de6f42ffc27)
- Update app.py (7815517c1e42d30bce7ae203c928ba6f743db48e)
- test data v2 (7d3d48c4dbe32849580f04e071c143856a177d92)
- data v2 (8cfc184e1f36158e95cae8949fce2054feceb24c)
- base de données v2 (cbd66080709bf8c2c9bef7e8e7e63c72845f6622)
- source table up to date (c60b40aa2a676290f51e654f3b6684d96129ba7a)
- Remove message in readme about language (c6f0b32a425f110ea0693bfcd35c941b39e25041)
- modified gitignore (bbcea094f621ca3577e63e2afd3d7ccd4199cc0e)
- Merge branch 'main' of https://huggingface.co/spaces/Ekimetrics/climate-question-answering (8d7ff84233dbdd78e1a7c92b42909af48699541b)
- Updated CSS and app (2e218e7d13e77137a43113c143b329a992685735)
- Added v3 FAISS Flat Files (9e5fc08f5aa319624dbb216e2bbeac10a42344dd)
- Delete documents (b8db6ac29ea2ba76bb673a4ba6f56710b46753b6)
- Update app.py (fbc1facd63ff127ba64e4d95ff5bdb10305b63bb)
- Update app.py (97c1ab968daa18170fbd1ce5594641f7acae6d41)
- Update app.py (3042aa7291312c72f3438ec643c2250019f3d11b)
- Update app.py (3ac1b5433f64ce96538adce66837159b89469a8d)
- Updated app 1.2.0 (eb0f8f83bd87b47d8bcff2bf18eadadd7e138b71)
- Update requirements.txt (5d956cd32db80b12494193d387f6bfb0e6dcde77)
- Updated requirements and changelog (a97a3ea8c6204dfed4965793b0d1491e0a489514)
- Update requirements.txt (2b02c85473a127ae41a59bd92443481e7119424c)
- Update app.py (7b97a461fc26a49ba883170a0962414d2d9e38b9)
- Update app.py (39b3b1fb994f4a2f67c422b1822ed915142b23fc)
- Updated app with config and audiences (fa572c4d96af8a39bf7c4069d19d9e88db1847fe)
- Update app.py (0be7c92dcc71399827ecac33fcb310bc5a52d8ed)
- Update app.py (00b001ee301a41ce83d1751b051880a892be02a4)
- Update app.py (8fc79eade32c0d9959e1e3a00dbba2fef0721b53)
- Update app.py (a8164b46253cbb0943f84b681b8d023f3e5796c1)
- Updated CSS (b0d7ddcf715042a093546a85664fdd6988152e79)
- Update style.css (e07482e059773e8f76093deb8f81e035aedc60d5)
- Update style.css (21b0eb2658d5cc1344975726277afad38e310e42)
- Added CSS (79f4b842aaf281b3158bdedc1ae74e531971e809)
- Updated CSS (e03c50b499faf67a5

app.py

@@ -7,7 +7,7 @@ from azure.storage.fileshare import ShareServiceClient
 # Import custom modules
 from climateqa.engine.embeddings import get_embeddings_function
 from climateqa.engine.llm import get_llm
-from climateqa.engine.vectorstore import get_pinecone_vectorstore
+from climateqa.engine.vectorstore import get_vectorstore
 from climateqa.engine.reranker import get_reranker
 from climateqa.engine.graph import make_graph_agent, make_graph_agent_poc
 from climateqa.engine.chains.retrieve_papers import find_papers
@@ -66,17 +66,11 @@ user_id = create_user_id()
 
 # Create vectorstore and retriever
 embeddings_function = get_embeddings_function()
-vectorstore = get_pinecone_vectorstore(
-    embeddings_function, index_name=os.getenv("PINECONE_API_INDEX")
-)
-vectorstore_graphs = get_pinecone_vectorstore(
-    embeddings_function,
-    index_name=os.getenv("PINECONE_API_INDEX_OWID"),
-    text_key="description",
-)
-vectorstore_region = get_pinecone_vectorstore(
-    embeddings_function, index_name=os.getenv("PINECONE_API_INDEX_LOCAL_V2")
-)
+
+vectorstore = get_vectorstore(provider="azure_search", embeddings=embeddings_function, index_name="climateqa-ipx")
+vectorstore_graphs = get_vectorstore(provider="azure_search", embeddings=embeddings_function, index_name="climateqa-owid", text_key="description")
+vectorstore_region = get_vectorstore(provider="azure_search", embeddings=embeddings_function, index_name="climateqa-v2")
+
 
 llm = get_llm(provider="openai", max_tokens=1024, temperature=0.0)
 if os.environ["GRADIO_ENV"] == "local":

climateqa/engine/chains/retrieve_documents.py

@@ -19,7 +19,7 @@ from ..llm import get_llm
 from .prompts import retrieve_chapter_prompt_template
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.output_parsers import StrOutputParser
-from ..vectorstore import get_pinecone_vectorstore
+from ..vectorstore import get_vectorstore
 from ..embeddings import get_embeddings_function
 import ast
 
@@ -134,7 +134,7 @@ def get_ToCs(version: str) :
         "version": version
     }
     embeddings_function = get_embeddings_function()
-    vectorstore = get_pinecone_vectorstore(embeddings_function, index_name="climateqa-v2")
+    vectorstore = get_vectorstore(provider="qdrant", embeddings=embeddings_function, index_name="climateqa")
     tocs = vectorstore.similarity_search_with_score(query="",filter = filters_text)
 
     # remove duplicates or almost duplicates
@@ -236,7 +236,7 @@ async def get_POC_documents_by_ToC_relevant_documents(
     filters_text_toc = {
         **filters,
         "chunk_type":"text",
-        "toc_level0": {"$in": toc_filters},
+        "toc_level0": toc_filters,  # Changed from {"$in": toc_filters} to direct list
         "version": version
         # "report_type": {}, # TODO  to be completed to choose the right documents / chapters according to the analysis of the question
     }
@@ -273,6 +273,22 @@ async def get_POC_documents_by_ToC_relevant_documents(
         "docs_images" : docs_images
     }
     
+def filter_for_full_report_documents(filters: dict) -> dict:
+    """
+    Filter for full report documents.
+    Returns a dictionary format compatible with all vectorstore providers.
+    """
+    # Start with the base filters
+    full_filters = filters.copy()
+    
+    # Add chunk_type filter
+    full_filters["chunk_type"] = "text"
+    
+    # Add report_type exclusion using the new _exclude suffix format
+    # This will be converted to appropriate OData filter by Azure Search wrapper
+    full_filters["report_type_exclude"] = ["SPM"]
+    
+    return full_filters
 
 async def get_IPCC_relevant_documents(
     query: str,
@@ -299,9 +315,9 @@ async def get_IPCC_relevant_documents(
     filters = {}
 
     if len(reports) > 0:
-        filters["short_name"] = {"$in":reports}
+        filters["short_name"] = reports  # Changed from {"$in":reports} to direct list
     else:
-        filters["source"] = { "$in": sources}
+        filters["source"] = sources  # Changed from {"$in": sources} to direct list
 
     # INIT 
     docs_summaries = []
@@ -323,18 +339,16 @@ async def get_IPCC_relevant_documents(
         filters_summaries = {
             **filters,
             "chunk_type":"text",
-            "report_type": { "$in":["SPM"]},
+            "report_type": ["SPM"],  # Changed from {"$in":["SPM"]} to direct list
         }
 
         docs_summaries = vectorstore.similarity_search_with_score(query=query,filter = filters_summaries,k = k_summary)
         docs_summaries = [x for x in docs_summaries if x[1] > threshold]
 
         # Search for k_total - k_summary documents in the full reports dataset
-        filters_full = {
-            **filters,
-            "chunk_type":"text",
-            "report_type": { "$nin":["SPM"]},
-        }
+        filters_full = filter_for_full_report_documents(filters)
+        
+        
         docs_full = vectorstore.similarity_search_with_score(query=query,filter = filters_full,k = k_total)
         
         if search_figures:

climateqa/engine/graph_retriever.py

@@ -60,10 +60,9 @@ async def retrieve_graphs(
         assert sources
         assert any([x in ["OWID"] for x in sources])
 
-        # Prepare base search kwargs
-        filters = {}
-
-        filters["source"] = {"$in": sources}
+        # Prepare base search kwargs for Azure AI Search
+        # Azure expects a filter string, e.g. "source eq 'OWID' or source eq 'IEA'"
+        filters = {"source":"OWID"}
 
         docs = vectorstore.similarity_search_with_score(query=query, filter=filters, k=k_total)
         

climateqa/engine/llm/openai.py

@@ -8,7 +8,6 @@ except Exception:
     pass
 
 def get_llm(model="gpt-4o-mini",max_tokens=1024, temperature=0.0, streaming=True,timeout=30, **kwargs):
-    
     llm = ChatOpenAI(
         model=model,
         api_key=os.environ.get("THEO_API_KEY", None),

climateqa/engine/talk_to_data/input_processing.py

@@ -10,6 +10,7 @@ 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
+import calendar
 
 async def detect_location_with_openai(sentence: str) -> str:
     """
@@ -118,7 +119,7 @@ async def detect_year_with_openai(sentence: str) -> str:
         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.
@@ -227,6 +228,55 @@ async def find_year(user_input: str) -> str| None:
         return None
     return year
 
+async def find_month(user_input: str) -> dict[str, str|None]:
+    """
+    Extracts month information from user input using an LLM.
+
+    This function analyzes the user's query to detect if a month is mentioned.
+    It returns both the month number (as a string, e.g. '7' for July) and the full English month name (e.g. 'July').
+    If no month is found, both values will be None.
+
+    Args:
+        user_input (str): The user's query text.
+
+    Returns:
+        dict[str, str|None]: A dictionary with keys:
+            - "month_number": the month number as a string (e.g. '7'), or None if not found
+            - "month_name": the full English month name (e.g. 'July'), or None if not found
+
+    Example:
+        >>> await find_month("Show me the temperature in Paris in July")
+        {'month_number': '7', 'month_name': 'July'}
+        >>> await find_month("Show me the temperature in Paris")
+        {'month_number': None, 'month_name': None}
+    """
+
+    llm = get_llm()
+    prompt = """
+    Extract the month (as a number from 1 to 12) mentioned in the following sentence.
+    Return the result as a Python list of integers. If no month is 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": user_input})
+    months_list = ast.literal_eval(response['array'])
+    if len(months_list) > 0:
+        month_number = int(months_list[0])
+        month_name = calendar.month_name[month_number]
+        return {
+            "month_number": str(month_number),
+            "month_name": month_name
+        }
+    else:
+        return {
+            "month_number" : None,
+            "month_name" : None
+        }
+
+
 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)
@@ -237,16 +287,28 @@ async def find_relevant_tables_per_plot(state: State, plot: Plot, llm, tables: l
     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
+async def find_param(state: State, param_name: str, mode: Literal['DRIAS', 'IPCC'] = 'DRIAS') -> dict[str, Optional[str]] | Location | None:
+    """
+    Retrieves a specific parameter (location, year, month, etc.) from the user's input using the appropriate extraction method.
 
     Args:
-        state (State): state of the workflow
-        param_name (str): name of the desired parameter
-        table (str): name of the table
+        state (State): The current state containing at least the user's input under 'user_input'.
+        param_name (str): The name of the parameter to extract. Supported: 'location', 'year', 'month'.
+        mode (Literal['DRIAS', 'IPCC']): The data mode to use for location extraction.
 
     Returns:
-        dict[str, Any] | None: 
+        - For 'location': a Location object (dict with keys like 'location', 'latitude', etc.), or None if not found.
+        - For 'year': a dict {'year': year or None}.
+        - For 'month': a dict {'month_number': str or None, 'month_name': str or None}.
+        - None if the parameter is not recognized or not found.
+
+    Example:
+        >>> await find_param(state, 'location')
+        {'location': 'Paris', 'latitude': ..., ...}
+        >>> await find_param(state, 'year')
+        {'year': '2050'}
+        >>> await find_param(state, 'month')
+        {'month_number': '7', 'month_name': 'July'}
     """
     if param_name == 'location':
         location = await find_location(state['user_input'], mode)
@@ -254,4 +316,7 @@ async def find_param(state: State, param_name:str, mode: Literal['DRIAS', 'IPCC'
     if param_name == 'year':
         year = await find_year(state['user_input'])
         return {'year': year}
-    return None
+    if param_name == 'month':
+        month = await find_month(state['user_input'])
+        return month
+    return None

climateqa/engine/talk_to_data/ipcc/config.py

@@ -6,16 +6,22 @@ from climateqa.engine.talk_to_data.config import IPCC_DATASET_URL
 IPCC_TABLES = [
     "mean_temperature",
     "total_precipitation",
+    "minimum_temperature",
+    "maximum_temperature"
 ]
 
 IPCC_INDICATOR_COLUMNS_PER_TABLE = {
     "mean_temperature": "mean_temperature",
-    "total_precipitation": "total_precipitation"
+    "total_precipitation": "total_precipitation",
+    "minimum_temperature": "minimum_temperature",
+    "maximum_temperature": "maximum_temperature"
 }
 
 IPCC_INDICATOR_TO_UNIT = {
     "mean_temperature": "°C",
-    "total_precipitation": "mm/day"
+    "total_precipitation": "mm/day",
+    "minimum_temperature": "°C",
+    "maximum_temperature": "°C"
 }
 
 IPCC_SCENARIO = [
@@ -30,7 +36,8 @@ IPCC_MODELS = []
 
 IPCC_PLOT_PARAMETERS = [
     'year',
-    'location'
+    'location',
+    'month'
 ]
 
 MACRO_COUNTRIES = ['JP',
@@ -63,7 +70,9 @@ HUGE_MACRO_COUNTRIES = ['CL',
 
 IPCC_INDICATOR_TO_COLORSCALE = {
     "mean_temperature": TEMPERATURE_COLORSCALE,
-    "total_precipitation": PRECIPITATION_COLORSCALE
+    "total_precipitation": PRECIPITATION_COLORSCALE,
+    "minimum_temperature": TEMPERATURE_COLORSCALE,
+    "maximum_temperature": TEMPERATURE_COLORSCALE,
 }
 
 IPCC_UI_TEXT = """
@@ -77,9 +86,12 @@ 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 
+- Yearly evolution of an indicator in a specific month at a specific location (historical + SSP Projections)
 
 Current available indicators :
 - Mean temperature 
+- Minimum temperature
+- Maximum temperature
 - Total precipitation
 
 For example, you can ask:  

climateqa/engine/talk_to_data/ipcc/plot_informations.py

@@ -47,4 +47,27 @@ Each grid point is colored according to the value of the indicator ({unit}), all
 - 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.
+"""
+
+def indicator_specific_month_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"]
+    if "month_name" not in params:
+        raise ValueError('"month_name" must be provided in params')
+    month = params["month_name"]
+    unit = IPCC_INDICATOR_TO_UNIT[indicator]
+    return f"""
+This plot shows how the climate indicator **{indicator}** evolves over time in **{location}** for the month of **{month}**.
+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}) for the selected month.
+Each line corresponds to a different scenario, allowing you to compare how {indicator} for month {month} might change under various future conditions.
+
+**Data source:**  
+- The data comes from the IPCC climate datasets (Parquet files) for the relevant indicator, location, and month.
+- For each year and scenario, the value of {indicator} for month {month} is extracted for the selected location.
+- 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.
 """

climateqa/engine/talk_to_data/ipcc/plots.py

@@ -5,8 +5,8 @@ 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.ipcc.plot_informations import choropleth_map_informations, indicator_evolution_informations, indicator_specific_month_evolution_informations
+from climateqa.engine.talk_to_data.ipcc.queries import indicator_for_given_year_query, indicator_per_year_and_specific_month_at_location_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:
@@ -102,6 +102,82 @@ indicator_evolution_at_location_historical_and_projections: Plot = {
     "short_name": "Evolution"
 }
 
+def plot_indicator_monthly_evolution_at_location(
+    params: dict,
+) -> Callable[[pd.DataFrame], Figure]:
+    """
+    Returns a function that generates a line plot showing the evolution of a climate indicator
+    for a specific month 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.
+            - month (str): Month name to plot.
+
+    Returns:
+        Callable[[pd.DataFrame], Figure]: Function that takes a DataFrame and returns a Plotly Figure.
+    """
+    indicator = params["indicator_column"]
+    location = params["location"]
+    month = params["month_name"]
+    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'Evolution of {indicator_label} in {month} 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_specific_month_evolution_at_location: Plot = {
+    "name": "Indicator specific month Evolution at Location (Historical + Projections)",
+    "description": (
+        "Shows how a climate indicator (e.g., rainfall, temperature) for a specific month changes over time at a specific location, "
+        "including historical data and future projections. "
+        "Useful for questions about the value or trend of an indicator for a given month at a location, "
+        "such as 'How does July temperature evolve in Paris over time?'. "
+        "Parameters: indicator_column (the climate variable), location (e.g., country, city), month (1-12)."
+    ),
+    "params": ["indicator_column", "location", "month"],
+    "plot_function": plot_indicator_monthly_evolution_at_location,
+    "sql_query": indicator_per_year_and_specific_month_at_location_query,
+    "plot_information": indicator_specific_month_evolution_informations,
+    "short_name": "Evolution for a specific month"
+}
+
 def plot_choropleth_map_of_country_indicator_for_specific_year(
     params: dict,
 ) -> Callable[[pd.DataFrame], Figure]:
@@ -167,6 +243,7 @@ def plot_choropleth_map_of_country_indicator_for_specific_year(
 
     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": (
@@ -185,5 +262,6 @@ choropleth_map_of_country_indicator_for_specific_year: Plot = {
 
 IPCC_PLOTS = [
     indicator_evolution_at_location_historical_and_projections,
-    choropleth_map_of_country_indicator_for_specific_year
+    choropleth_map_of_country_indicator_for_specific_year,
+    indicator_specific_month_evolution_at_location
 ]

climateqa/engine/talk_to_data/ipcc/queries.py

@@ -43,7 +43,7 @@ def indicator_per_year_at_location_query(
         return ""
 
     if country_code in MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_monthly_macro.parquet'"
         sql_query = f"""
         SELECT year, scenario, AVG({indicator_column}) as {indicator_column}
         FROM {table_path}
@@ -52,7 +52,7 @@ def indicator_per_year_at_location_query(
         ORDER BY year, scenario
         """
     elif country_code in HUGE_MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_annualy_macro.parquet'"
         sql_query = f"""
         SELECT year, scenario, {indicator_column}
         FROM {table_path}
@@ -75,6 +75,66 @@ def indicator_per_year_at_location_query(
         """
     return sql_query.strip()
 
+class IndicatorPerYearAndSpecificMonthAtLocationQueryParams(TypedDict, total=False):
+    """
+    Parameters for querying the evolution of an indicator per year for a specific month 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.
+        month (str): Month targeted
+    """
+    indicator_column: str
+    latitude: str
+    longitude: str
+    country_code: str
+    month: str
+
+def indicator_per_year_and_specific_month_at_location_query(
+    table: str, params: IndicatorPerYearAndSpecificMonthAtLocationQueryParams
+) -> str:
+    """
+    Builds an SQL query to get the evolution of an indicator per year for a specific month at a specific location.
+
+    Args:
+        table (str): SQL table of the indicator.
+        params (dict): Dictionary with required params:
+            - indicator_column (str)
+            - latitude (str or float)
+            - longitude (str or float)
+            - month (int)
+
+    Returns:
+        str: The SQL query string.
+    """
+    indicator_column = params.get("indicator_column")
+    latitude = params.get("latitude")
+    longitude = params.get("longitude")
+    country_code = params.get("country_code")
+    month = params.get('month_number')
+
+    if not all([indicator_column, latitude, longitude, country_code, month]):
+        return ""
+
+    if country_code in (MACRO_COUNTRIES+HUGE_MACRO_COUNTRIES):
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_monthly_macro.parquet'"
+        sql_query = f"""
+        SELECT year, scenario, {indicator_column}
+        FROM {table_path}
+        WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950 AND month={month}
+        ORDER BY year, scenario
+        """
+    else:
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}.parquet'"
+        sql_query = f"""
+        SELECT year, scenario, MEDIAN({indicator_column}) AS {indicator_column}
+        FROM {table_path}
+        WHERE latitude = {latitude} AND longitude = {longitude} AND year >= 1950 AND month={month}
+        GROUP BY scenario, year
+        """
+    return sql_query.strip()
 class IndicatorForGivenYearQueryParams(TypedDict, total=False):
     """
     Parameters for querying an indicator's values across locations for a specific year.
@@ -110,7 +170,7 @@ def indicator_for_given_year_query(
         return ""
 
     if country_code in MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_monthly_macro.parquet'"
         sql_query = f"""
         SELECT latitude, longitude, scenario, AVG({indicator_column}) as {indicator_column}
         FROM {table_path}
@@ -119,7 +179,7 @@ def indicator_for_given_year_query(
         ORDER BY latitude, longitude, scenario
         """
     elif country_code in HUGE_MACRO_COUNTRIES:
-        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_macro.parquet'"
+        table_path = f"'{IPCC_DATASET_URL}/{table.lower()}/{country_code}_annualy_macro.parquet'"
         sql_query = f"""
         SELECT latitude, longitude, scenario, {indicator_column}
         FROM {table_path}
@@ -141,4 +201,4 @@ def indicator_for_given_year_query(
         ORDER BY latitude, longitude, scenario
         """
 
-    return sql_query.strip()
+    return sql_query.strip()

climateqa/engine/talk_to_data/main.py

@@ -50,7 +50,7 @@ async def ask_drias(query: str, index_state: int = 0, user_id: str | None = None
 
     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"]
+        return None, None, None, None, [], [], [], [], 0, [], final_state["error"]
 
     sql_query = sql_queries[index_state]
     dataframe = result_dataframes[index_state]
@@ -112,7 +112,7 @@ async def ask_ipcc(query: str, index_state: int = 0, user_id: str | None = None)
 
     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"]
+        return None, None, None, None, [], [], [], [], 0, [], final_state["error"]
 
     sql_query = sql_queries[index_state]
     dataframe = result_dataframes[index_state]

climateqa/engine/talk_to_data/workflow/drias.py

@@ -125,11 +125,16 @@ async def drias_workflow(user_input: str) -> State:
                 'plot': plot,
                 'status': 'OK'
             }
+            
+    # Gather all required parameters in parallel
+    param_tasks = [
+            find_param(state, param_name, mode='DRIAS')
+            for param_name in DRIAS_PLOT_PARAMETERS
+        ]
+    param_results = await asyncio.gather(*param_tasks)
 
-    # Gather all required parameters
     params = {}
-    for param_name in DRIAS_PLOT_PARAMETERS:
-        param = await find_param(state, param_name, mode='DRIAS')
+    for param in param_results:
         if param:
             params.update(param)
 

climateqa/engine/talk_to_data/workflow/ipcc.py

@@ -125,12 +125,17 @@ async def ipcc_workflow(user_input: str) -> State:
             }
 
     # Gather all required parameters
+    param_tasks = [
+            find_param(state, param_name, mode='IPCC')
+            for param_name in IPCC_PLOT_PARAMETERS
+        ]
+    param_results = await asyncio.gather(*param_tasks)
+
     params = {}
-    for param_name in IPCC_PLOT_PARAMETERS:
-        param = await find_param(state, param_name, mode='IPCC')
+    for param in param_results:
         if param:
             params.update(param)
-
+            
     # Process all outputs in parallel using process_output
     tasks = [
         process_output(output_title, output['table'], output['plot'], params.copy())
@@ -152,10 +157,18 @@ async def ipcc_workflow(user_input: str) -> State:
 
     # 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"
+        state['error'] = (
+            "Sorry, I couldn't find any relevant table in our database to answer your question.\n"
+            "Try asking about a different climate indicator like temperature or precipitation."
+        )
     elif not errors['have_sql_query']:
-        state['error'] = "There is no relevant sql query on our database that can help to answer your question"
+        state['error'] = (
+            "Sorry, I couldn't generate a relevant SQL query to answer your question.\n"
+            "Try rephrasing your question to focus on a specific location, a year, or a month."
+        )
     elif not errors['have_dataframe']:
-        state['error'] = "There is no data in our table that can answer to your question"
-
+        state['error'] = (
+            "Sorry, there is no data in our tables that can answer your question.\n"
+            "Try asking about a more common location, or a different year."
+        )
     return state

climateqa/engine/vectorstore.py

@@ -1,11 +1,11 @@
-# Pinecone
-# More info at https://docs.pinecone.io/docs/langchain
-# And https://python.langchain.com/docs/integrations/vectorstores/pinecone
+# Azure AI Search: https://python.langchain.com/docs/integrations/vectorstores/azuresearch
 import os
-from pinecone import Pinecone
-from langchain_community.vectorstores import Pinecone as PineconeVectorstore
 
-# LOAD ENVIRONMENT VARIABLES
+# Azure AI Search imports
+from langchain_community.vectorstores.azuresearch import AzureSearch
+
+
+# Load environment variables
 try:
     from dotenv import load_dotenv
     load_dotenv()
@@ -13,44 +13,136 @@ except:
     pass
 
 
-
-
-def get_pinecone_vectorstore(embeddings,text_key = "content", index_name = os.getenv("PINECONE_API_INDEX")):
-
-    # # initialize pinecone
-    # pinecone.init(
-    #     api_key=os.getenv("PINECONE_API_KEY"),  # find at app.pinecone.io
-    #     environment=os.getenv("PINECONE_API_ENVIRONMENT"),  # next to api key in console
-    # )
-
-    # index_name = os.getenv("PINECONE_API_INDEX")
-    # vectorstore = Pinecone.from_existing_index(index_name, embeddings,text_key = text_key)
-
-    # return vectorstore
-
-    pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))
-    index = pc.Index(index_name)
-
-    vectorstore = PineconeVectorstore(
-        index, embeddings, text_key,
+class AzureSearchWrapper:
+    """
+    Wrapper class for Azure AI Search vectorstore to handle filter conversion.
+    
+    This wrapper automatically converts dictionary-style filters to Azure Search OData filter format,
+    ensuring seamless compatibility when switching from other providers.
+    """
+    
+    def __init__(self, azure_search_vectorstore):
+        self.vectorstore = azure_search_vectorstore
+        
+    def __getattr__(self, name):
+        """Delegate all other attributes to the wrapped vectorstore."""
+        return getattr(self.vectorstore, name)
+    
+    def _convert_dict_filter_to_odata(self, filter_dict):
+        """
+        Convert dictionary-style filters to Azure Search OData filter format.
+        
+        Args:
+            filter_dict (dict): Dictionary-style filter
+            
+        Returns:
+            str: OData filter string
+        """
+        if not filter_dict:
+            return None
+            
+        conditions = []
+        
+        for key, value in filter_dict.items():
+            if key.endswith('_exclude'):
+                # Handle exclusion filters (e.g., report_type_exclude)
+                base_key = key.replace('_exclude', '')
+                if isinstance(value, list):
+                    if len(value) == 1:
+                        conditions.append(f"{base_key} ne '{value[0]}'")
+                    else:
+                        exclude_conditions = [f"{base_key} ne '{v}'" for v in value]
+                        conditions.append(f"({' and '.join(exclude_conditions)})")
+                else:
+                    conditions.append(f"{base_key} ne '{value}'")
+            elif isinstance(value, list):
+                # Handle list values (equivalent to $in operator)
+                if len(value) == 1:
+                    conditions.append(f"{key} eq '{value[0]}'")
+                else:
+                    list_conditions = [f"{key} eq '{v}'" for v in value]
+                    conditions.append(f"({' or '.join(list_conditions)})")
+            else:
+                # Handle single values
+                conditions.append(f"{key} eq '{value}'")
+        
+        return " and ".join(conditions) if conditions else None
+    
+    def similarity_search_with_score(self, query, k=4, filter=None, **kwargs):
+        """Override similarity_search_with_score to convert filters."""
+        if filter is not None:
+            filter = self._convert_dict_filter_to_odata(filter)
+
+        return self.vectorstore.hybrid_search_with_score(
+            query=query, k=k, filters=filter, **kwargs
+        )
+
+    
+    def similarity_search(self, query, k=4, filter=None, **kwargs):
+        """Override similarity_search to convert filters."""
+        if filter is not None:
+            filter = self._convert_dict_filter_to_odata(filter)
+        
+        return self.vectorstore.similarity_search(
+            query=query, k=k, filter=filter, **kwargs
+        )
+    
+    def similarity_search_by_vector(self, embedding, k=4, filter=None, **kwargs):
+        """Override similarity_search_by_vector to convert filters."""
+        if filter is not None:
+            filter = self._convert_dict_filter_to_odata(filter)
+        
+        return self.vectorstore.similarity_search_by_vector(
+            embedding=embedding, k=k, filter=filter, **kwargs
+        )
+    
+    def as_retriever(self, search_type="similarity", search_kwargs=None, **kwargs):
+        """Override as_retriever to handle filter conversion in search_kwargs."""
+        if search_kwargs and "filter" in search_kwargs:
+            # Convert the filter in search_kwargs
+            search_kwargs = search_kwargs.copy()  # Don't modify the original
+            if search_kwargs["filter"] is not None:
+                search_kwargs["filter"] = self._convert_dict_filter_to_odata(search_kwargs["filter"])
+        
+        return self.vectorstore.as_retriever(
+            search_type=search_type, search_kwargs=search_kwargs, **kwargs
+        )
+
+
+def get_azure_search_vectorstore(embeddings, text_key="content", index_name=None):
+    """
+    Create an Azure AI Search vectorstore instance.
+    
+    Args:
+        embeddings: The embeddings function to use
+        text_key: The key for text content in the payload (default: "content")
+        index_name: The name of the Azure Search index
+    
+    Returns:
+        AzureSearchWrapper: A wrapped Azure AI Search vectorstore instance with filter compatibility
+    """
+    # Get Azure AI Search configuration from environment variables
+    azure_search_endpoint = os.getenv("AI_SEARCH_INDEX_ENDPOINT")
+    azure_search_key = os.getenv("AI_SEARCH_KEY")
+    
+    if not azure_search_endpoint:
+        raise ValueError("AI_SEARCH_INDEX_ENDPOINT environment variable is required")
+    
+    if not azure_search_key:
+        raise ValueError("AI_SEARCH_KEY environment variable is required")
+    
+    if not index_name:
+        raise ValueError("index_name must be provided for Azure Search")
+    
+    # Create Azure Search vectorstore
+    vectorstore = AzureSearch(
+        azure_search_endpoint=azure_search_endpoint,
+        azure_search_key=azure_search_key,
+        index_name=index_name,
+        embedding_function=embeddings.embed_query,
+        content_key=text_key,
     )
-    return vectorstore
-
-
-
-# def get_pinecone_retriever(vectorstore,k = 10,namespace = "vectors",sources = ["IPBES","IPCC"]):
-
-#     assert isinstance(sources,list)
-
-#     # Check if all elements in the list are either IPCC or IPBES
-#     filter = {
-#         "source": { "$in":sources},
-#     }
-
-#     retriever = vectorstore.as_retriever(search_kwargs={
-#         "k": k,
-#         "namespace":"vectors",
-#         "filter":filter
-#     })
+    
+    # Wrap the vectorstore to handle filter conversion
+    return AzureSearchWrapper(vectorstore)
 
-#     return retriever

climateqa/utils.py

@@ -25,7 +25,7 @@ def remove_duplicates_keep_highest_score(documents):
     unique_docs = {}
     
     for doc in documents:
-        doc_id = doc.metadata.get('doc_id')
+        doc_id = doc.metadata.get('id')
         if doc_id in unique_docs:
             if doc.metadata['reranking_score'] > unique_docs[doc_id].metadata['reranking_score']:
                 unique_docs[doc_id] = doc

front/tabs/tab_ipcc.py

@@ -68,6 +68,8 @@ def show_filter_by_scenario(table_names, index_state, dataframes):
         return gr.update(visible=False)
         
 def filter_by_scenario(dataframes, figures, table_names, index_state, scenario):
+    if len(dataframes) == 0:
+        return None, None 
     df = dataframes[index_state]
     if not table_names[index_state].startswith("Map"):
         return df, figures[index_state](df)

requirements.txt

@@ -1,6 +1,9 @@
 gradio==5.0.2
 azure-storage-file-share==12.11.1
 azure-storage-blob==12.23.0
+# Azure AI Search support
+azure-search-documents>=11.4.0
+azure-core>=1.29.0
 python-dotenv==1.0.0
 langchain==0.2.1
 langchain_openai==0.1.7

style.css

@@ -661,7 +661,6 @@ a {
 
 #sql-query textarea{
     min-height: 200px !important;
-
 }
 
 #sql-query span{