Initial commit

README.md

@@ -14,3 +14,50 @@ short_description: A quick Gradio agent demo
 ---
 
 An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).
+
+# 🧠 Thoughtful AI – Customer Support Agent
+
+A lightweight conversational demo built for the **Thoughtful AI coding exercise**.  
+This app simulates a simple **customer service AI agent** that answers user questions about Thoughtful AI’s healthcare automation agents — using only **hardcoded responses** and a minimal similarity retriever.
+
+---
+
+## 🚀 Overview
+
+The **Thoughtful AI Support Assistant** accepts user questions and returns the most relevant predefined answer.  
+It uses a lightweight token-based similarity model (no external NLP dependencies) to match user input against five common FAQs.
+
+### Example Questions
+- What does the eligibility verification agent (EVA) do?  
+- How does the claims processing agent (CAM) work?  
+- What are the benefits of using Thoughtful AI’s agents?  
+- Tell me about Thoughtful AI’s agents.
+
+---
+
+## 💡 Features
+
+- Conversational chat interface built with **Gradio Blocks**.  
+- **Hardcoded FAQ retrieval** (no external APIs or models required).  
+- **Lightweight custom tokenizer** for fuzzy keyword matching.  
+- Handles unknown inputs gracefully with fallback responses.  
+- Includes confidence scoring and clear, user-friendly formatting.
+
+---
+
+## 🧩 Tech Stack
+
+- **Language:** Python 3.9+  
+- **Framework:** [Gradio](https://gradio.app)  
+- **Deployment:** [Hugging Face Spaces](https://huggingface.co/spaces)  
+- **Dependencies:** None beyond Gradio (no model downloads required)
+
+---
+
+## 🏗️ Local Development
+
+To run locally:
+
+```bash
+pip install gradio
+python app.py

app.py

@@ -1,70 +1,174 @@
+import re
+from dataclasses import dataclass
+from typing import List, Tuple
+from data import RAW_DATA, GENERIC_HELP, EXAMPLES
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
+
+# ======= Retrieval utilities (dependency-free) =======
+@dataclass
+class QA:
+    question: str
+    answer: str
+    keywords: List[str]
+
+def normalize(text: str) -> str:
+    text = text.lower()
+    text = re.sub(r"[^a-z0-9\s\(\)\-\'&/]", " ", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+# A simplified tokenizer to reduce latency
+def tokenize(text: str) -> List[str]:
+    return normalize(text).split()
+
+# Other similarity measures could be used, but jaccard is simple enough and it works
+def jaccard(a: List[str], b: List[str]) -> float:
+    sa, sb = set(a), set(b)
+    if not sa and not sb:
+        return 0.0
+    return len(sa & sb) / len(sa | sb)
+
+def seq_ratio(a: str, b: str) -> float:
+    # lightweight character-overlap ratio (no external dependencies)
+    sa, sb = set(a), set(b)
+    if not sa and not sb:
+        return 0.0
+    return len(sa & sb) / max(len(sa), len(sb))
+
+def contains_any(text: str, needles: List[str]) -> int:
+    t = normalize(text)
+    return sum(1 for n in needles if n in t)
+
+def build_qa_bank(raw) -> List[QA]:
+    bank = []
+    for item in raw["questions"]:
+        q = item["question"]
+        a = item["answer"]
+        kws = []
+        lq = q.lower()
+        if "eva" in lq:
+            kws += ["eva", "eligibility", "benefits", "verification"]
+        if "cam" in lq:
+            kws += ["cam", "claims", "processing", "reimbursement"]
+        if "phil" in lq:
+            kws += ["phil", "payment", "posting", "reconciliation"]
+        if "agents" in lq or "thoughtful ai" in lq:
+            kws += ["agents", "thoughtful ai", "suite", "automation", "healthcare"]
+        bank.append(QA(q, a, kws))
+    return bank
+
+
+QA_BANK = build_qa_bank(RAW_DATA)
+
+def score_query(user_msg: str, qa: QA) -> float:
+    """Return a confidence score for how well `qa` answers `user_msg`."""
+    u_norm = normalize(user_msg)
+    q_tokens = tokenize(qa.question + " " + qa.answer)
+    u_tokens = tokenize(u_norm)
+
+    s_jaccard = jaccard(u_tokens, q_tokens)            # word overlap
+    s_seq_q = seq_ratio(u_norm, normalize(qa.question))  # char overlap vs question
+    s_seq_a = seq_ratio(u_norm, normalize(qa.answer))  # char overlap vs answer
+    s_kw = 0.06 * contains_any(u_norm, qa.keywords)    # keyword hints
+    s_agent_hint = 0.03 if "agent" in u_norm else 0.0
+
+    score = (0.5 * s_jaccard) + (0.25 * s_seq_q) + (0.15 * s_seq_a) + s_kw + s_agent_hint
+    return min(score, 1.5)
+
+def retrieve_best_answer(user_msg: str) -> Tuple[str, str, float]:
+    best = None
+    best_score = -1.0
+    for qa in QA_BANK:
+        s = score_query(user_msg, qa)
+        if s > best_score:
+            best, best_score = qa, s
+    return best.question, best.answer, best_score
+
+# ======= Chat logic =======
+def chat_step(user_msg: str, history: List[Tuple[str, str]], show_conf: bool):
     """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+    Stateless step function for the UI.
+    Returns updated history and an empty textbox string.
     """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+    try:
+        user_msg = (user_msg or "").strip()
+        if not user_msg:
+            # gentle nudge without crashing the flow
+            bot_reply = "Please enter a question about Thoughtful AI’s agents (EVA, CAM, PHIL)."
+            return history + [(user_msg, bot_reply)], ""
 
-    messages = [{"role": "system", "content": system_message}]
+        matched_q, answer, score = retrieve_best_answer(user_msg)
 
-    messages.extend(history)
+        # Arbitrarily setting the matching score to 0.18
+        if score < 0.18:
+            bot_reply = (
+                f"Here’s a quick overview:\n\n{GENERIC_HELP}\n\n"
+                f"_Tip: mention an agent name like EVA, CAM, or PHIL for a precise answer._"
+            )
+        else:
+            bot_reply = f"**Answer:** {answer}"
+            if show_conf:
+                bot_reply += (
+                    f"\n\n_Matched topic:_ “{matched_q}”  \n"
+                    f"_Confidence:_ {score:.2f}"
+                )
 
-    messages.append({"role": "user", "content": message})
+        return history + [(user_msg, bot_reply)], ""
 
-    response = ""
+    except Exception as e:
+        # UI Robustness
+        bot_reply = (
+            "Sorry — I ran into an unexpected error while processing that. "
+            "Please try again or rephrase your question."
+        )
+        # In a real setting, I would log `e` to a file/monitoring system.
+        print(e)
+        return history + [(user_msg or "", bot_reply)], ""
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
 
-        response += token
-        yield response
+# ======= UI =======
+CSS = """
+#app-title {font-size: 28px; font-weight: 700; margin-bottom: 2px;}
+#app-sub  {opacity: 0.8; margin-bottom: 16px;}
+"""
 
+with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "<div id='app-title'>Thoughtful AI – Support Assistant</div>"
+        "<div id='app-sub'>Ask about EVA, CAM, PHIL, or general benefits.</div>"
+    )
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+    with gr.Row():
+        show_conf = gr.Checkbox(label="Show match & confidence", value=True)
+
+    chatbot = gr.Chatbot(type='tuples', height=380)
+    with gr.Row():
+        inp = gr.Textbox(placeholder="Ask a question about Thoughtful AI…", lines=2)
+    with gr.Row():
+        submit = gr.Button("Ask", variant="primary")
+        clear = gr.Button("Clear Chat")
+
+    gr.Examples(examples=EXAMPLES, inputs=inp, label="Try these")
+
+    state = gr.State([])  # chat history
+
+    def on_submit(user_msg, history, conf):
+        new_history, cleared = chat_step(user_msg, history, conf)
+        return new_history, cleared
+
+    submit.click(on_submit, inputs=[inp, state, show_conf], outputs=[chatbot, inp])
+    inp.submit(on_submit, inputs=[inp, state, show_conf], outputs=[chatbot, inp])
+
+    def on_clear():
+        return [], ""
+
+    clear.click(on_clear, outputs=[chatbot, inp])
+
+    # keep state in sync with what's shown
+    def sync_state(chat_history):
+        return chat_history
 
+    chatbot.change(sync_state, inputs=[chatbot], outputs=[state])
 
 if __name__ == "__main__":
     demo.launch()

data.py

@@ -0,0 +1,42 @@
+# Base Q&A
+RAW_DATA = {
+    "questions": [
+        {
+            "question": "What does the eligibility verification agent (EVA) do?",
+            "answer": "EVA automates the process of verifying a patient’s eligibility and benefits information in real-time, eliminating manual data entry errors and reducing "
+                      "claim rejections."
+        },
+        {
+            "question": "What does the claims processing agent (CAM) do?",
+            "answer": "CAM streamlines the submission and management of claims, improving accuracy, reducing manual intervention, and accelerating reimbursements."
+        },
+        {
+            "question": "How does the payment posting agent (PHIL) work?",
+            "answer": "PHIL automates the posting of payments to patient accounts, ensuring fast, accurate reconciliation of payments and reducing administrative burden."
+        },
+        {
+            "question": "Tell me about Thoughtful AI's Agents.",
+            "answer": "Thoughtful AI provides a suite of AI-powered automation agents designed to streamline healthcare processes. These include Eligibility Verification (EVA), "
+                      "Claims Processing (CAM), and Payment Posting (PHIL), among others."
+        },
+        {
+            "question": "What are the benefits of using Thoughtful AI's agents?",
+            "answer": "Using Thoughtful AI's Agents can significantly reduce administrative costs, improve operational efficiency, and reduce errors in critical processes like "
+                      "claims management and payment posting."
+        }
+    ]
+}
+
+GENERIC_HELP = (
+    "I can help with Thoughtful AI’s healthcare automation agents. "
+    "Ask me about Eligibility Verification (EVA), Claims Processing (CAM), or Payment Posting (PHIL), "
+    "or say “Tell me about Thoughtful AI’s agents.”"
+)
+
+EXAMPLES = [
+    "What does EVA do?",
+    "How does CAM help with claims?",
+    "Tell me about Thoughtful AI's agents",
+    "What are the benefits of using Thoughtful AI?",
+    "How does PHIL work?",
+]