using openai

app.py

@@ -1,546 +1,62 @@
 import gradio as gr
-import requests
-import numpy as np
-import time
-import json
-import os
+from openai import OpenAI
 
-# Import the utilities with proper error handling
-try:
-    from utils.encoding_input import encode_text
-    from utils.retrieve_n_rerank import retrieve_and_rerank
-    from utils.sentiment_analysis import get_sentiment
-    from utils.coherence_bbscore import coherence_report
-    from utils.loading_embeddings import get_vectorstore
-    from utils.model_generation import build_messages
-    from utils.query_constraints import parse_query_constraints, page_matches, doc_matches
-    from utils.conversation_logging import load_history, log_exchange
-    from langchain.schema import Document
-    from utils.hybrid_retrieval import HybridRetriever, consolidate_page
-except ImportError as e:
-    print(f"Import error: {e}")
-    print("Make sure you're running from the correct directory and all dependencies are installed.")
+# 🔹 Configure your agent
+agent_endpoint = "https://q77iuwf7ncfemoonbzon2iyd.agents.do-ai.run/api/v1/"
+agent_access_key = "CzIwmTIDFNWRRIHvxVNzKWztq8rn5S5w"
 
-API_KEY = os.getenv("API_KEY", "sk-do-8Hjf0liuGQCoPwglilL49xiqrthMECwjGP_kAjPM53OTOFQczPyfPK8xJc")
-MODEL = "llama3.3-70b-instruct"
+client = OpenAI(base_url=agent_endpoint, api_key=agent_access_key)
 
-# Global settings for sentiment and coherence analysis
-ENABLE_SENTIMENT = True
-ENABLE_COHERENCE = True
+# Parameters
+DEFAULT_RETRIEVAL_RUNS = 3  # adjustable in UI
 
