Update app.py

app.py

@@ -7,31 +7,81 @@ from appStore.prep_utils import create_documents, get_client
 from appStore.embed import hybrid_embed_chunks
 from appStore.search import hybrid_search
 from appStore.region_utils import load_region_data, get_country_name, get_regions
-from appStore.tfidf_extraction import extract_top_keywords 
+#from appStore.tfidf_extraction import extract_top_keywords  # TF-IDF part commented out
 from torch import cuda
 import json
 from datetime import datetime
 
+###########################################
+# Helper functions for data processing
+###########################################
+
+# New helper: Truncate a text to a given (approximate) token count.
+def truncate_to_tokens(text, max_tokens):
+    tokens = text.split()  # simple approximation
+    if len(tokens) > max_tokens:
+        return " ".join(tokens[:max_tokens])
+    return text
+
+# Build a context string for a single result using title, objectives and description.
+def build_context_for_result(res):
+    metadata = res.payload.get('metadata', {})
+    # Compute title if not already present.
+    title = metadata.get("title", compute_title(metadata))
+    objectives = metadata.get("objectives", "")
+    # Use description.en if available; otherwise use description.de.
+    desc_en = metadata.get("description.en", "").strip()
+    desc_de = metadata.get("description.de", "").strip()
+    description = desc_en if desc_en != "" else desc_de
+    return f"{title}\n{objectives}\n{description}"
+
+# Updated highlight: return HTML that makes the matched query red and bold.
+def highlight_query(text, query):
+    pattern = re.compile(re.escape(query), re.IGNORECASE)
+    return pattern.sub(lambda m: f"<span style='color:red; font-weight:bold;'>{m.group(0)}</span>", text)
+
+# Helper: Format project id (e.g., "201940485" -> "2019.4048.5")
+def format_project_id(pid):
+    s = str(pid)
+    if len(s) > 5:
+        return s[:4] + "." + s[4:-1] + "." + s[-1]
+    return s
 
+# Helper: Compute title from metadata using name.en (or name.de if empty)
+def compute_title(metadata):
+    name_en = metadata.get("name.en", "").strip()
+    name_de = metadata.get("name.de", "").strip()
+    base = name_en if name_en else name_de
+    pid = metadata.get("id", "")
+    if base and pid:
+        return f"{base} [{format_project_id(pid)}]"
+    return base or "No Title"
 
-#model_config = getconfig("model_params.cfg")
-###########
-# ToDo move functions to utils and model specifications to config file!
-# Configuration for the dedicated model
-#https://qu2d8m6dmsollhly.us-east-1.aws.endpoints.huggingface.cloud
-DEDICATED_MODEL = "meta-llama/Llama-3.1-8B-Instruct"
-DEDICATED_ENDPOINT = "https://nwea79x4q1clc89l.eu-west-1.aws.endpoints.huggingface.cloud"
-# Write access token from the settings
-WRITE_ACCESS_TOKEN = st.secrets["Llama_3_1"]
+# Load CRS lookup CSV and define a lookup function.
+crs_lookup = pd.read_csv("docStore/crs5_code.csv")  # Assumes columns: "code" and "new_crs_value"
+def lookup_crs_value(crs_key):
+    row = crs_lookup[crs_lookup["code"] == crs_key]
+    if not row.empty:
+        # Convert to integer (drop decimals) and then to string.
+        try:
+            return str(int(float(row.iloc[0]["new_crs_value"])))
+        except:
+            return str(row.iloc[0]["new_crs_value"])
+    return ""
 
+###########################################
+# RAG Answer function (Change 1 & 2 & 3)
+###########################################
 def get_rag_answer(query, top_results):
