Local updates

.gitignore

@@ -18,4 +18,7 @@ config.yaml
 .ipynb_checkpoints
 llm_rag
 *.ipynb
-.git*
+.git*
+*.csv
+ug
+.cache

app_dev.py

@@ -0,0 +1,242 @@
+import shutil
+import os
+import streamlit as st
+from huggingface_hub import snapshot_download
+
+from src.config_loader import load_config, get_api_key
+from src.ingest import get_chroma_collection, ingest_documents
+from src.retriever import clear_collection_cache, retrieve
+from src.llm import list_models
+from src.peri import APPROVED_OPTIONS
+from src.query_engine import understand_query, categorize_query, init_query, analyze_committment_to_vc
+from src.prompts import dict_to_string
+
+snapshot_download(repo_id="CGIAR/peri-kb", 
+                  repo_type="dataset", 
+                  allow_patterns="ug/*",
+                  token=os.getenv('HF_TOKEN'), 
+                  local_dir="./"
+                  )
+shutil.copytree("./ug", "./", dirs_exist_ok=True)
+
+
+def render_sidebar():
+    """Render sidebar with provider/model selectors, web search toggle, and KB stats."""
+    cfg = st.session_state.cfg
+
+    with st.sidebar:
+        st.header("Settings")
+
+        # --- Provider dropdown ---
+        providers = ["openai", "anthropic", "gemini", "meta-llama"]
+        current_provider = cfg.get("llm", {}).get("provider", "openai")
+        provider_index = providers.index(current_provider) if current_provider in providers else 0
+
+        provider = st.selectbox(
+            "LLM Provider",
+            providers,
+            index=provider_index,
+            key="sidebar_provider",
+        )
+
+        # Update cfg in session when provider changes
+        if provider != cfg.get("llm", {}).get("provider"):
+            cfg.setdefault("llm", {})["provider"] = provider
+
+        # --- Model dropdown (cached per provider) ---
+        # Invalidate model cache if provider changed
+        prev_provider_key = "prev_provider"
+        if st.session_state.get(prev_provider_key) != provider:
+            for p in providers:
+                st.session_state.pop(f"models_{p}", None)
+            st.session_state[prev_provider_key] = provider
+
+        models_cache_key = f"models_{provider}"
+        if models_cache_key not in st.session_state:
+            api_key = get_api_key(cfg, provider)
+            if api_key:
+                try:
+                    st.session_state[models_cache_key] = list_models(provider, api_key)
+                except Exception:
+                    st.session_state[models_cache_key] = []
+            else:
+                st.session_state[models_cache_key] = []
+
+        available_models = st.session_state[models_cache_key]
+        current_model = cfg.get("llm", {}).get("model", "")
+
+        if available_models:
+            model_index = (
+                available_models.index(current_model)
+                if current_model in available_models
+                else 0
+            )
+            model = st.selectbox(
+                "Model",
+                available_models,
+                index=model_index,
+                key="sidebar_model",
+            )
+        else:
+            model = st.text_input(
+                "Model",
+                value=current_model,
+                key="sidebar_model_text",
+            )
+
+        # Update cfg in session when model changes
+        if model != cfg.get("llm", {}).get("model"):
+            cfg.setdefault("llm", {})["model"] = model
+
+        # --- Web search toggle ---
+        web_enabled = cfg.get("web_search", {}).get("enabled", False)
+        web_toggle = st.toggle("Web search", value=web_enabled, key="sidebar_web_search")
+        cfg.setdefault("web_search", {})["enabled"] = web_toggle
+
+        st.divider()
+
+        # --- Knowledge base stats ---
+        st.subheader("Knowledge Base")
+        try:
+            collection = get_chroma_collection(cfg)
+            chunk_count = collection.count()
+            st.metric("Chunks indexed", chunk_count)
+        except Exception as e:
+            st.warning(f"Could not read knowledge base: {e}")
+            chunk_count = 0
+
+        # --- Re-ingest button ---
+        if st.button("Re-ingest documents", use_container_width=True):
+            st.info("Ingestion may take a few minutes for large document collections...")
+            with st.spinner("Ingesting documents..."):
+                try:
+                    count = ingest_documents(cfg)
+                    clear_collection_cache()
+                    st.success(f"Ingested {count} chunks.")
+                    # Clear cached data so it refreshes after re-ingest
+                    st.session_state.pop("kb_welcome_summary", None)
+                    st.rerun()
+                except Exception as e:
+                    st.error(f"Ingestion failed: {e}")
+
+
+def render_chat():
+    """Render the chat interface with message history and input."""
+    cfg = st.session_state.cfg
+
+    # Display chat history
+    for msg in st.session_state.messages:
+        with st.chat_message(msg["role"]):
+            st.markdown(msg["content"])
+
+    # Chat input
+    user_input = st.chat_input("Ask a question about your knowledge base...",
+                            accept_file="multiple", 
+                            file_type=["docx", "csv", "xlsx", "xls", "pdf", "rds", "rda", 
+                                       "tsv", "sav", "dta", "txt", "md", "json", "do"]
+                        )
+
+    if user_input:
+        prompt = user_input.text
+        uploaded_files = user_input.files
+        # Show and store user message
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        # ── Categorize user query ───────────────────
+        save_dir = "uploaded_do_files"
+        os.makedirs(save_dir, exist_ok=True)
+
+        # Exclude the just-appended user message to avoid sending
+        # the current question twice (once in history, once as query)
+        cat_cfg = cfg.get("query_categorization", {})
+        max_history = cat_cfg.get("max_history", 6)
+
+        # ── Query understanding ─────────────────────────────────────────
+        qu_cfg = cfg.get("query_understanding", {})
+        qu_enabled = qu_cfg.get("enabled", True)
+        max_history = qu_cfg.get("max_history", 6)
+
+        # ── Check if this is a clarification response ───────────────────
+        unresolved = st.session_state.unresolved_category
+        if unresolved is not None:
+            # This prompt is the user's clarification answer
+            # Include the clarification question for context
+            unresolved_question = st.session_state.get("unresolved_category_question", "")
+            if unresolved_question:
+                combined_cat = f"{unresolved} (Clarification: Q: {unresolved_question} A: {prompt})"
+            else:
+                combined_cat = f"{unresolved} — {prompt}"
+            st.session_state.unresolved_category_question = None
+            original_query_cat = unresolved
+            st.session_state.unresolved_category = None
+        else:
+            combined_cat = prompt
+            original_query_cat = prompt
+            st.session_state.resolution_rounds = 0
+            unresolved_question = []
+
+        prior_messages = st.session_state.messages[:-1]
+        history = [
+            {"role": m["role"], "content": m["content"]}
+            for m in prior_messages[-max_history:]
+        ]
+        try:
+            qinit_result = init_query(combined_cat, cfg, history)
+            print("result: ", qinit_result)
+            if qinit_result.get("country", None) is None:
+                
+                with st.chat_message("assistant"):
+                    st.markdown("Please specify the country for which you'd like to run a PERI analysis")
+                return
+            if qinit_result.get("value_chain", None) is None and qinit_result.get("investment", None) is None:
+                
+                with st.chat_message("assistant"):
+                    st.markdown(f"Please specify the value chain or investment area in {qinit_result.get('country', None)} for which you'd like to run a PERI analysis")
+                return
+            qcat_result = categorize_query(combined_cat, cfg, history)
+            print("result: ", qcat_result)
+        except Exception as e:
+            print(e)
+            qinit_result = {"country": None, "value_chain": None, "investment": None}
+            qcat_result = {"category": "pillar_1", "action": "unresolved"}
+
+        if not isinstance(qinit_result.get("country", None), list) and qinit_result.get("country", None)==None:
+            resolution_msg = f"It seems there is no country specified for the analysis. Currently the PERI framework supports analysis for the countries listed below:\n\n  {', '.join([c.capitalize() for c in APPROVED_OPTIONS.get('countries')])}\n\n We are also continuously \
+                            working to expand the framework and you can submit a form if the country you would like to run the analysis on is not included. In the meantime please let me know if you would like to run the anlysis for one of the included countries."
+                        
+        if qinit_result.get("country", None)[0].lower() not in [c.lower() for c in APPROVED_OPTIONS.get('countries')]:
+            resolution_msg = f"It seems you are trying to run a PERI analysis for {qinit_result.get('country', None)[0].capitalize()}! Currently the PERI framework only supports analysis for the countries listed below:\n\n  {', '.join([c.capitalize() for c in APPROVED_OPTIONS.get('countries')])}\n\n We are continuously \
+                working to expand the framework and you can submit a form to request. In the meantime please let me know if you would like to run the anlysis for one of the included countries."
+
+        if qinit_result.get("value_chain", None)[0]==None and qinit_result.get('investment', None)[0]==None:
+            resolution_msg = f"It seems there is no value chain or investment area specified for the analysis. Please select one of the value chains or investment areas included in the current PERI framework."
+        
+        if qinit_result.get("value_chain", None)[0].lower() not in [c.lower() for v in APPROVED_OPTIONS.get('value_chains').values() for c in v]:
+            resolution_msg = f"It seems you are trying to run a PERI analysis for {qinit_result.get('value_chain', None)[0]} in {qinit_result.get('country', None)[0].capitalize()}! Currently the PERI framework only supports analysis for the value chains listed below:\n\n  {dict_to_string(APPROVED_OPTIONS.get('value_chains'), 2)}\n\n We are continuously \
+                working to expand the framework and you can submit a form to request. In the meantime please let me know if you would like to run the anlysis for one of the included countries."
+                
+        if qinit_result.get("investment", None)[0].lower() not in [i.lower() for i in APPROVED_OPTIONS.get('investments')]:
+            resolution_msg = f"It seems you are trying to run a PERI analysis for {qinit_result.get('investment', None)[0]} investemnt in {qinit_result.get('country', None)[0].capitalize()}! Currently the PERI framework only supports analysis for the investment areas listed below:\n\n  {', '.join([c.capitalize() for c in APPROVED_OPTIONS.get('investments')])}\n\n We are continuously \
+                working to expand the framework and you can submit a form to request. In the meantime please let me know if you would like to run the anlysis for one of the included countries."
+
+        if qinit_result.get("country", None)[0] in APPROVED_OPTIONS.get('countries') and (qinit_result.get('value_chain', None)[0] in APPROVED_OPTIONS.get('value_chains') or qinit_result.get('investment', None)[0] in APPROVED_OPTIONS.get('investments')):
+    
+            pillar_dict = {
+                "pillar_1":f"would like to understand whether {','.join(qinit_result.get('value_chain'))} aligns with the government's political incentives.",
+                "pillar_2":f"would like to understand to what degree decisions are impacted by the lobbying of particular groups or by elite influence",
+                "pillar_3":f"would like to understand if {','.join(qinit_result.get('value_chain'))} and/or investing in {','.join(qinit_result.get('investment'))} can be feasibly implemented given the broader institutional and policy environment",
+                
+            }
+            resolution_msg = f"**Before I search, could you clarify?** Please let me know if you {' and '.join([pillar_dict[c] for c in qcat_result.get('category')])}."
+                                 
+        # st.session_state.unresolved_category_question = f"Please let me know if you {' and '.join([pillar_dict[c] for c in qcat_result.get('category')])}."
+        st.session_state.unresolved_category_question = resolution_msg
+        st.session_state.unresolved_category = original_query_cat
+        st.session_state.resolution_rounds += 1
+        st.session_state.messages.append({"role": "assistant", "content": resolution_msg})
+        
+        with st.chat_message("assistant"):
+            st.markdown(resolution_msg)
+        return