-# Load persisted history (if any) for memory retention
-PERSISTED_HISTORY = load_history()
-
-# Default verbatim mode flag (quotes only, no generative summarization)
-VERBATIM_MODE_DEFAULT = True
-
-def _citation(meta, alias_map=None):
-    """Return a concise citation token for a metadata dict.
-    Example: [S1 p.17] where S1 alias maps to full doc name in Sources section.
-    Falls back to base filename when no alias_map provided.
-    """
-    src_raw = os.path.basename(meta.get('source', 'Unknown'))
-    base = os.path.splitext(src_raw)[0]
-    label = alias_map.get(base, base) if alias_map else base
-    page = meta.get('page_label') or meta.get('page') or 'unknown'
-    return f"[{label} p.{page}]"
-
-def _extract_quotes(query: str, docs, max_quotes: int = 12):
-    import re, math
-    terms = [t.lower() for t in re.findall(r"[A-Za-z0-9]+", query) if len(t) > 2]
-    term_set = set(terms)
-    scored = []
-    for d in docs:
-        meta = getattr(d,'metadata',{})
-        # split on sentence end punctuation heuristically
-        sentences = re.split(r"(?<=[\.!?])\s+", d.page_content)
-        for sent in sentences:
-            s = sent.strip()
-            if not s:
-                continue
-            toks = [w.lower() for w in re.findall(r"[A-Za-z0-9]+", s)]
-            if not toks:
-                continue
-            overlap = len(term_set.intersection(toks))
-            if overlap == 0:
-                continue
-            score = overlap / math.log(len(toks)+1, 2)
-            scored.append((score, s, meta))
-    scored.sort(key=lambda x: x[0], reverse=True)
-    out = []
-    seen = set()
-    for score, s, meta in scored:
-        key = (s, meta.get('source'), meta.get('page_label'))
-        if key in seen:
-            continue
-        seen.add(key)
-        out.append(f"- \"{s}\" {_citation(meta)}")
-        if len(out) >= max_quotes:
-            break
-    return out
-
-def _extract_quote_records(query: str, docs, max_quotes: int = 14):
-    """Structured variant of _extract_quotes returning list of dict rows."""
-    import re, math
-    terms = [t.lower() for t in re.findall(r"[A-Za-z0-9]+", query) if len(t) > 2]
-    term_set = set(terms)
-    scored = []
-    for d in docs:
-        meta = getattr(d,'metadata',{})
-        sentences = re.split(r"(?<=[\.!?])\s+", d.page_content)
-        for sent in sentences:
-            s = sent.strip()
-            if not s:
-                continue
-            toks = [w.lower() for w in re.findall(r"[A-Za-z0-9]+", s)]
-            if not toks:
-                continue
-            overlap = len(term_set.intersection(toks))
-            if overlap == 0:
-                continue
-            score = overlap / math.log(len(toks)+1, 2)
-            scored.append((score, s, meta))
-    scored.sort(key=lambda x: x[0], reverse=True)
-    rows = []
-    seen = set()
-    for score, s, meta in scored:
-        key = (s, meta.get('source'), meta.get('page_label'))
-        if key in seen:
-            continue
-        seen.add(key)
-        src_raw = os.path.basename(meta.get('source','Unknown'))
-        src = os.path.splitext(src_raw)[0]
-        page = meta.get('page_label') or meta.get('page') or '—'
-        rows.append({"Document": src, "Page": page, "Excerpt": s, "Citation": _citation(meta)})
-        if len(rows) >= max_quotes:
-            break
-    return rows
-
-def _detect_comparison_intent(message: str) -> bool:
-    m = message.lower()
-    keywords = [" compare ", " comparison", " vs ", " versus ", "difference between", "differences between", "contrast "]
-    if any(k in m for k in keywords):
-        return True
-    # pattern like "between X and Y"
-    return ("between" in m and " and " in m)
-
-def _quote_records_to_table(rows):
-    if not rows:
-        return "Not found in sources."
-    # Limit excerpt length for readability
-    def shorten(txt, limit=260):
-        return txt if len(txt) <= limit else txt[:limit].rstrip() + "…"
-    headers = ["Document", "Page", "Excerpt", "Citation"]
-    table_lines = ["| " + " | ".join(headers) + " |", "| " + " | ".join(["---"]*len(headers)) + " |"]
-    for r in rows:
-        table_lines.append("| " + " | ".join([
-            str(r['Document']),
-            str(r['Page']),
-            shorten(r['Excerpt']).replace("|","\\|"),
-            r['Citation']
-        ]) + " |")
-    return "\n".join(table_lines)
-
-def _extract_enumerated_objectives(text: str):
-    """Extract enumerated policy objectives (a) .. (q) from a block of text.
-    Returns list of tuples (label, objective_text)."""
-    import re
-    lowered = text.lower()
-    if "objective" not in lowered:
-        return []
-    # Heuristic anchor phrases.
-    anchor_idx = None
-    for anchor in ["specifically these objectives are", "specifically, these objectives are", "1.2 energy policy objectives", "energy policy objectives", "policy objectives are:"]:
-        idx = lowered.find(anchor)
-        if idx != -1:
-            anchor_idx = idx
-            break
-    if anchor_idx is not None:
-        segment = text[anchor_idx: anchor_idx + 6000]  # limit to reasonable window
-    else:
-        segment = text
-    # Normalize line breaks inside enumerations: join lines that don't start a new bullet.
-    lines = [l.strip() for l in segment.splitlines() if l.strip()]
-    rebuilt = []
-    current = ""
-    bullet_pat = re.compile(r"^\(?([a-q])\)\s+", re.IGNORECASE)
-    for ln in lines:
-        if bullet_pat.match(ln):
-            if current:
-                rebuilt.append(current.strip())
-            current = ln
-        else:
-            if current:
-                # continuation of current bullet
-                if not ln.endswith(('.', ';', ':')) and not current.endswith((';', ':')):
-                    current += ' ' + ln
-                else:
-                    current += ' ' + ln
-            # else ignore preamble lines
-    if current:
-        rebuilt.append(current.strip())
-    objectives = []
-    for item in rebuilt:
-        m = bullet_pat.match(item)
-        if not m:
-            continue
-        label = m.group(1).lower()
-        body = bullet_pat.sub('', item).strip()
-        # Clean stray spaces/hyphen splits
-        body = re.sub(r"\s+", " ", body)
-        body = body.replace(" - ", " – ")
-        objectives.append((label, body))
-    # Deduplicate by label keeping first occurrence
-    seen = set()
-    ordered = []
-    for lab, body in objectives:
-        if lab in seen:
-            continue
-        seen.add(lab)
-        ordered.append((lab, body))
-    return ordered
-
-def _format_objectives_markdown(objs, meta_docs, alias_map=None):
-    if not objs:
-        return None
-    hdr = f"**Policy Objectives** ({len(objs)})\n"
-    bullets = [f"{i+1}. ({lab}) {txt}" for i,(lab, txt) in enumerate(objs)]
-    src_note = "\n\nSources:\n" + "\n".join([f"- {alias_map.get(d,d)}" for d in sorted(meta_docs)]) if meta_docs else ""
-    return hdr + "\n".join(bullets) + src_note
-
-def _build_alias_map(docs):
-    bases = []
-    for d in docs:
-        meta = getattr(d,'metadata',{})
-        base = os.path.splitext(os.path.basename(meta.get('source','Unknown')))[0]
-        if base not in bases:
-            bases.append(base)
-    alias_map = {}
-    for idx, b in enumerate(bases, start=1):
-        alias_map[b] = f"S{idx}"
-    return alias_map
-
-def chat_response(message, history, verbatim_mode=True):
+def policy_chat(message, history, retrieval_runs=DEFAULT_RETRIEVAL_RUNS):
     """
-    Generate response for chat interface.
-    
-    Args:
-        message: Current user message
-        history: List of [user_message, bot_response] pairs
+    Chatbot with streaming + multiple retrieval runs.
     """