-    context = "\n\n".join([res.payload["page_content"] for res in top_results])
-    #max_context_chars = 23500  
-    #if len(context) > max_context_chars:
-    #    context = context[:max_context_chars]
+    # Build context from each top result using title, objectives, and description.
+    context = "\n\n".join([build_context_for_result(res) for res in top_results])
+    # Truncate context to 11500 tokens (approximation)
+    context = truncate_to_tokens(context, 11500)
+    # Improved prompt with role instruction and formatting instruction.
     prompt = (
         "You are a project portfolio adviser at the development cooperation GIZ. "
-        "Using the following context, answer the question in english precisely. "
+        "Using the following context, answer the question in English precisely. "
+        "Ensure that any project title mentioned in your answer is wrapped in ** (markdown bold). "
         "Only output the final answer below, without repeating the context or question.\n\n"
         f"Context:\n{context}\n\n"
         f"Question: {query}\n\n"
@@ -52,24 +102,9 @@ def get_rag_answer(query, top_results):
     else:
         return f"Error in generating answer: {response.text}"
 
-# Helper: Format project id (e.g., "201940485" -> "2019.4048.5")
-def format_project_id(pid):
-    s = str(pid)
-    if len(s) > 5:
-        return s[:4] + "." + s[4:-1] + "." + s[-1]
-    return s
-
-# Helper: Compute title from metadata using name.en (or name.de if empty)
-def compute_title(metadata):
-    name_en = metadata.get("name.en", "").strip()
-    name_de = metadata.get("name.de", "").strip()
-    base = name_en if name_en else name_de
-    pid = metadata.get("id", "")
-    if base and pid:
-        return f"{base} [{format_project_id(pid)}]"
-    return base or "No Title"
-
-# Helper: Get CRS filter options from all documents
+###########################################
+# CRS Options using lookup (Change 7)
+###########################################
 @st.cache_data
 def get_crs_options(_client, collection_name):
     results = hybrid_search(_client, "", collection_name)
@@ -77,20 +112,23 @@ def get_crs_options(_client, collection_name):
     crs_set = set()
     for res in all_results:
         metadata = res.payload.get('metadata', {})
-        crs_value = metadata.get("crs_value", "").strip()
         crs_key = metadata.get("crs_key", "").strip()
-        if crs_key or crs_key:
-            # Convert crs_key to integer if possible:
-            try:
-                crs_int = int(float(crs_key))
-            except:
-                crs_int = crs_key
-            crs_combined = f"{crs_int}: {crs_value}"
+        if crs_key:
+            new_value = lookup_crs_value(crs_key)
+            crs_combined = f"{crs_key}: {new_value}"
             crs_set.add(crs_combined)
     return sorted(crs_set)
 
-# Revised filter_results: Allow missing end_year or CRS; enforce CRS only when present.
-def filter_results(results, country_filter, region_filter, end_year_range, crs_filter):
+###########################################
+# Revised filter_results with budget filtering (Change 7 & 9)
+###########################################
+def parse_budget(value):
+    try:
+        return float(value)
+    except:
+        return 0.0
+
+def filter_results(results, country_filter, region_filter, end_year_range, crs_filter, budget_filter):
     filtered = []
     for r in results:
         metadata = r.payload.get('metadata', {})
@@ -118,18 +156,21 @@ def filter_results(results, country_filter, region_filter, end_year_range, crs_f
             countries_in_region = c_list
 
         crs_key = metadata.get("crs_key", "").strip()
-        crs_value = metadata.get("crs_value", "").strip()
-        try:
-            crs_int = int(float(crs_key))
-        except:
-            crs_int = crs_key
-        crs_combined = f"{crs_key}: {crs_int}" if (crs_key or crs_key) else ""
-        # Only enforce CRS filter if result has a CRS value.
+        # Use lookup value instead of stored crs_value.
+        new_crs_value = lookup_crs_value(crs_key)
+        crs_combined = f"{crs_key}: {new_crs_value}" if crs_key else ""
+
+        # Enforce CRS filter only if specified.
         if crs_filter != "All/Not allocated" and crs_combined:
             if crs_filter != crs_combined:
                 continue
 
-        # Allow projects with no valid end_year to pass (if end_year_val is 0)
+        # Budget filtering: parse total_project value.
+        budget_value = parse_budget(metadata.get('total_project', "0"))
+        # Only keep results with budget >= budget_filter (in million euros, so multiply by 1e6)
+        if budget_value < (budget_filter * 1e6):
+            continue
+
         year_ok = True if end_year_val == 0 else (end_year_range[0] <= end_year_val <= end_year_range[1])
 
         if ((country_filter == "All/Not allocated" or (selected_iso_code and selected_iso_code in c_list))
@@ -138,19 +179,44 @@ def filter_results(results, country_filter, region_filter, end_year_range, crs_f
             filtered.append(r)
     return filtered
 
-# Get the device to be used (GPU or CPU)
+###########################################
+# Get device
+###########################################
 device = 'cuda' if cuda.is_available() else 'cpu'
 
+###########################################
+# App heading and About button (Change 5 & 6)
+###########################################
 st.set_page_config(page_title="SEARCH IATI", layout='wide')
-st.title("GIZ Project Database (PROTOTYPE)")
+col_title, col_about = st.columns([8,2])
+with col_title:
+    st.markdown("<h1 style='text-align:center;'>GIZ Project Database (PROTOTYPE)</h1>", unsafe_allow_html=True)
+with col_about:
+    with st.expander("About"):
+        st.markdown(
+            """
+            **This app is a prototype for testing purposes.**  
+            The intended use is to explore AI-generated answers using publicly available project data from the German International Cooperation Society (GIZ) as of 23rd February 2025.  
+            **Please do NOT enter sensitive or personal information.**  
+            Note: The generated answers are AI-generated and may be wrong or misleading.
+            """)
+            
+###########################################
+# Query input and budget slider (Change 9)
+###########################################
 var = st.text_input("Enter Search Question")
+min_budget = st.slider("Minimum Project Budget (Million €)", min_value=0.0, max_value=100.0, value=0.0)
 
-
-# Load the region lookup CSV
+###########################################
+# Load region lookup CSV
+###########################################
 region_lookup_path = "docStore/regions_lookup.csv"
 region_df = load_region_data(region_lookup_path)
 
-####################  Create the embeddings collection and save ######################
+
+###########################################
+# Create the embeddings collection and save
+###########################################
 # the steps below need to be performed only once and then commented out any unnecssary compute over-run
 ##### First we process and create the chunks for relvant data source
 #chunks = process_giz_worldwide()
@@ -160,7 +226,9 @@ region_df = load_region_data(region_lookup_path)
 collection_name = "giz_worldwide"
 #hybrid_embed_chunks(docs=temp_doc, collection_name=collection_name, del_if_exists=True)
 
-################### Hybrid Search #####################################################
+###########################################
+# Hybrid Search and Filters Setup
+###########################################
 client = get_client()
 print(client.get_collections())
 max_end_year = get_max_end_year(client, collection_name)
@@ -192,11 +260,10 @@ client = get_client()
 country_name_mapping, iso_code_to_sub_region = get_country_name_and_region_mapping(client, collection_name, region_df)
 unique_country_names = sorted(country_name_mapping.keys())
 
-# Layout filters in columns
+# Layout filter columns
 col1, col2, col3, col4 = st.columns([1, 1, 1, 1])
 with col1:
     region_filter = st.selectbox("Region", ["All/Not allocated"] + sorted(unique_sub_regions))
-# Compute filtered_country_names based on region_filter:
 if region_filter == "All/Not allocated":
     filtered_country_names = unique_country_names
 else:
@@ -214,19 +281,19 @@ with col4:
 # Checkbox for exact matches
 show_exact_matches = st.checkbox("Show only exact matches", value=False)
 
-# Run the search
+###########################################
+# Run the search and apply filters
+###########################################
 results = hybrid_search(client, var, collection_name, limit=500)
 semantic_all = results[0]
 lexical_all = results[1]
-
 semantic_all = [r for r in semantic_all if len(r.payload["page_content"]) >= 5]
 lexical_all = [r for r in lexical_all if len(r.payload["page_content"]) >= 5]
-
 semantic_thresholded = [r for r in semantic_all if r.score >= 0.0]
 
-filtered_semantic = filter_results(semantic_thresholded, country_filter, region_filter, end_year_range, crs_filter)
-filtered_lexical = filter_results(lexical_all, country_filter, region_filter, end_year_range, crs_filter)
-
+# Pass the budget filter (min_budget) into filter_results
+filtered_semantic = filter_results(semantic_thresholded, country_filter, region_filter, end_year_range, crs_filter, min_budget)
+filtered_lexical = filter_results(lexical_all, country_filter, region_filter, end_year_range, crs_filter, min_budget)
 filtered_semantic_no_dupe = remove_duplicates(filtered_semantic)
 filtered_lexical_no_dupe = remove_duplicates(filtered_lexical)
 
@@ -236,193 +303,149 @@ def format_currency(value):
     except (ValueError, TypeError):
         return value
 
-# Helper to highlight query matches (case-insensitive)
-def highlight_query(text, query):
-    pattern = re.compile(re.escape(query), re.IGNORECASE)
-    return pattern.sub(lambda m: f"**{m.group(0)}**", text)
-
-###############################
-# Display Lexical Results Branch
-###############################
+###########################################
+# Display Results (Lexical and Semantic)
+###########################################
+# --- Lexical Results Branch ---
 if show_exact_matches:
-    st.write(f"Showing **Top 15 Lexical Search results** for query: {var}")
+    st.write("Showing **Top 15 Lexical Search results**")
     query_substring = var.strip().lower()
     lexical_substring_filtered = [r for r in lexical_all if query_substring in r.payload["page_content"].lower()]
-    filtered_lexical = filter_results(lexical_substring_filtered, country_filter, region_filter, end_year_range, crs_filter)
+    filtered_lexical = filter_results(lexical_substring_filtered, country_filter, region_filter, end_year_range, crs_filter, min_budget)
     filtered_lexical_no_dupe = remove_duplicates(filtered_lexical)
     if not filtered_lexical_no_dupe:
         st.write('No exact matches, consider unchecking "Show only exact matches"')
     else:
         top_results = filtered_lexical_no_dupe[:10]
         rag_answer = get_rag_answer(var, top_results)
-        st.markdown(f"**{var}**")
+        # Use the query as heading; increase size and center it.
+        st.markdown(f"<h2 style='text-align:center; font-size:2.5em;'>Query: {var}</h2>", unsafe_allow_html=True)
         st.write(rag_answer)
         st.divider()
         for res in top_results:
             metadata = res.payload.get('metadata', {})
             if "title" not in metadata:
                 metadata["title"] = compute_title(metadata)
-            # Highlight query in red and bold (allow HTML)
-            display_title = (
-                st.markdown(highlight_query(metadata["title"], var), unsafe_allow_html=True)
-                if var.strip() else metadata["title"]
-            )
-            proj_id = metadata.get('id', 'Unknown')
-            st.markdown(f"#### {metadata['title']}")
-            countries = metadata.get('countries')
-            client_name = metadata.get('client', 'Unknown Client')
-            start_year = metadata.get('start_year', None)
-            end_year = metadata.get('end_year', None)
-            total_volume = metadata.get('total_volume', "Unknown")
-            total_project = metadata.get('total_project', "Unknown")
+            # Highlight query matches in title (rendered with HTML)
+            title_html = highlight_query(metadata["title"], var) if var.strip() else metadata["title"]
+            st.markdown(f"#### {title_html}", unsafe_allow_html=True)
+            # Build snippet from objectives and description
             objectives = metadata.get("objectives", "")
-            desc_de = metadata.get("description.de", "")
-            desc_en = metadata.get("description.en", "")
-            description = desc_de if desc_de else desc_en
+            desc_en = metadata.get("description.en", "").strip()
+            desc_de = metadata.get("description.de", "").strip()
+            description = desc_en if desc_en != "" else desc_de
             full_snippet = f"{objectives} {description}"
             words = full_snippet.split()
             preview_word_count = 90
             preview_text = " ".join(words[:preview_word_count])
             remainder_text = " ".join(words[preview_word_count:])
-            preview_text = highlight_query(preview_text, var) if var.strip() else preview_text
-            st.write(preview_text)
-            if remainder_text:
-                with st.expander("Show more"):
-                    st.write(remainder_text)
-            
-            full_text = res.payload['page_content']
-            top_keywords = extract_top_keywords(full_text, top_n=5)
-            if top_keywords:
-                st.markdown(f"_{' · '.join(top_keywords)}_")
-            
-            # Format year range and budget info
-            start_year_str = extract_year(start_year) if start_year else "Unknown"
-            end_year_str = extract_year(end_year) if end_year else "Unknown"
-            formatted_project_budget = format_currency(total_project)
-            formatted_total_volume = format_currency(total_volume)
-            
-            # Compute matched country names (as before)
-            try:
-                c_list = json.loads(metadata.get('countries', "[]").replace("'", '"'))
-            except json.JSONDecodeError:
-                c_list = []
-            matched_countries = []
-            for code in c_list:
-                if len(code) == 2:
-                    resolved_name = get_country_name(code.upper(), region_df)
-                    if resolved_name.upper() != code.upper():
-                        matched_countries.append(resolved_name)
-            
-            # Compute CRS combined value as integer
-            crs_key = metadata.get("crs_key", "").strip()
-            crs_value = metadata.get("crs_value", "").strip()
-            try:
-                crs_int = int(float(crs_key))
-            except:
-                crs_int = crs_key
-            crs_combined = f"{crs_int}: {crs_value}" if (crs_key or crs_value) else "Unknown"
-            
-            # Build the additional text with original details, then add Sector and contact.
-            additional_text = (
-                f"Commissioned by **{client_name}**\n"
-                f"Projekt duration **{start_year_str}-{end_year_str}**\n"
-                f"Budget: Project: **{formatted_project_budget}**, Total volume: **{formatted_total_volume}**\n"
-                f"Country: **{', '.join(matched_countries)}**\n"
-                f"Sector: **{crs_combined}**"
-            )
-            #contact = metadata.get("contact", "").strip()
-            #if contact and contact.lower() != "[email protected]":
-            #    additional_text += f" | Contact: **{contact}**"
-            
-            st.markdown(additional_text)
+            st.markdown(highlight_query(preview_text, var), unsafe_allow_html=True)
+            # Create two columns: left for "Show more" (remainder text) and right for additional details.
+            col_left, col_right = st.columns(2)
+            with col_left:
+                if remainder_text:
+                    with st.expander("Show more"):
+                        st.write(remainder_text)
+            with col_right:
+                # Format additional text with line breaks using <br>
+                start_year = metadata.get('start_year', None)
+                end_year = metadata.get('end_year', None)
+                start_year_str = extract_year(start_year) if start_year else "Unknown"
+                end_year_str = extract_year(end_year) if end_year else "Unknown"
+                total_project = metadata.get('total_project', "Unknown")
+                total_volume = metadata.get('total_volume', "Unknown")
+                formatted_project_budget = format_currency(total_project)
+                formatted_total_volume = format_currency(total_volume)
+                try:
+                    c_list = json.loads(metadata.get('countries', "[]").replace("'", '"'))
+                except json.JSONDecodeError:
+                    c_list = []
+                matched_countries = []
+                for code in c_list:
+                    if len(code) == 2:
+                        resolved_name = get_country_name(code.upper(), region_df)
+                        if resolved_name.upper() != code.upper():
+                            matched_countries.append(resolved_name)
+                crs_key = metadata.get("crs_key", "").strip()
+                new_crs_value = lookup_crs_value(crs_key)
+                crs_combined = f"{crs_key}: {new_crs_value}" if crs_key else "Unknown"
+                client_name = metadata.get('client', 'Unknown Client')
+                contact = metadata.get("contact", "").strip()
+                additional_text = (
+                    f"Commissioned by **{client_name}**<br>"
+                    f"Projekt duration **{start_year_str}-{end_year_str}**<br>"
+                    f"Budget: Project: **{formatted_project_budget}**, Total volume: **{formatted_total_volume}**<br>"
+                    f"Country: **{', '.join(matched_countries)}**<br>"
+                    f"Sector: **{crs_combined}**"
+                )
+                if contact and contact.lower() != "[email protected]":
+                    additional_text += f"<br>Contact: **{contact}**"
+                st.markdown(additional_text, unsafe_allow_html=True)
             st.divider()
 
-###############################
-# Display Semantic Results Branch
-###############################
+# --- Semantic Results Branch ---
 else:
     if not filtered_semantic_no_dupe:
         st.write("No relevant results found.")
     else:
         top_results = filtered_semantic_no_dupe[:10]
         rag_answer = get_rag_answer(var, top_results)
-        st.markdown(f"**{var}**")
+        st.markdown(f"<h2 style='text-align:center; font-size:2.5em;'>Query: {var}</h2>", unsafe_allow_html=True)
         st.write(rag_answer)
         st.divider()
-        st.write(f"Showing **Top 15 Semantic Search results** for query: {var}")
+        st.write("Showing **Top 15 Semantic Search results**")
         for res in top_results:
             metadata = res.payload.get('metadata', {})
             if "title" not in metadata:
                 metadata["title"] = compute_title(metadata)
-            display_title = metadata["title"]
-            st.markdown(f"#### {display_title}")
-            countries = metadata.get('countries')
-            client_name = metadata.get('client', 'Unknown Client')
-            start_year = metadata.get('start_year', None)
-            end_year = metadata.get('end_year', None)
-            total_volume = metadata.get('total_volume', "Unknown")
-            total_project = metadata.get('total_project', "Unknown")
+            st.markdown(f"#### {metadata['title']}")
             objectives = metadata.get("objectives", "")
-            desc_de = metadata.get("description.de", "")
-            desc_en = metadata.get("description.en", "")
-            description = desc_de if desc_de else desc_en
+            desc_en = metadata.get("description.en", "").strip()
+            desc_de = metadata.get("description.de", "").strip()
+            description = desc_en if desc_en != "" else desc_de
             full_snippet = f"{objectives} {description}"
             words = full_snippet.split()
             preview_word_count = 90
             preview_text = " ".join(words[:preview_word_count])
             remainder_text = " ".join(words[preview_word_count:])
             st.write(preview_text)
-            if remainder_text:
-                with st.expander("Show more"):
-                    st.write(remainder_text)
-            
-            top_keywords = extract_top_keywords(res.payload['page_content'], top_n=5)
-            if top_keywords:
-                st.markdown(f"_{' · '.join(top_keywords)}_")
-            
-            # Format year range and budget info
-            start_year_str = extract_year(start_year) if start_year else "Unknown"
-            end_year_str = extract_year(end_year) if end_year else "Unknown"
-            formatted_project_budget = format_currency(total_project)
-            formatted_total_volume = format_currency(total_volume)
-            
-            # Compute matched country names (as before)
-            try:
-                c_list = json.loads(metadata.get('countries', "[]").replace("'", '"'))
-            except json.JSONDecodeError:
-                c_list = []
-            matched_countries = []
-            for code in c_list:
-                if len(code) == 2:
-                    resolved_name = get_country_name(code.upper(), region_df)
-                    if resolved_name.upper() != code.upper():
-                        matched_countries.append(resolved_name)
-            
-            # Compute CRS combined value
-            crs_key = metadata.get("crs_key", "").strip()
-            crs_value = metadata.get("crs_value", "").strip()
-            try:
-                crs_int = int(float(crs_key))
-            except:
-                crs_int = crs_key
-            crs_combined = f"{crs_int}: {crs_value}" if (crs_key or crs_value) else "Unknown"
-            
-            # Build the additional text with original details, then add Sector and contact.
-            additional_text = (
-                f"Commissioned by **{client_name}**\n"
-                f"Projekt duration **{start_year_str}-{end_year_str}**\n"
-                f"Budget: Project: **{formatted_project_budget}**, Total volume: **{formatted_total_volume}**\n"
-                f"Country: **{', '.join(matched_countries)}**\n"
-                f"Sector: **{crs_combined}**"
-            )
-            #contact = metadata.get("contact", "").strip()
-            #if contact and contact.lower() != "[email protected]":
-            #    additional_text += f" | Contact: **{contact}**"
-            
-            st.markdown(additional_text)
-            st.divider()                
-    #  for i in results: 
-    #      st.subheader(str(i.metadata['id'])+":"+str(i.metadata['title_main']))
-    #      st.caption(f"Status:{str(i.metadata['status'])}, Country:{str(i.metadata['country_name'])}")
-    #      st.write(i.page_content)
-    #      st.divider()
+            col_left, col_right = st.columns(2)
+            with col_left:
+                if remainder_text:
+                    with st.expander("Show more"):
+                        st.write(remainder_text)
+            with col_right:
+                start_year = metadata.get('start_year', None)
+                end_year = metadata.get('end_year', None)
+                start_year_str = extract_year(start_year) if start_year else "Unknown"
+                end_year_str = extract_year(end_year) if end_year else "Unknown"
+                total_project = metadata.get('total_project', "Unknown")
+                total_volume = metadata.get('total_volume', "Unknown")
+                formatted_project_budget = format_currency(total_project)
+                formatted_total_volume = format_currency(total_volume)
+                try:
+                    c_list = json.loads(metadata.get('countries', "[]").replace("'", '"'))
+                except json.JSONDecodeError:
+                    c_list = []
+                matched_countries = []
+                for code in c_list:
+                    if len(code) == 2:
+                        resolved_name = get_country_name(code.upper(), region_df)
+                        if resolved_name.upper() != code.upper():
+                            matched_countries.append(resolved_name)
+                crs_key = metadata.get("crs_key", "").strip()
+                new_crs_value = lookup_crs_value(crs_key)
+                crs_combined = f"{crs_key}: {new_crs_value}" if crs_key else "Unknown"
+                client_name = metadata.get('client', 'Unknown Client')
+                contact = metadata.get("contact", "").strip()
+                additional_text = (
+                    f"Commissioned by **{client_name}**<br>"
+                    f"Projekt duration **{start_year_str}-{end_year_str}**<br>"
+                    f"Budget: Project: **{formatted_project_budget}**, Total volume: **{formatted_total_volume}**<br>"
+                    f"Country: **{', '.join(matched_countries)}**<br>"
+                    f"Sector: **{crs_combined}**"
+                )
+                if contact and contact.lower() != "[email protected]":
+                    additional_text += f"<br>Contact: **{contact}**"
+                st.markdown(additional_text, unsafe_allow_html=True)
+            st.divider()