app_web.py

@@ -3,18 +3,21 @@ import os
 import shutil
 import zipfile
 import streamlit as st
+import pandas as pd
 
 from src.config_loader import load_config, get_api_key
 from src.ingest import get_chroma_collection, ingest_documents
 from src.kb_meta import load_kb_meta_brief
-from src.query_engine import understand_query, categorize_query, init_query, analyze_committment_to_vc
+from src.query_engine import understand_query, categorize_query, init_query, _parse_vc_analyzer_result
 from src.retriever import clear_collection_cache, retrieve
 from src.verifier import verify_and_respond
 from src.llm import list_models
 from src.stata import explain_
 from src.peri import APPROVED_OPTIONS
+from src.peri.value_chains import categorize_vc_production, analyze_committment_to_vc 
+from src.peri.investments import analyze_investments
 from src.prompts import dict_to_string
-
+# from ui import render_db
 from huggingface_hub import snapshot_download
 
 snapshot_download(repo_id="CGIAR/peri-kb", 
@@ -28,6 +31,8 @@ shutil.copytree("./ug", "./", dirs_exist_ok=True)
 
 def init_session():
     """Initialise st.session_state with messages list, cfg, and last_retrieval."""
+    if "bot_launched" not in st.session_state:
+        st.session_state.bot_launched = False
     if "messages" not in st.session_state:
         st.session_state.messages = []
     if "cfg" not in st.session_state:
@@ -55,6 +60,175 @@ def init_session():
     if "stata_file" not in st.session_state:
         st.session_state.stata_file = None
 
+# ── Sidebar ──────────────────────────────────────────────────────────────────
+def render_landing_page():
+    cfg = st.session_state.cfg
+    # print(cfg)
+    st.title(f"🤖 Welcome to the {cfg["chatbot"].get("name")} Assistant!")
+    st.markdown("Let's go through some preliminary steps below before getting started.")
+    
+    st.divider()
+    
+    # Dropdown Options
+    country = st.selectbox(
+        "Please select a country you would like to prepare a PERI analysis for today:",
+        [None]+[c.capitalize() for c in APPROVED_OPTIONS.get("countries")],
+        format_func=lambda x: "Please select a country..." if x is None else x
+    )
+
+    regime = None
+    if country is not None:
+        regime = st.selectbox(
+            f"Please specify whether {country.capitalize()} is an autocracy or democracy:",
+            [None, "Autocracy", "Democracy"],
+            format_func=lambda x: f"Please specify {country.capitalize()}'s regime..." if x is None else x
+        )
+    
+    # creativity_level = st.select_slider(
+    #     "Adjust Creativity (Temperature):",
+    #     options=["Low (Factual)", "Medium (Balanced)", "High (Creative)"],
+    #     value="Medium (Balanced)"
+    # )
+    
+    uploaded_ref = None
+    if regime is not None:
+        # Create the file uploader widget
+        pol_geo_desc = """\
+            A PERI analysis typically requires a preliminary analysis of 
+            the political geography of the country under review. Please upload 
+            the political geography analysis results for {country} if available.
+            You can also follow the guide at ... to prepare the analysis and upload your results:
+            """
+        st.write(pol_geo_desc.format(country=country))
+        uploaded_ref = st.file_uploader(
+            f"Please upload the political geography analysis results for {country}", 
+            type=["csv", "xls", "xlsx"])
+
+    if uploaded_ref is not None:
+        st.divider()
+        
+        # Launch Button
+        if st.button("Launch PERI-AI 🚀", type="primary", use_container_width=True):
+            # Save selections to session state to use during the chat session
+            try:
+                pol_geo_ref = pd.read_csv(uploaded_ref)
+            except Exception:
+                pol_geo_ref = pd.read_excel(uploaded_ref)
+                
+            st.session_state.country = country
+            st.session_state.regime = regime
+            st.session_state.pol_geo_ref = pol_geo_ref
+
+            with st.status("Preparing metadata for the analysis...", expanded=True) as status:
+                status.update(label=f'Preparing value chain metadata...')
+                pol_geo_scores = categorize_vc_production(pol_geo_ref, "value_chain")
+                
+                status.update(label=f'Preparing investment area metadata...')
+                investments = analyze_investments()
+
+                # ── Query understanding ─────────────────────────────────────────
+                qu_cfg = cfg.get("query_understanding", {})
+                qu_enabled = qu_cfg.get("enabled", True)
+                max_history = qu_cfg.get("max_history", 6)
+                
+                prior_messages = st.session_state.messages[:-1]
+                history = [
+                    {"role": m["role"], "content": m["content"]}
+                    for m in prior_messages[-max_history:]
+                ]
+
+                c2vc = {}
+                for vc in pol_geo_ref["value_chain"].unique():
+                    status.update(label=f'Analyzing committment to {vc} production...')
+
+                    prompt = f"{vc} production in uganda. use data tables and statistics where possible"     
+                    st.session_state.messages.append({"role": "user", "content": prompt})
+
+                    # ── Check if this is a clarification response ───────────────────
+                    pending = st.session_state.pending_clarification
+                    if pending is not None:
+                        # This prompt is the user's clarification answer
+                        # Include the clarification question for context
+                        pending_question = st.session_state.get("pending_clarification_question", "")
+                        if pending_question:
+                            combined = f"{pending} (Clarification: Q: {pending_question} A: {prompt})"
+                        else:
+                            combined = f"{pending} — {prompt}"
+                        st.session_state.pending_clarification_question = None
+                        original_query = pending
+                        st.session_state.pending_clarification = None
+                    else:
+                        combined = prompt
+                        original_query = prompt
+                        st.session_state.clarification_rounds = 0
+
+                    search_query = combined
+                    display_query = combined
+                    route = "vector"
+                    sql_query = None
+                    max_clarifications = qu_cfg.get("max_clarifications", 1)
+
+                    if qu_enabled:
+                        print("Q understanding")
+                        # Exclude the just-appended user message to avoid sending
+                        # the current question twice (once in history, once as query)
+                        prior_messages = st.session_state.messages[:-1]
+                        history = [
+                            {"role": m["role"], "content": m["content"]}
+                            for m in prior_messages[-max_history:]
+                        ]
+                        try:
+                            qu_result = understand_query(combined, cfg, history)
+                        except Exception:
+                            qu_result = {"action": "search", "search_query": combined, "display_query": combined, "original_query": original_query, "route": "vector", "sql_query": None}
+
+                        if qu_result.get("action") == "clarify" and st.session_state.clarification_rounds < max_clarifications:
+                            # Ask clarification — store original query and question for context
+                            st.session_state.pending_clarification = original_query
+                            st.session_state.pending_clarification_question = qu_result.get('clarification_question', 'Could you be more specific?')
+                            st.session_state.clarification_rounds += 1
+                            clarification_msg = f"**Before I search, could you clarify?** {qu_result.get('clarification_question', 'Could you be more specific?')}"
+                            st.session_state.messages.append(
+                                {"role": "assistant", "content": clarification_msg}
+                            )
+                            with st.chat_message("assistant"):
+                                st.markdown(clarification_msg)
+                            return
+
+                        # After max clarification rounds, force search (matches CLI behavior)
+                        if qu_result.get("action") == "clarify":
+                            qu_result["action"] = "search"
+
+                        search_query = qu_result.get("search_query", combined)
+                        display_query = qu_result.get("display_query", original_query)
+                        route = qu_result.get("route", "vector")
+                        sql_query = qu_result.get("sql_query")
+
+                    retrieval_result = retrieve(search_query, cfg, route=route, sql_query=sql_query)
+                    st.session_state.last_retrieval = retrieval_result
+
+                    output = verify_and_respond(
+                        display_query, retrieval_result, cfg, vc, original_query,
+                    )
+                    print(route)
+                    print(sql_query)
+                    print(display_query)
+                    print(output["response"])
+                    c2vc.update(_parse_vc_analyzer_result(output["response"]))
+
+                status.update(
+                    label=f"Completed metadata preparation for {pol_geo_scores.shape[0]} value chains and {investments.shape[0]} investment areas in {country}.",
+                    state="complete",
+                    )
+            print(c2vc)
+            st.session_state.beneficiaries_var = pol_geo_scores
+            st.session_state.investments_var = investments
+            st.session_state.c2vc = c2vc
+            st.session_state.country = country
+            st.session_state.bot_launched = True
+            st.rerun()
+
+
 
 # ── Sidebar ──────────────────────────────────────────────────────────────────
 
@@ -528,7 +702,70 @@ def render_chat():
         if len(st.session_state.messages) > max_messages:
             st.session_state.messages = st.session_state.messages[-max_messages:]
 
-
+def render_db():
+    # rows = st.columns((5,5), gap='medium')
+    row1 = st.columns((2,6), gap='medium')
+    row2 = st.container()
+    with row1[0]:
+        st.markdown(f'#### Political Geography of {st.session_state.country}')
+        st.dataframe(st.session_state.beneficiaries_var,
+                    # column_order=("states", "population"),
+                    hide_index=True,
+                    width='stretch',
+                    # column_config={
+                    #     "states": st.column_config.TextColumn(
+                    #         "States",
+                    #     ),
+                    #     "population": st.column_config.ProgressColumn(
+                    #         "Population",
+                    #         format="%f",
+                    #         min_value=0,
+                    #         max_value=max(st.session_state.beneficiaries_var.population),
+                    #     )}
+                    )
+            
+    with row1[1]:
+        st.markdown(f'#### Investment Area Analysis Results')
+        st.dataframe(st.session_state.investments_var,
+                    # column_order=("states", "population"),
+                    hide_index=True,
+                    width='stretch',
+                    # column_config={
+                    #     "states": st.column_config.TextColumn(
+                    #         "States",
+                    #     ),
+                    #     "population": st.column_config.ProgressColumn(
+                    #         "Population",
+                    #         format="%f",
+                    #         min_value=0,
+                    #         max_value=max(st.session_state.beneficiaries_var.population),
+                    #     )}
+                    )
+    with row2:
+        # with cols[2]:
+        st.markdown(f"#### Committment of {st.session_state.country}'s Government to Various Value Chains")
+       
+       
+        def display_nested_dict(d, indent=0, cols_per_row=2):
+        # Get all items in the dictionary
+            items = list(d.items())
+
+            # Create rows of columns
+            for i in range(0, len(items), cols_per_row):
+                cols = st.columns(cols_per_row)
+                for j in range(cols_per_row):
+                    if i + j < len(items):
+                        key, value = items[i + j]
+                        with cols[j]:
+                            if isinstance(value, dict):
+                                with st.expander(f"{' ' * indent}📁 {key.capitalize()}"):
+                                # Recursive call (you can adjust columns or keep single column inside expander)
+                                    display_nested_dict(value, indent + 2, 1)
+                            else:
+                                st.write(f"**{key.capitalize()}:** {value}")
+
+        display_nested_dict(st.session_state.c2vc, cols_per_row=3)
+        # st.json(st.session_state.c2vc)
 # ── Main ─────────────────────────────────────────────────────────────────────
 
 def main():
@@ -558,8 +795,13 @@ def main():
                 please let me know what pillar(s) you'd like us to analyze today and for what country. If this is\
                 is your first time working with PERI please proceed by letting me know what your particular interests are.")
 
-    render_sidebar()
-    render_chat()
+    if not st.session_state.bot_launched:
+        render_landing_page()
+
+    else:
+        # render_sidebar()
+        # render_chat()
+        render_db()
 
     st.caption(
         "All answers are sourced from the local knowledge base. "

src/kb_meta.py

@@ -259,8 +259,29 @@ def _collect_all_data(collection) -> tuple[list[str], list[dict]]:
     """Fetch all documents and metadatas from ChromaDB in a single call."""
     if collection.count() == 0:
         return [], []
-    all_data = collection.get(include=["documents", "metadatas"])
-    return all_data.get("documents", []), all_data.get("metadatas", [])
+    batch_size = 5000
+    offset = 0
+    all_documents = []
+    all_metadatas = []
+
+    while True:
+        batch = collection.get(
+            limit=batch_size, 
+            offset=offset, 
+            include=["documents", "metadatas"]
+        )
+        
+        # Break when no more records are returned
+        if not batch["ids"]:
+            break
+
+        # print(batch)
+            
+        all_documents.extend(batch["documents"])
+        all_metadatas.extend(batch["metadatas"])
+        offset += batch_size
+        # all_data = collection.get(include=["documents", "metadatas"])
+    return all_documents, all_metadatas
 
 
 def collect_file_records(collection, *, _cache: tuple = None) -> list[dict]:

src/peri.py

@@ -1,92 +0,0 @@
-COUNTRIES = ["ethiopia", "kenya", "malawi",
-             "nigeria", "tanzania", "uganda", "zambia"]
-ROOT_CROPS = ["potato", "cassava", "sweet_potato"]
-CASH_CROPS = ["coffee", "cocoa", "tea",
-              "tobacco", "cotton", "sugar"]
-HORTICULTURE = ["mango", "avocado", "haricot_vert", "banana", "other"]
-CEREALS = ["maize", "rice", "wheat", "teff"]
-INVESTMENTS = ["agricultural extension", "agricultural research and development", "biosecurity"
-               "cooperatives", "credit", "fertilizer", "input subsidies", "irrigation",
-               "machinery", "market information", "pest surveillance", "roads",
-               "seeds", "storage facilities", "training", "weather surveillance"]
-
-APPROVED_OPTIONS = {
-    "countries":COUNTRIES,
-    "value_chains":{
-        "root":ROOT_CROPS,
-        "cash":CASH_CROPS,
-        "hort":HORTICULTURE,
-        "cereal":CEREALS,
-        "other":["livestock and dairy", "fisheries", "pulses and oilseeds"]
-    },
-    "investments":INVESTMENTS
-}
-
-tti_ref = {
-    "within 1 year":["input subsidies", "machinery", "credit"],
-    "between 1 to 5 years":["small scale irrigation", "storage facilities",
-                         "roads", "market information", "weather surveillance",
-                         "cooperatives", "training"],
-    "between 5 to 10 years":["large scale irrigation"],
-    "10 years or more":["agricultural research and development"],
-}
-
-target_ref = {
-    "private":["fertilizer", "machinery", "credit", "storage facilities"],
-    "club":["irrigation", "roads", "cooperatives",  "storage facilities"],
-    "quasi public (impure public)":["agricultural extension"],
-    "public":["agricultural research and development", "pest surveillance",
-              "biosecurity", "weather surveillance", "market information"],
-}
-
-vis_ref = {
-    "very high":["roads", "irrigation"],
-    "high":["input subsidies"],
-    "medium":["agricultural extension", "credit", "training"],
-    "low":["weather surveillance", "market information"],
-    "very low":["agricultural research and development"]
-}
-
-target_add_ref = {
-    "private":{
-        "rivalrous":"yes",
-        "excludable":"yes"
-    },
-    "club":{
-        "rivalrous":"no",
-        "excludable":"yes"
-    },
-    "quasi public (impure public)":{
-        "rivalrous":"no",
-        "excludable":"partially"
-    },
-    "public":{
-        "rivalrous":"no",
-        "excludable":"no"
-    },
-}
-
-vis_add_ref = {
-    "very high":{
-        "desc":"physical infrastructure"
-    },
-    "high":{
-        "desc":"tangible inputs delivered to farmers"
-    },
-    "medium":{
-        "desc":"services or training"
-    },
-    "low":{
-        "desc":"informattional goods"
-    },
-    "very low":{
-        "desc":"knowledge generation, institutional change"
-    },
-}
-
-def prepare_investment_codings(var_ref:dict, var_col:str=None):
-    score_ref = {k:v for k,v in zip(var_ref, range(len(var_ref), 0, -1))}
-    score_df = pd.DataFrame({"investments":[c for v in var_ref.values() for c in v],
-                             var_col:[k for k,v in var_ref.items() for c in v],
-                             "score":[score_ref[k] for k,v in var_ref.items() for c in v]})
-    return normalize_scores(score_df)

src/peri/__init__.py

@@ -0,0 +1,85 @@
+COUNTRIES = ["ethiopia", "kenya", "malawi",
+             "nigeria", "tanzania", "uganda", "zambia"]
+ROOT_CROPS = ["potato", "cassava", "sweet_potato"]
+CASH_CROPS = ["coffee", "cocoa", "tea",
+              "tobacco", "cotton", "sugar"]
+HORTICULTURE = ["mango", "avocado", "haricot_vert", "banana", "other"]
+CEREALS = ["maize", "rice", "wheat", "teff"]
+INVESTMENTS = ["agricultural extension", "agricultural research and development", "biosecurity"
+               "cooperatives", "credit", "fertilizer", "input subsidies", "irrigation",
+               "machinery", "market information", "pest surveillance", "roads",
+               "seeds", "storage facilities", "training", "weather surveillance"]
+
+APPROVED_OPTIONS = {
+    "countries":COUNTRIES,
+    "value_chains":{
+        "root":ROOT_CROPS,
+        "cash":CASH_CROPS,
+        "hort":HORTICULTURE,
+        "cereal":CEREALS,
+        "other":["livestock and dairy", "fisheries", "pulses and oilseeds"]
+    },
+    "investments":INVESTMENTS
+}
+
+tti_ref = {
+    "within 1 year":["input subsidies", "machinery", "credit"],
+    "between 1 to 5 years":["small scale irrigation", "storage facilities",
+                         "roads", "market information", "weather surveillance",
+                         "cooperatives", "training"],
+    "between 5 to 10 years":["large scale irrigation"],
+    "10 years or more":["agricultural research and development"],
+}
+
+target_ref = {
+    "private":["fertilizer", "machinery", "credit", "storage facilities"],
+    "club":["irrigation", "roads", "cooperatives",  "storage facilities"],
+    "quasi public (impure public)":["agricultural extension"],
+    "public":["agricultural research and development", "pest surveillance",
+              "biosecurity", "weather surveillance", "market information"],
+}
+
+vis_ref = {
+    "very high":["roads", "irrigation"],
+    "high":["input subsidies"],
+    "medium":["agricultural extension", "credit", "training"],
+    "low":["weather surveillance", "market information"],
+    "very low":["agricultural research and development"]
+}
+
+target_add_ref = {
+    "private":{
+        "rivalrous":"yes",
+        "excludable":"yes"
+    },
+    "club":{
+        "rivalrous":"no",
+        "excludable":"yes"
+    },
+    "quasi public (impure public)":{
+        "rivalrous":"no",
+        "excludable":"partially"
+    },
+    "public":{
+        "rivalrous":"no",
+        "excludable":"no"
+    },
+}
+
+vis_add_ref = {
+    "very high":{
+        "desc":"physical infrastructure"
+    },
+    "high":{
+        "desc":"tangible inputs delivered to farmers"
+    },
+    "medium":{
+        "desc":"services or training"
+    },
+    "low":{
+        "desc":"informattional goods"
+    },
+    "very low":{
+        "desc":"knowledge generation, institutional change"
+    },
+}

src/peri/investments.py

@@ -0,0 +1,30 @@
+import pandas as pd
+from src.peri import tti_ref, target_ref, vis_ref, target_add_ref, vis_add_ref
+
+def normalize_scores(score_df:pd.DataFrame):
+    max_score = max(4, score_df['score'].max())
+    min_score = min(1, score_df['score'].min())
+    score_df['noremalized_scores'] = (score_df['score']-min_score)/(max_score-min_score)
+    return score_df
+
+def prepare_investment_codings(var_ref:dict, var_col:str=None):
+    score_ref = {k:v for k,v in zip(var_ref, range(len(var_ref), 0, -1))}
+    score_df = pd.DataFrame({"investments":[c for v in var_ref.values() for c in v],
+                             var_col:[k for k,v in var_ref.items() for c in v],
+                             "score":[score_ref[k] for k,v in var_ref.items() for c in v]})
+    return normalize_scores(score_df)
+
+def analyze_investments():    
+    tti_scores = prepare_investment_codings(tti_ref, "time_to_impact")
+    target_scores = prepare_investment_codings(target_ref, "type")
+    vis_scores = prepare_investment_codings(vis_ref, "observability")
+
+    merge_cols = ["investments", "score"]
+    investment_scores = tti_scores[merge_cols].rename(columns={"score":"time_to_impact"}).merge(target_scores[merge_cols].rename(columns={"score":"targetability"}), on="investments", how="outer")
+    investment_df = investment_scores.merge(vis_scores[merge_cols].rename(columns={"score":"visibility"}), on="investments", how="outer")
+
+    score_cols = ["time_to_impact", "targetability", "visibility"]
+    investment_df['agg_score'] = investment_df[score_cols].sum(1)
+
+    return investment_df
+            

src/peri/{beneficiaries.py → value_chains.py}

@@ -1,13 +1,13 @@
 import pandas as pd
-from typing import Iterable
+from typing import Iterable, Dict
 
-def normalize_scores(score_df:pd.DataFrame):
-    max_score = max(4, score_df['score'].max())
-    min_score = min(1, score_df['score'].min())
-    score_df['noremalized_scores'] = (score_df['score']-min_score)/(max_score-min_score)
-    return score_df
+from src.llm import generate
+from src.retriever import retrieve
+from src.prompts import build_vc_analyzer_prompt
+from src.query_engine import _parse_vc_analyzer_result
+from .investments import normalize_scores
 
-def score_beneficiaries(vc_dist_ref:pd.DataFrame,
+def score_value_chains(vc_dist_ref:pd.DataFrame,
                         val_chain_col:str,
                         ruling_opp_swing_share:Iterable):
     vc_dist_ref["score"] = 0
@@ -21,10 +21,25 @@ def score_beneficiaries(vc_dist_ref:pd.DataFrame,
 def categorize_vc_production(vc_dist_ref:pd.DataFrame,
                              val_chain_col:str):
     vc_dist_ref = vc_dist_ref[~vc_dist_ref['category'].str.lower().str.contains("plurality")].reset_index(drop=True)
-    ros_vc = vc_dist_ref.groupby([val_chain_col], as_index=False).apply(lambda x: x[x["share"]>0.5])[val_chain_col].unique()
+    ros_vc = vc_dist_ref.groupby([val_chain_col]).apply(lambda x: x[x["share"]>0.5]).reset_index()[val_chain_col].unique()
 
-    score_df = score_beneficiaries(vc_dist_ref, val_chain_col, ros_vc)
+    score_df = score_value_chains(vc_dist_ref, val_chain_col, ros_vc)
     score_df = score_df.groupby(['score'], as_index=False)[val_chain_col].unique().explode(val_chain_col).reset_index(drop=True)
 
     score_df = score_df[[val_chain_col, 'score']]
-    return normalize_scores(score_df)
+    return normalize_scores(score_df)
+
+def analyze_committment_to_vc(cfg:Dict, value_chain:str):
+    search_query = f"{value_chain} production in uganda"
+    retrieval_result = retrieve(search_query, cfg, route="both")
+    context = retrieval_result.get("context", "")
+
+    prompt = build_vc_analyzer_prompt(context, value_chain, cfg["chatbot"].get("domain"))
+    raw = generate(
+        "",
+        prompt,
+        cfg,
+        max_tokens=4096,
+        )
+
+    return _parse_vc_analyzer_result(raw)

src/prompts.py

@@ -288,16 +288,66 @@ Your task is to review retrieved documents from a knowledge base and extract evi
 
 IMPORTANT RULES
 
-1. Only use information explicitly found in the provided documents.
-2. Do not infer facts that are not supported by evidence.
-3. If evidence is not found, return "NOT_FOUND".
+1. NEVER use your training data or memory to answer questions.
+   Every factual claim MUST be grounded in the provided context.
+2. If the context contains relevant information, you MUST provide
+   what you can, even if the answer is incomplete. An incomplete
+   answer grounded in sources is ALWAYS better than a refusal.
+3. ONLY refuse if the context contains NO relevant information at
+   all. If evidence is not found, return "NOT_FOUND".
 4. Every extracted value must be accompanied by:
    - supporting quotation
    - source document name
    - page/section reference when available
 5. Multiple documents may be provided.
 6. Consolidate information across all documents.
-7. Return output strictly as valid JSON.
+7. STRUCTURED DATA WITH MISSING VALUES: N/A or empty values in
+   dataset rows are NORMAL — they mean data was not collected or
+   not available for that year/source. Do NOT treat N/A values as
+   a reason to refuse answering. Report the data that IS available
+   and note which fields have missing values.
+8. Return output strictly as valid JSON.
+
+---------------------------------------------------------------------
+CITATION RULES
+---------------------------------------------------------------------
+1. Every factual claim MUST carry a numbered endnote like [1], [2],
+   etc. that maps to a reference at the end of your response.
+   Do NOT output the literal text "[N]" — always use actual numbers.
+2. Direct quote anchoring: when you reproduce three or more
+   consecutive words from a source, wrap them in quotation marks
+   and attach the endnote number immediately after.
+3. Paraphrased claims still require a numbered endnote.
+
+---------------------------------------------------------------------
+REFERENCE LIST FORMAT
+---------------------------------------------------------------------
+At the end of every response, include a "References" section.
+
+IMPORTANT: Do NOT use chunk IDs (CHUNK-LOCAL-001, CHUNK-SQL-001, CHUNK-WEB-001, etc.)
+in the reference list. Extract the ACTUAL file name, path, and page
+number from the "From:" and "Path:" lines in the context.
+
+For local sources, use the file name and path:
+  [1] Chenoweth_Stephan_2011.pdf (p. 23)
+      -- knowledge_base/NAVCO 2.0/Chenoweth_Stephan_2011.pdf
+
+For web sources, use author, year, title, and URL/DOI:
+  [2] Nepstad, S.E. (2011). "Nonviolent Revolutions"
+      DOI: https://doi.org/10.xxxx/yyyy
+
+Source priority:
+  Local sources (user's documents) > Web sources (search results)
+
+Organize references into two groups when both are present:
+  **Local Sources (Primary)**
+  **Web Sources (Supplementary)**
+
+---------------------------------------------------------------------
+RESPONSE LENGTH
+---------------------------------------------------------------------
+Keep your response length proportional to the available evidence.
+Short context = short answer.  Do NOT pad responses.
 
 --------------------------------------------------------
 TARGET VALUE CHAIN
@@ -321,12 +371,12 @@ B. Current budget allocation (or in the most recent financial year)
 
 Extract:
 
-- budget_start_year
-- budget_start_value
-- budget_end_year
-- budget_end_value
-- currency
-- responsible institution
+- budget_start_year (string or datetime)
+- budget_start_value (integer)
+- budget_end_year (string or datetime)
+- budget_end_value (integer)
+- currency (integer)
+- responsible institution (string)
 
 If multiple values are found, report all candidate values and explain differences.
 
@@ -425,7 +475,7 @@ OUTPUT FORMAT
 --------------------------------------------------------
 
 {{
-  "value_chain": "",
+  {value_chain}:{{
 
   "financial_commitment": {{
     "budget_start_year": "",
@@ -485,6 +535,7 @@ OUTPUT FORMAT
       "evidence": []
     }}
   }}
+  }}
 }}
 
 """

src/query_engine.py

@@ -26,7 +26,7 @@ def analyze_committment_to_vc(value_chain:str,
     except Exception:
         # LLM failure: fall back to raw query
         return {
-            "value_chain": None,
+            value_chain:{
 
             "financial_commitment": {
                 "budget_start_year": "",
@@ -86,6 +86,7 @@ def analyze_committment_to_vc(value_chain:str,
                 "evidence": []
                 }
             }
+            }
         }
 
 

src/verifier.py

@@ -16,7 +16,7 @@ The main entry point is ``verify_and_respond``.
 import json
 import re
 
-from src.prompts import build_prompt, build_verification_prompt
+from src.prompts import build_prompt, build_verification_prompt, build_vc_analyzer_prompt
 from src.llm import generate
 from src.retriever import NO_SOURCES_REFUSAL
 
@@ -303,7 +303,7 @@ def parse_verification_result(raw: str) -> dict:
 # ── Main entry point ─────────────────────────────────────────────────────────
 
 def verify_and_respond(
-    query: str, retrieval_result: dict, cfg: dict,
+    query: str, retrieval_result: dict, cfg: dict, value_chain:str,
     original_query: str = "",
 ) -> dict:
     """Generate a response and run it through the 7-layer verification stack.
@@ -346,7 +346,7 @@ def verify_and_respond(
     soft_max = compute_soft_max_tokens(len(context), default_max)
 
     # ── Layer 1: System prompt guardrails (built into prompt) ─────────────
-    system_prompt = build_prompt(context, bot_name, domain, kb_overview=kb_overview)
+    system_prompt = build_vc_analyzer_prompt(context, value_chain, domain)
 
     # ── Build user message with original query for intent cross-check ────
     if original_query and original_query != query:

ui.py

@@ -0,0 +1,276 @@
+#######################
+# Import libraries
+import streamlit as st
+import pandas as pd
+import altair as alt
+import plotly.express as px
+
+#######################
+# Page configuration
+st.set_page_config(
+    page_title="US Population Dashboard",
+    page_icon="🏂",
+    layout="wide",
+    initial_sidebar_state="expanded")
+
+alt.themes.enable("dark")
+
+#######################
+# CSS styling
+st.markdown("""
+<style>
+
+[data-testid="block-container"] {
+    padding-left: 2rem;
+    padding-right: 2rem;
+    padding-top: 1rem;
+    padding-bottom: 0rem;
+    margin-bottom: -7rem;
+}
+
+[data-testid="stVerticalBlock"] {
+    padding-left: 0rem;
+    padding-right: 0rem;
+}
+
+[data-testid="stMetric"] {
+    background-color: #393939;
+    text-align: center;
+    padding: 15px 0;
+}
+
+[data-testid="stMetricLabel"] {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+[data-testid="stMetricDeltaIcon-Up"] {
+    position: relative;
+    left: 38%;
+    -webkit-transform: translateX(-50%);
+    -ms-transform: translateX(-50%);
+    transform: translateX(-50%);
+}
+
+[data-testid="stMetricDeltaIcon-Down"] {
+    position: relative;
+    left: 38%;
+    -webkit-transform: translateX(-50%);
+    -ms-transform: translateX(-50%);
+    transform: translateX(-50%);
+}
+
+</style>
+""", unsafe_allow_html=True)
+
+
+#######################
+# Load data
+df_reshaped = pd.read_csv('./us-population-2010-2019-reshaped.csv')
+
+
+#######################
+# Sidebar
+with st.sidebar:
+    st.title('🏂 US Population Dashboard')
+    
+    year_list = list(df_reshaped.year.unique())[::-1]
+    
+    selected_year = st.selectbox('Select a year', year_list)
+    df_selected_year = df_reshaped[df_reshaped.year == selected_year]
+    df_selected_year_sorted = df_selected_year.sort_values(by="population", ascending=False)
+
+    color_theme_list = ['blues', 'cividis', 'greens', 'inferno', 'magma', 'plasma', 'reds', 'rainbow', 'turbo', 'viridis']
+    selected_color_theme = st.selectbox('Select a color theme', color_theme_list)
+
+
+#######################
+# Plots
+
+# Heatmap
+def make_heatmap(input_df, input_y, input_x, input_color, input_color_theme):
+    heatmap = alt.Chart(input_df).mark_rect().encode(
+            y=alt.Y(f'{input_y}:O', axis=alt.Axis(title="Year", titleFontSize=18, titlePadding=15, titleFontWeight=900, labelAngle=0)),
+            x=alt.X(f'{input_x}:O', axis=alt.Axis(title="", titleFontSize=18, titlePadding=15, titleFontWeight=900)),
+            color=alt.Color(f'max({input_color}):Q',
+                             legend=None,
+                             scale=alt.Scale(scheme=input_color_theme)),
+            stroke=alt.value('black'),
+            strokeWidth=alt.value(0.25),
+        ).properties(width=900
+        ).configure_axis(
+        labelFontSize=12,
+        titleFontSize=12
+        ) 
+    # height=300
+    return heatmap
+
+# Choropleth map
+def make_choropleth(input_df, input_id, input_column, input_color_theme):
+    choropleth = px.choropleth(input_df, locations=input_id, color=input_column, locationmode="USA-states",
+                               color_continuous_scale=input_color_theme,
+                               range_color=(0, max(df_selected_year.population)),
+                               scope="usa",
+                               labels={'population':'Population'}
+                              )
+    choropleth.update_layout(
+        template='plotly_dark',
+        plot_bgcolor='rgba(0, 0, 0, 0)',
+        paper_bgcolor='rgba(0, 0, 0, 0)',
+        margin=dict(l=0, r=0, t=0, b=0),
+        height=350
+    )
+    return choropleth
+
+
+# Donut chart
+def make_donut(input_response, input_text, input_color):
+  if input_color == 'blue':
+      chart_color = ['#29b5e8', '#155F7A']
+  if input_color == 'green':
+      chart_color = ['#27AE60', '#12783D']
+  if input_color == 'orange':
+      chart_color = ['#F39C12', '#875A12']
+  if input_color == 'red':
+      chart_color = ['#E74C3C', '#781F16']
+    
+  source = pd.DataFrame({
+      "Topic": ['', input_text],
+      "% value": [100-input_response, input_response]
+  })
+  source_bg = pd.DataFrame({
+      "Topic": ['', input_text],
+      "% value": [100, 0]
+  })
+    
+  plot = alt.Chart(source).mark_arc(innerRadius=45, cornerRadius=25).encode(
+      theta="% value",
+      color= alt.Color("Topic:N",
+                      scale=alt.Scale(
+                          #domain=['A', 'B'],
+                          domain=[input_text, ''],
+                          # range=['#29b5e8', '#155F7A']),  # 31333F
+                          range=chart_color),
+                      legend=None),
+  ).properties(width=130, height=130)
+    
+  text = plot.mark_text(align='center', color="#29b5e8", font="Lato", fontSize=32, fontWeight=700, fontStyle="italic").encode(text=alt.value(f'{input_response} %'))
+  plot_bg = alt.Chart(source_bg).mark_arc(innerRadius=45, cornerRadius=20).encode(
+      theta="% value",
+      color= alt.Color("Topic:N",
+                      scale=alt.Scale(
+                          # domain=['A', 'B'],
+                          domain=[input_text, ''],
+                          range=chart_color),  # 31333F
+                      legend=None),
+  ).properties(width=130, height=130)
+  return plot_bg + plot + text
+
+# Convert population to text 
+def format_number(num):
+    if num > 1000000:
+        if not num % 1000000:
+            return f'{num // 1000000} M'
+        return f'{round(num / 1000000, 1)} M'
+    return f'{num // 1000} K'
+
+# Calculation year-over-year population migrations
+def calculate_population_difference(input_df, input_year):
+  selected_year_data = input_df[input_df['year'] == input_year].reset_index()
+  previous_year_data = input_df[input_df['year'] == input_year - 1].reset_index()
+  selected_year_data['population_difference'] = selected_year_data.population.sub(previous_year_data.population, fill_value=0)
+  return pd.concat([selected_year_data.states, selected_year_data.id, selected_year_data.population, selected_year_data.population_difference], axis=1).sort_values(by="population_difference", ascending=False)
+
+def render_db():
+    #######################
+    # Dashboard Main Panel
+    col = st.columns((1.5, 4.5, 2), gap='medium')
+
+    with col[0]:
+        st.markdown('#### Gains/Losses')
+
+        df_population_difference_sorted = calculate_population_difference(df_reshaped, selected_year)
+
+        if selected_year > 2010:
+            first_state_name = df_population_difference_sorted.states.iloc[0]
+            first_state_population = format_number(df_population_difference_sorted.population.iloc[0])
+            first_state_delta = format_number(df_population_difference_sorted.population_difference.iloc[0])
+        else:
+            first_state_name = '-'
+            first_state_population = '-'
+            first_state_delta = ''
+        st.metric(label=first_state_name, value=first_state_population, delta=first_state_delta)
+
+        if selected_year > 2010:
+            last_state_name = df_population_difference_sorted.states.iloc[-1]
+            last_state_population = format_number(df_population_difference_sorted.population.iloc[-1])   
+            last_state_delta = format_number(df_population_difference_sorted.population_difference.iloc[-1])   
+        else:
+            last_state_name = '-'
+            last_state_population = '-'
+            last_state_delta = ''
+        st.metric(label=last_state_name, value=last_state_population, delta=last_state_delta)
+
+        
+        st.markdown('#### States Migration')
+
+        if selected_year > 2010:
+            # Filter states with population difference > 50000
+            # df_greater_50000 = df_population_difference_sorted[df_population_difference_sorted.population_difference_absolute > 50000]
+            df_greater_50000 = df_population_difference_sorted[df_population_difference_sorted.population_difference > 50000]
+            df_less_50000 = df_population_difference_sorted[df_population_difference_sorted.population_difference < -50000]
+            
+            # % of States with population difference > 50000
+            states_migration_greater = round((len(df_greater_50000)/df_population_difference_sorted.states.nunique())*100)
+            states_migration_less = round((len(df_less_50000)/df_population_difference_sorted.states.nunique())*100)
+            donut_chart_greater = make_donut(states_migration_greater, 'Inbound Migration', 'green')
+            donut_chart_less = make_donut(states_migration_less, 'Outbound Migration', 'red')
+        else:
+            states_migration_greater = 0
+            states_migration_less = 0
+            donut_chart_greater = make_donut(states_migration_greater, 'Inbound Migration', 'green')
+            donut_chart_less = make_donut(states_migration_less, 'Outbound Migration', 'red')
+
+        migrations_col = st.columns((0.2, 1, 0.2))
+        with migrations_col[1]:
+            st.write('Inbound')
+            st.altair_chart(donut_chart_greater)
+            st.write('Outbound')
+            st.altair_chart(donut_chart_less)
+
+    with col[1]:
+        st.markdown('#### Total Population')
+        
+        choropleth = make_choropleth(df_selected_year, 'states_code', 'population', selected_color_theme)
+        st.plotly_chart(choropleth, use_container_width=True)
+        
+        heatmap = make_heatmap(df_reshaped, 'year', 'states', 'population', selected_color_theme)
+        st.altair_chart(heatmap, use_container_width=True)
+        
+
+    with col[2]:
+        st.markdown('#### Top States')
+
+        st.dataframe(df_selected_year_sorted,
+                    column_order=("states", "population"),
+                    hide_index=True,
+                    width='content',
+                    column_config={
+                        "states": st.column_config.TextColumn(
+                            "States",
+                        ),
+                        "population": st.column_config.ProgressColumn(
+                            "Population",
+                            format="%f",
+                            min_value=0,
+                            max_value=max(df_selected_year_sorted.population),
+                        )}
+                    )
+        
+        with st.expander('About', expanded=True):
+            st.write('''
+                - Data: [U.S. Census Bureau](https://www.census.gov/data/datasets/time-series/demo/popest/2010s-state-total.html).
+                - :orange[**Gains/Losses**]: states with high inbound/ outbound migration for selected year
+                - :orange[**States Migration**]: percentage of states with annual inbound/ outbound migration > 50,000
+                ''')