-    
-    try:
-        # Initialize vectorstore when needed
-        vectorstore = get_vectorstore()
+    # Show "processing" placeholder
+    history = history + [[message, "Processing..."]]
+    yield history, history  
 
-        constraints = parse_query_constraints(message)
-        want_page = constraints.get("page")
-        doc_tokens = constraints.get("doc_tokens", [])
+    aggregated_responses = []
 
-        # Attempt hybrid deterministic retrieval first
-        reranked_results = []
+    for run in range(retrieval_runs):
         try:
-            hybrid = HybridRetriever(vectorstore)
-            filters = {}
-            if want_page is not None:
-                filters['page_label'] = str(want_page)
-            hybrid_docs = hybrid.fetch(message, k_dense=40, k_bm25=40, filters=filters if filters else None, rerank_top=30)
-            reranked_results = [(d, 0.0) for d in hybrid_docs]
-        except Exception:
-            pass
-        if not reranked_results:  # fallback legacy path
-            base_k = 120 if want_page is not None else 50
-            reranked_results = retrieve_and_rerank(
-                query_text=message,
-                vectorstore=vectorstore,
-                k=base_k,
-                rerank_model="cross-encoder/ms-marco-MiniLM-L-6-v2",
-                top_m=40 if want_page is not None else 20,
-                min_score=0.4 if want_page is not None else 0.5,
-                only_docs=False
+            stream = client.chat.completions.create(
+                model="n/a",  # agent handles routing
+                messages=[
+                    {"role": "system", "content": "The data must be returned verbatim. Please be quite detailed and include all information. You are new to the analysis of policy documents, hence you need to be objective in retrieving information, and it is not expected that you will analyse and interpret the information."},
+                    *[{"role": "user", "content": u} if i % 2 == 0 else {"role": "assistant", "content": b}
+                      for i, (u, b) in enumerate(history[:-1])],  # exclude placeholder
+                    {"role": "user", "content": message},
+                ],
+                extra_body={"include_retrieval_info": True},
+                stream=True,
             )
-        
-        if not reranked_results:
-            return "I'm sorry, I couldn't find any relevant information in the policy documents to answer your question. Could you try rephrasing your question or asking about a different topic?"
-        
-        # Enforce page constraint if present
-        # Document filtering (title tokens)
-        if doc_tokens:
-            reranked_results = [(d,s) for d,s in reranked_results if doc_matches(getattr(d,'metadata',{}), doc_tokens)]
 
-        # Page filter
-        if want_page is not None:
-            page_filtered = [(d, s) for d, s in reranked_results if page_matches(getattr(d, 'metadata', {}), want_page)]
-            if not page_filtered:
-                # Fallback: exhaustive scan of vectorstore for that page & doc tokens
-                all_docs = []
-                try:
-                    for i in range(len(vectorstore.index_to_docstore_id)):
-                        doc = vectorstore.docstore.search(vectorstore.index_to_docstore_id[i])
-                        meta = getattr(doc,'metadata',{})
-                        if doc_tokens and not doc_matches(meta, doc_tokens):
-                            continue
-                        if page_matches(meta, want_page):
-                            all_docs.append(doc)
-                except Exception:
-                    pass
-                if all_docs:
-                    # treat as retrieved with neutral score
-                    reranked_results = [(d, 0.0) for d in all_docs]
-                    page_filtered = reranked_results
-            else:
-                reranked_results = page_filtered
+            response_text = ""
+            for chunk in stream:
+                delta = chunk.choices[0].delta
+                if delta and delta.content:  # delta.content is a string or None
+                    response_text += delta.content
+                    # Stream update to Gradio UI
+                    history[-1][1] = response_text
+                    yield history, history
 
-            # If still nothing after fallback, return not found
-            if want_page is not None and (not reranked_results or (doc_tokens and not any(page_matches(getattr(d,'metadata',{}), want_page) for d,_ in reranked_results))):
-                return "Not found in sources."
+            aggregated_responses.append(response_text or "⚠️ Empty response")
 
-        top_docs = [doc for doc, score in reranked_results]
+        except Exception as e:
+            aggregated_responses.append(f"⚠️ Error during run {run+1}: {str(e)}")
 
-        # If single page requested consolidate all fragments so quotes not truncated
-        if want_page is not None:
-            consolidated = consolidate_page(top_docs, str(want_page))
-            if consolidated:
-                top_docs = consolidated
+    # 🔹 Choose the “best” response (longest for now)
+    best_response = max(aggregated_responses, key=len, default="⚠️ No response")
+    history[-1][1] = best_response
+    yield history, history
 
-        if verbatim_mode:
-            alias_map = _build_alias_map(top_docs)
-            # Specialized extraction for enumerated objectives if user asks for objectives
-            wants_objectives = 'objective' in message.lower()
-            objectives_output = None
-            if wants_objectives:
-                collected = []
-                doc_names = set()
-                for d in top_docs:
-                    meta = getattr(d, 'metadata', {})
-                    raw = d.page_content
-                    objs = _extract_enumerated_objectives(raw)
-                    if objs:
-                        src = os.path.splitext(os.path.basename(meta.get('source','Unknown')))[0]
-                        doc_names.add(src)
-                        for o in objs:
-                            collected.append(o)
-                # Collapse duplicates by label keeping first
-                dedup = []
-                seen_lab = set()
-                for lab, body in collected:
-                    if lab in seen_lab:
-                        continue
-                    seen_lab.add(lab)
-                    dedup.append((lab, body))
-                if len(dedup) >= 3:  # threshold to treat as valid objective list
-                    md = _format_objectives_markdown(dedup, doc_names, alias_map=alias_map)
-                    if md:
-                        objectives_output = md
-                        yield md
-                        try:
-                            log_exchange(message, md, meta={"mode":"verbatim_objectives","count":len(dedup)})
-                        except Exception:
-                            pass
-                        return
-            is_comparison = _detect_comparison_intent(message)
-            if is_comparison:
-                rows = _extract_quote_records(message, top_docs)
-                if not rows:
-                    return "Not found in sources."
-                # Replace Document column with alias
-                alias_map_rows = _build_alias_map(top_docs)
-                for r in rows:
-                    r['Document'] = alias_map_rows.get(r['Document'], r['Document'])
-                    # Rebuild citation using alias
-                    # Extract meta again not stored; citation already present keep as is for now
-                table_md = _quote_records_to_table(rows)
-                doc_set = sorted({r['Document'] for r in rows})
-                header = f"**Comparative Excerpts** ({len(rows)} sentences)\n"
-                guidance = "Columns: Document alias, Page, Excerpt, Citation."
-                sources_section = "\n\nSources:\n" + "\n".join([f"- {alias_map_rows.get(k,k)}: {k}" for k in sorted(alias_map_rows)])
-                answer = header + guidance + "\n\n" + table_md + sources_section
-                yield answer
-                try:
-                    log_exchange(message, answer, meta={"mode": "verbatim_compare", "docs": doc_set})
-                except Exception:
-                    pass
-                return
-            else:
-                # Rebuild quotes with alias citation for cleanliness
-                quotes_raw = []
-                import re, math
-                terms = [t.lower() for t in re.findall(r"[A-Za-z0-9]+", message) if len(t)>2]
-                term_set = set(terms)
-                scored=[]
-                for d in top_docs:
-                    meta = getattr(d,'metadata',{})
-                    sentences = re.split(r"(?<=[\.!?])\s+", d.page_content)
-                    for sent in sentences:
-                        s = sent.strip()
-                        if not s:
-                            continue
-                        toks=[w.lower() for w in re.findall(r"[A-Za-z0-9]+", s)]
-                        if not toks:
-                            continue
-                        overlap = len(term_set.intersection(toks))
-                        if overlap==0:
-                            continue
-                        score = overlap / math.log(len(toks)+1,2)
-                        scored.append((score,s,meta))
-                scored.sort(key=lambda x:x[0], reverse=True)
-                seen=set(); quotes=[]
-                for score, s, meta in scored:
-                    key=(s, meta.get('source'), meta.get('page_label'))
-                    if key in seen: continue
-                    seen.add(key)
-                    quotes.append(f"- \"{s}\" {_citation(meta, alias_map)}")
-                    if len(quotes)>=12: break
-                quotes = quotes
-                if not quotes:
-                    return "Not found in sources."
-                # Summarize document + page coverage
-                doc_ids = []
-                pages = set()
-                for d in top_docs:
-                    m = getattr(d, 'metadata', {})
-                    sid = os.path.splitext(os.path.basename(m.get('source', 'Unknown')))[0]
-                    if sid not in doc_ids:
-                        doc_ids.append(sid)
-                    pg = m.get('page_label') or m.get('page')
-                    if pg is not None:
-                        pages.add(str(pg))
-                coverage = f"{len(quotes)} excerpt(s) from {len(doc_ids)} document(s)"
-                if want_page is not None:
-                    coverage += f" (page {want_page})"
-                elif pages:
-                    coverage += f" across pages {', '.join(sorted(pages))}"
-                header = f"**Verbatim Excerpts** ({coverage})\n"
-                sources_section = "\n\nSources:\n" + "\n".join([f"- {_citation({'source': sid}, alias_map).split()[0][1:-1]}: {sid}" for sid in doc_ids])
-                answer = header + "\n".join(quotes) + sources_section
-                yield answer
-                try:
-                    log_exchange(message, answer, meta={"mode": "verbatim", "page": want_page, "docs": doc_ids})
-                except Exception:
-                    pass
-                return
 
-        # Perform sentiment and coherence analysis if enabled
-        sentiment_rollup = get_sentiment(top_docs) if ENABLE_SENTIMENT else {}
-        coherence_report_ = coherence_report(reranked_results=top_docs, input_text=message) if ENABLE_COHERENCE else ""
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue", secondary_hue="gray")) as demo:
+    gr.Markdown("# 🤖 Policy-Agent Chatbot\nAsk me about policies. I’ll query the knowledge base multiple times to retrieve the best answer for you!")
 
-        # Build base messages from strict template
-        allow_meta = None
-        if want_page is not None and doc_tokens:
-            # simple doc_id alias from tokens joined
-            allow_meta = {"doc_id": "_".join(doc_tokens), "pages": [want_page]}
-        base_messages = build_messages(
-            query=message,
-            top_docs=top_docs,
-            task_mode="verbatim_sentiment",
-            sentiment_rollup=sentiment_rollup if ENABLE_SENTIMENT else {},
-            coherence_report=coherence_report_ if ENABLE_COHERENCE else "",
-            allowlist_meta=allow_meta
-        )
-
-        # Insert recent history (excluding system + final user already in base) after system message
-        messages = [base_messages[0]]  # system
-        # Combine persisted history (only at first call when provided history empty)
-        if not history and PERSISTED_HISTORY:
-            history.extend(PERSISTED_HISTORY[-6:])  # seed last 6 past exchanges
-        recent_history = history[-6:] if len(history) > 6 else history
-        for u, a in recent_history:
-            messages.append({"role": "user", "content": u})
-            messages.append({"role": "assistant", "content": a})
-        messages.append(base_messages[1])  # current user prompt (template)
-
-        # Stream response from the API
-        response = ""
-        heading_added = False
-        for chunk in stream_llm_response(messages):
-            if not heading_added:
-                chunk = "**Answer**\n" + chunk.lstrip()
-                heading_added = True
-            response += chunk
-            yield response
-        # Append sources block (non-streamed) for clarity
-        alias_map_final = _build_alias_map(top_docs)
-        if alias_map_final:
-            sources_block = "\n\nSources:\n" + "\n".join([f"- {a}: {doc}" for doc,a in {v:k for k,v in alias_map_final.items()}.items()])
-            response += sources_block
-            yield response
-        # After final response, log exchange persistently
-        try:
-            log_exchange(message, response, meta={"pages": [getattr(d.metadata,'page_label', None) if hasattr(d,'metadata') else None for d in top_docs]})
-        except Exception as log_err:
-            print(f"Logging error: {log_err}")
-
-    except Exception as e:
-        error_msg = f"I encountered an error while processing your request: {str(e)}"
-        yield error_msg
-
-## Removed custom prompt builder in favor of strict template usage
-
-def stream_llm_response(messages):
-    """Stream response from the LLM API."""
-    headers = {
-        "Authorization": f"Bearer {API_KEY}",
-        "Content-Type": "application/json"
-    }
-
-    data = {
-        "model": MODEL,
-        "messages": messages,
-        "temperature": 0.2,
-        "stream": True,
-        "max_tokens": 2000
-    }
-
-    try:
-        with requests.post("https://inference.do-ai.run/v1/chat/completions", 
-                          headers=headers, json=data, stream=True, timeout=30) as r:
-            if r.status_code != 200:
-                yield f"[ERROR] API returned status {r.status_code}: {r.text}"
-                return
-
-            for line in r.iter_lines(decode_unicode=True):
-                if not line or line.strip() == "data: [DONE]":
-                    continue
-                if line.startswith("data: "):
-                    line = line[len("data: "):]
-
-                try:
-                    chunk = json.loads(line)
-                    delta = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "")
-                    if delta:
-                        yield delta
-                        time.sleep(0.01)  # Small delay for smooth streaming
-                except json.JSONDecodeError:
-                    continue
-                except Exception as e:
-                    print(f"Streaming error: {e}")
-                    continue
-                    
-    except requests.exceptions.RequestException as e:
-        yield f"[ERROR] Network error: {str(e)}"
-    except Exception as e:
-        yield f"[ERROR] Unexpected error: {str(e)}"
-
-def update_sentiment_setting(enable):
-    """Update global sentiment analysis setting."""
-    global ENABLE_SENTIMENT
-    ENABLE_SENTIMENT = enable
-    return f"✅ Sentiment analysis {'enabled' if enable else 'disabled'}"
-
-def update_coherence_setting(enable):
-    """Update global coherence analysis setting."""
-    global ENABLE_COHERENCE
-    ENABLE_COHERENCE = enable
-    return f"✅ Coherence analysis {'enabled' if enable else 'disabled'}"
-
-# Create the chat interface
-with gr.Blocks(title="Kenya Policy Assistant - Chat", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🏛️ Kenya Policy Assistant - Interactive Chat
-    Ask questions about Kenya's policies and have a conversation! I can help you understand policy documents with sentiment and coherence analysis.
-    """)
-        # Floating popup embed for external policy-agent widget (bottom-right)
-        # Assumption: vendor script auto-renders a launcher; we just position container.
     popup_widget_html = '''<style>
         .policy-agent-popup-container { position:fixed; bottom:16px; right:16px; z-index:9999; }
         </style>
@@ -558,107 +74,16 @@ with gr.Blocks(title="Kenya Policy Assistant - Chat", theme=gr.themes.Soft()) as
             </script>
         </div>'''
     gr.HTML(popup_widget_html)
-    
-    with gr.Row():
-        with gr.Column(scale=3):
-            # Settings row at the top
-            with gr.Row():
-                sentiment_toggle = gr.Checkbox(
-                    label="📊 Sentiment Analysis", 
-                    value=True,
-                    info="Analyze tone and sentiment of policy documents"
-                )
-                coherence_toggle = gr.Checkbox(
-                    label="🔍 Coherence Analysis", 
-                    value=True,
-                    info="Check coherence and consistency of retrieved documents"
-                )
-            
-            # Main chat interface
-            chatbot = gr.Chatbot(
-                height=500,
-                bubble_full_width=False,
-                show_copy_button=True,
-                show_share_button=True,
-                avatar_images=("👤", "🤖"),
-                value=PERSISTED_HISTORY  # seed prior memory
-            )
-            
-            msg = gr.Textbox(
-                placeholder="Ask me about Kenya's policies... (e.g., 'What are the renewable energy regulations?')",
-                label="Your Question",
-                lines=2
-            )
-            
-            with gr.Row():
-                submit_btn = gr.Button("📤 Send", variant="primary")
-        
-        with gr.Column(scale=1):
-            gr.Markdown("""
-            ### 💡 Chat Tips
-            - Ask specific questions about Kenya policies
-            - Ask follow-up questions based on responses
-            - Reference previous answers: *"What does this mean?"*
-            - Request elaboration: *"Can you explain more?"*
-            
-            ### 📝 Example Questions
-            - *"What are Kenya's renewable energy policies?"*
-            - *"Tell me about water management regulations"*
-            - *"What penalties exist for environmental violations?"*
-            - *"How does this relate to what you mentioned earlier?"*
-            
-            ### ⚙️ Analysis Features
-            **Sentiment Analysis**: Understands the tone and intent of policy text
-            
-            **Coherence Analysis**: Checks if retrieved documents are relevant and consistent
-            """)
-            
-            with gr.Accordion("📊 Analysis Status", open=False):
-                sentiment_status = gr.Textbox(
-                    value="✅ Sentiment analysis enabled",
-                    label="Sentiment Status",
-                    interactive=False
-                )
-                coherence_status = gr.Textbox(
-                    value="✅ Coherence analysis enabled", 
-                    label="Coherence Status",
-                    interactive=False
-                )
 
-    # Chat functionality
-    def respond(message, history, verbatim_mode):
-        if message.strip():
-            bot_message = chat_response(message, history, verbatim_mode=verbatim_mode)
-            history.append([message, ""])
-            
-            for partial_response in bot_message:
-                history[-1][1] = partial_response
-                yield history, ""
-        else:
-            yield history, ""
+    chatbot = gr.Chatbot(height=500)
+    msg = gr.Textbox(placeholder="Type your question...")
+    retrieval_slider = gr.Slider(1, 10, value=DEFAULT_RETRIEVAL_RUNS, step=1, label="Number of retrieval runs")
+    clear = gr.Button("Clear Chat")
 
-    verbatim_toggle = gr.Checkbox(label="Verbatim Mode", value=VERBATIM_MODE_DEFAULT, info="Return only exact quoted excerpts (no generation).")
-    submit_btn.click(respond, [msg, chatbot, verbatim_toggle], [chatbot, msg])
-    msg.submit(respond, [msg, chatbot, verbatim_toggle], [chatbot, msg])
-    
-    # Update settings when toggles change
-    sentiment_toggle.change(
-        fn=update_sentiment_setting,
-        inputs=[sentiment_toggle],
-        outputs=[sentiment_status]
-    )
-    
-    coherence_toggle.change(
-        fn=update_coherence_setting,
-        inputs=[coherence_toggle],
-        outputs=[coherence_status]
-    )
+    msg.submit(policy_chat, [msg, chatbot, retrieval_slider], [chatbot, chatbot])
+    msg.submit(lambda: "", None, msg)  # clear textbox
+    clear.click(lambda: None, None, chatbot, queue=False)
 
 if __name__ == "__main__":
-    print("🚀 Starting Kenya Policy Assistant Chat...")
-    demo.queue(max_size=20).launch(
-        share=True, 
-        debug=True,
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+    demo.launch(debug=True)
+

requirements.txt

@@ -15,4 +15,5 @@ rank-bm25
 pypdf
 Pillow
 pytesseract
+openai