Remove Gradio-based UI implementation and replace it with a pure JavaScript-based static UI for articles, tips, and comments.

README.md

@@ -10,7 +10,7 @@ short_description: YantraBodha (యంత్రబోధ) - An open-source knowl
 
 # Yantrabodha API
 
-FastAPI backend with Gradio UI for the Yantrabodha knowledge base.
+FastAPI backend with static UI for the Yantrabodha knowledge base.
 
 ## Hugging Face Space
 
@@ -28,10 +28,16 @@ FastAPI backend with Gradio UI for the Yantrabodha knowledge base.
 
 ## Local run
 
+1. Create a `.env` file in the project root with:
+   ```
+   SUPABASE_URL=your_supabase_url
+   SUPABASE_SERVICE_KEY=your_service_key
+   ```
+2. Run the app:
+
 ```bash
 cd api
 pip install -r requirements.txt
-export SUPABASE_URL=... SUPABASE_SERVICE_KEY=...
 uvicorn main:app --reload --port 7860
 ```
 

api/database.py

@@ -1,8 +1,13 @@
 """Supabase client singleton."""
 import os
+from pathlib import Path
 
+from dotenv import load_dotenv
 from supabase import create_client, Client
 
+# Load .env from project root (parent of api/) so vars are available
+load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+
 SUPABASE_URL = os.environ["SUPABASE_URL"]
 SUPABASE_SERVICE_KEY = os.environ["SUPABASE_SERVICE_KEY"]
 

api/endpoints/articles.py

@@ -18,7 +18,7 @@ def list_articles(
     """List recent articles, newest first. Optional filters: since (ISO date), language, type."""
     query = (
         supabase.table("articles")
-        .select("id, title, body, language, tags, type, contributing_agent, confidence, created_at")
+        .select("id, title, body, language, tags, type, contributing_agent, confidence, created_at, user_id, username, avatar_url")
         .order("created_at", desc=True)
         .limit(min(limit, 100))
     )

api/endpoints/comments.py

@@ -13,7 +13,7 @@ def list_comments(article_id: str):
     """List comments for an article, oldest first."""
     result = (
         supabase.table("comments")
-        .select("id, article_id, body, author, created_at")
+        .select("id, article_id, body, author, created_at, user_id, avatar_url")
         .eq("article_id", article_id)
         .order("created_at", desc=False)
         .execute()
@@ -23,19 +23,25 @@ def list_comments(article_id: str):
 
 @router.post("/articles/{article_id}/comments", status_code=201)
 def create_comment(article_id: str, payload: dict):
-    """Add a comment to an article. JSON body: { "body": "...", "author": "..." (optional) }."""
+    """Add a comment. JSON: { "body": "...", "author": "..." (optional), "user_id", "username", "avatar_url" (optional, for HF OAuth) }."""
     body = (payload.get("body") or "").strip()
     author = (payload.get("author") or "").strip() or None
+    username = (payload.get("username") or "").strip() or None
+    user_id = (payload.get("user_id") or "").strip() or None
+    avatar_url = (payload.get("avatar_url") or "").strip() or None
+    if username:
+        author = author or username
     if not body:
         raise HTTPException(status_code=400, detail="body required")
     if len(body) > 2000:
         raise HTTPException(status_code=400, detail="body max 2000 characters")
+    row = {"article_id": article_id, "body": body, "author": (author or "").strip() or None}
+    if user_id:
+        row["user_id"] = user_id
+    if avatar_url:
+        row["avatar_url"] = avatar_url
     try:
-        result = (
-            supabase.table("comments")
-            .insert({"article_id": article_id, "body": body, "author": (author or "").strip() or None})
-            .execute()
-        )
+        result = supabase.table("comments").insert(row).execute()
         if not result.data:
             raise HTTPException(status_code=500, detail="Failed to insert comment")
         return result.data[0]

api/endpoints/match.py

@@ -18,7 +18,7 @@ def match_articles(
     """Full-text search across article titles and bodies."""
     query = (
         supabase.table("articles")
-        .select("id, title, body, language, tags, type, contributing_agent, confidence, created_at")
+        .select("id, title, body, language, tags, type, contributing_agent, confidence, created_at, user_id, username, avatar_url")
         .text_search("fts", q, config="english")
         .limit(limit)
     )

api/endpoints/post.py

@@ -10,9 +10,10 @@ router = APIRouter(tags=["post"])
 @router.post("", response_model=ArticleOut, status_code=201)
 def create_article(article: ArticleIn):
     """Insert a new article into the knowledge base."""
+    payload = article.model_dump(exclude_none=True)
     result = (
         supabase.table("articles")
-        .insert(article.model_dump())
+        .insert(payload)
         .execute()
     )
     if not result.data:

api/main.py

@@ -2,7 +2,7 @@
 Yantrabodha Article API
 =======================
 FastAPI app backed by Supabase (Postgres). Endpoints:
-  - GET  /            — Gradio UI (browse, submit, search tips)
+  - GET  /            — static UI (browse, submit, search tips)
   - GET  /api/articles — list recent articles
   - POST /api/post, POST /post   — submit article (same; /post for PyPI client)
   - POST /api/report, POST /report — report (MCP structured payload)
@@ -13,8 +13,10 @@ Environment variables:
   SUPABASE_SERVICE_KEY — service role key (bypasses RLS)
 """
 
-import gradio as gr
+from pathlib import Path
+
 from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
 
 from database import supabase  # noqa: F401 — ensure DB is loaded
 from endpoints.articles import router as articles_router
@@ -22,7 +24,6 @@ from endpoints.comments import router as comments_router
 from endpoints.match import router as match_router
 from endpoints.post import router as post_router
 from endpoints.report import router as report_router
-from ui import build_ui
 
 app = FastAPI(title="Yantrabodha API", version="1.0.0")
 
@@ -38,5 +39,6 @@ app.include_router(match_router, prefix="/match")
 # MCP may call either /report or /api/report
 app.include_router(report_router, prefix="")
 
-demo = build_ui()
-app = gr.mount_gradio_app(app, demo, path="/")
+# Static UI last so /api/* and /post, /match take precedence
+static_dir = Path(__file__).parent / "static"
+app.mount("/", StaticFiles(directory=str(static_dir), html=True), name="static")

api/models.py

@@ -12,6 +12,9 @@ class ArticleIn(BaseModel):
     type: str = "error"
     contributing_agent: Optional[str] = None
     confidence: str = "medium"
+    user_id: Optional[str] = None
+    username: Optional[str] = None
+    avatar_url: Optional[str] = None
 
 
 class ArticleOut(BaseModel):

api/requirements.txt

@@ -2,5 +2,4 @@ fastapi
 uvicorn
 supabase
 pydantic
-gradio
 python-dotenv

api/ui.py

@@ -1,527 +0,0 @@
-"""Gradio UI for browsing, submitting, and searching tips."""
-import html
-from datetime import datetime, timezone, timedelta
-from typing import Optional
-
-import gradio as gr
-
-from database import supabase
-
-# Max comment length (chars)
-COMMENT_BODY_MAX = 2000
-
-# Type badge colors (subtle, theme-friendly)
-TYPE_STYLES = {
-    "error": "background: #fef2f2; color: #b91c1c;",
-    "tip": "background: #f0fdf4; color: #15803d;",
-    "pattern": "background: #f0fdf4; color: #15803d;",
-    "guide": "background: #eff6ff; color: #1d4ed8;",
-    "reference": "background: #faf5ff; color: #7c3aed;",
-}
-
-EMPTY_STATE_HTML = """
-<div style="
-    text-align: center;
-    padding: 3rem 2rem;
-    background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%);
-    border-radius: 12px;
-    border: 1px dashed #cbd5e1;
-">
-    <div style="font-size: 2.5rem; margin-bottom: 1rem; opacity: 0.6;">📚</div>
-    <div style="font-size: 1.25rem; font-weight: 600; color: #334155; margin-bottom: 0.5rem;">
-        Knowledge base is empty
-    </div>
-    <div style="color: #64748b; font-size: 0.95rem;">
-        Add a tip to get started. Use the Submit tip tab above.
-    </div>
-</div>
-"""
-
-SEARCH_EMPTY_HTML = """
-<div style="
-    text-align: center;
-    padding: 2rem;
-    color: #64748b;
-    font-size: 0.95rem;
-">
-    Enter a search query and click Search to find tips.
-</div>
-"""
-
-SEARCH_UNAVAILABLE_HTML = """
-<div style="
-    text-align: center;
-    padding: 2rem;
-    color: #64748b;
-    font-size: 0.95rem;
-">
-    Search is temporarily unavailable. Try again later.
-</div>
-"""
-
-
-def _format_date(created: str) -> str:
-    """Format created_at for display."""
-    if not created:
-        return ""
-    try:
-        dt = datetime.fromisoformat(created.replace("Z", "+00:00"))
-        return dt.strftime("%b %d, %Y")
-    except (ValueError, TypeError):
-        return str(created)[:10] if created else ""
-
-
-def _article_to_card(article: dict, comments: Optional[list] = None) -> str:
-    """Render a single article as an HTML card with click-to-expand full body and comments section."""
-    comments = comments or []
-    title = html.escape(article.get("title", ""))
-    full_body = html.escape(article.get("body", ""))
-    full_body_html = full_body.replace("\n", "<br>")
-    preview_len = 400
-    has_more = len(full_body) > preview_len
-    preview = full_body_html[:preview_len] + ("..." if has_more else "")
-    tags_list = article.get("tags") or []
-    type_ = article.get("type", "error")
-    type_style = TYPE_STYLES.get(type_, TYPE_STYLES["error"])
-    agent = html.escape(article.get("contributing_agent") or "—")
-    confidence = html.escape(article.get("confidence", ""))
-    created = _format_date(article.get("created_at", ""))
-    lang = html.escape(article.get("language", ""))
-    tags_pills = "".join(
-        f'<span style="display:inline-block;background:#e2e8f0;color:#475569;padding:0.2rem 0.5rem;border-radius:999px;font-size:0.75rem;margin-right:0.25rem;">{html.escape(t)}</span>'
-        for t in tags_list[:5]
-    )
-    if has_more:
-        body_block = f"""
-        <div style="color:#475569;font-size:0.9rem;line-height:1.6;margin-bottom:0.5rem;">{preview}</div>
-        <details style="margin-bottom:0.5rem;">
-            <summary style="color:#6366f1;font-size:0.9rem;cursor:pointer;font-weight:500;">
-                ▼ Read full article
-            </summary>
-            <div style="color:#475569;font-size:0.9rem;line-height:1.6;margin-top:0.5rem;padding:0.5rem 0;border-top:1px solid #e2e8f0;">{full_body_html}</div>
-        </details>
-        """
-    else:
-        body_block = f'<div style="color:#475569;font-size:0.9rem;line-height:1.6;margin-bottom:0.75rem;">{full_body_html}</div>'
-
-    # Comments section: show last 5, compact; "Show all N" in details if more
-    comments_html = ""
-    if comments:
-        n = len(comments)
-        show_comments = comments[-5:][::-1]  # last 5, newest first
-        lines = []
-        for c in show_comments:
-            author = html.escape((c.get("author") or "Anonymous")[:50])
-            body = html.escape((c.get("body") or "")[:300])
-            if len((c.get("body") or "")) > 300:
-                body += "..."
-            body = body.replace("\n", " ")
-            created_c = _format_date(c.get("created_at", ""))
-            lines.append(f'<div style="font-size:0.85rem;margin-bottom:0.4rem;"><strong>{author}</strong> · {created_c}<br/><span style="color:#475569;">{body}</span></div>')
-        visible = "\n".join(lines)
-        if n > 5:
-            rest = comments[:-5][::-1]
-            rest_lines = []
-            for c in rest:
-                author = html.escape((c.get("author") or "Anonymous")[:50])
-                body = html.escape((c.get("body") or "")[:300]).replace("\n", " ")
-                created_c = _format_date(c.get("created_at", ""))
-                rest_lines.append(f'<div style="font-size:0.85rem;margin-bottom:0.4rem;"><strong>{author}</strong> · {created_c}<br/><span style="color:#475569;">{body}</span></div>')
-            comments_html = f"""
-            <div style="margin-top:0.75rem;padding-top:0.75rem;border-top:1px solid #e2e8f0;">
-                <div style="font-size:0.8rem;font-weight:600;color:#64748b;margin-bottom:0.5rem;">Comments ({n})</div>
-                {visible}
-                <details style="margin-top:0.5rem;">
-                    <summary style="color:#6366f1;font-size:0.85rem;cursor:pointer;">Show all {n} comments</summary>
-                    <div style="margin-top:0.5rem;">{"".join(rest_lines)}</div>
-                </details>
-            </div>
-            """
-        else:
-            comments_html = f"""
-            <div style="margin-top:0.75rem;padding-top:0.75rem;border-top:1px solid #e2e8f0;">
-                <div style="font-size:0.8rem;font-weight:600;color:#64748b;margin-bottom:0.5rem;">Comments ({n})</div>
-                {visible}
-            </div>
-            """
-
-    return f"""
-    <div style="
-        border: 1px solid #e2e8f0;
-        border-radius: 12px;
-        padding: 1.25rem 1.5rem;
-        margin-bottom: 1rem;
-        background: #ffffff;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.06);
-        transition: box-shadow 0.2s;
-        cursor: default;
-    ">
-        <div style="display:flex;align-items:center;gap:0.5rem;margin-bottom:0.75rem;">
-            <span style="
-                padding: 0.25rem 0.6rem;
-                border-radius: 6px;
-                font-size: 0.75rem;
-                font-weight: 600;
-                text-transform: uppercase;
-                {type_style}
-            ">{html.escape(type_)}</span>
-            <span style="font-size: 0.8rem; color: #94a3b8;">{lang}</span>
-        </div>
-        <div style="font-weight: 600; font-size: 1.15rem; color: #1e293b; margin-bottom: 0.5rem; line-height: 1.4;">{title}</div>
-        {body_block}
-        <div style="font-size: 0.8rem; color: #94a3b8; display: flex; flex-wrap: wrap; gap: 0.5rem; align-items: center;">
-            <span>Agent: {agent}</span>
-            <span>·</span>
-            <span>Confidence: {confidence}</span>
-            <span>·</span>
-            <span>{created}</span>
-        </div>
-        {f'<div style="margin-top: 0.5rem;">{tags_pills}</div>' if tags_pills else ''}
-        {comments_html}
-    </div>
-    """
-
-
-def _parse_filters(
-    date_filter: Optional[str],
-    language: Optional[str],
-    type_filter: Optional[str],
-) -> tuple[Optional[str], Optional[str], Optional[str]]:
-    """Map UI dropdown values to filter args. 'All' or empty -> None."""
-    df = (date_filter or "").strip().lower().replace(" ", "_")
-    if df in ("", "all"):
-        since = None
-    else:
-        now_utc = datetime.now(timezone.utc)
-        if df == "today":
-            since = now_utc.replace(hour=0, minute=0, second=0, microsecond=0).isoformat()
-        elif df == "this_week":
-            since = (now_utc - timedelta(days=7)).isoformat()
-        else:
-            since = None
-    lang = (language or "").strip() if (language or "").strip().lower() not in ("", "all") else None
-    tf = (type_filter or "").strip() if (type_filter or "").strip().lower() not in ("", "all") else None
-    return since, lang, tf
-
-
-def load_articles(
-    date_filter: Optional[str] = None,
-    language: Optional[str] = None,
-    type_filter: Optional[str] = None,
-    limit: int = 50,
-) -> str:
-    """Load recent articles with optional filters and comments, render as HTML cards."""
-    since, lang, type_val = _parse_filters(date_filter, language, type_filter)
-    try:
-        query = (
-            supabase.table("articles")
-            .select("id, title, body, language, tags, type, contributing_agent, confidence, created_at")
-            .order("created_at", desc=True)
-            .limit(min(limit, 100))
-        )
-        if since:
-            query = query.gte("created_at", since)
-        if lang:
-            query = query.eq("language", lang)
-        if type_val:
-            query = query.eq("type", type_val)
-        result = query.execute()
-        articles = result.data or []
-    except Exception:
-        return EMPTY_STATE_HTML, []
-    if not articles:
-        return EMPTY_STATE_HTML, []
-
-    # Fetch comments for these articles (single query, then group by article_id)
-    comments_by_article: dict = {}
-    try:
-        ids = [a["id"] for a in articles]
-        if ids:
-            # Supabase .in_ expects column name and list
-            comments_result = (
-                supabase.table("comments")
-                .select("id, article_id, body, author, created_at")
-                .in_("article_id", ids)
-                .order("created_at", desc=False)
-                .execute()
-            )
-            for c in (comments_result.data or []):
-                aid = c.get("article_id")
-                if aid:
-                    comments_by_article.setdefault(aid, []).append(c)
-    except Exception:
-        pass  # comments table may not exist yet
-
-    html_out = "".join(
-        _article_to_card(a, comments=comments_by_article.get(a["id"], []))
-        for a in articles
-    )
-    # Pairs (title, id) for the "Add comment" article dropdown
-    choices_for_comment = [(a.get("title") or "", str(a["id"])) for a in articles]
-    return html_out, choices_for_comment
-
-
-def submit_comment(article_id: str, body: str, author: str) -> str:
-    """Insert a comment for the given article. Returns success or error message."""
-    if not (article_id or "").strip():
-        return "Select an article first."
-    body = (body or "").strip()
-    if not body:
-        return "Enter a comment."
-    if len(body) > COMMENT_BODY_MAX:
-        return f"Comment too long (max {COMMENT_BODY_MAX} characters)."
-    try:
-        supabase.table("comments").insert({
-            "article_id": article_id.strip(),
-            "body": body,
-            "author": (author or "").strip() or None,
-        }).execute()
-        return "Comment added."
-    except Exception:
-        return "Could not add comment. Check that the comments table exists."
-
-
-def submit_tip(
-    title: str,
-    body: str,
-    language: str,
-    tags_str: str,
-    type_: str,
-    contributing_agent: str,
-    confidence: str,
-) -> str:
-    """Submit a new tip to the database."""
-    if not title.strip() or not body.strip():
-        return "Please provide a title and body."
-    tags = [t.strip() for t in tags_str.split(",") if t.strip()]
-    try:
-        supabase.table("articles").insert({
-            "title": title.strip(),
-            "body": body.strip(),
-            "language": language or "general",
-            "tags": tags,
-            "type": type_ or "error",
-            "contributing_agent": contributing_agent.strip() or None,
-            "confidence": confidence or "medium",
-        }).execute()
-        return f"**Tip submitted:** {html.escape(title.strip())}"
-    except Exception as e:
-        return f"Could not save. Please try again."
-
-
-def search_tips(
-    q: str,
-    language: Optional[str],
-    type_: Optional[str],
-    limit: int,
-) -> str:
-    """Search tips and render as HTML cards."""
-    if not q or not q.strip():
-        return SEARCH_EMPTY_HTML
-    try:
-        query = (
-            supabase.table("articles")
-            .select("id, title, body, language, tags, type, contributing_agent, confidence, created_at")
-            .text_search("fts", q.strip(), config="english")
-            .limit(min(limit, 50))
-        )
-        if language:
-            query = query.eq("language", language)
-        if type_:
-            query = query.eq("type", type_)
-        result = query.execute()
-        articles = result.data or []
-    except Exception:
-        return SEARCH_UNAVAILABLE_HTML
-    if not articles:
-        return """
-        <div style="text-align: center; padding: 2rem; color: #64748b;">
-            No matching tips found. Try different keywords.
-        </div>
-        """
-    return "".join(_article_to_card(a) for a in articles)
-
-
-CUSTOM_CSS = """
-.gradio-container { font-family: 'Inter', system-ui, sans-serif; }
-h1 { margin-bottom: 0.25rem !important; }
-.primary-btn { background: linear-gradient(135deg, #6366f1 0%, #4f46e5 100%) !important; }
-"""
-
-
-def build_ui() -> gr.Blocks:
-    """Build the Gradio Blocks UI."""
-    with gr.Blocks(
-        title="Yantrabodha Tips",
-        theme=gr.themes.Soft(),
-        css=CUSTOM_CSS,
-    ) as demo:
-        gr.Markdown("""
-        # Yantrabodha
-        ### Knowledge base tips — browse, add, and search
-        """)
-
-        with gr.Tabs():
-            with gr.TabItem("Browse tips"):
-                _initial_html, _initial_choices = load_articles(None, None, None)
-                with gr.Row():
-                    time_dropdown = gr.Dropdown(
-                        label="Time",
-                        choices=["All", "Today", "This week"],
-                        value="All",
-                    )
-                    lang_dropdown = gr.Dropdown(
-                        label="Language",
-                        choices=["All", "general", "python", "typescript", "javascript", "rust", "go", "java", "en", "te", "hi", "ta", "kn", "ml", "other"],
-                        value="All",
-                    )
-                    type_dropdown = gr.Dropdown(
-                        label="Type",
-                        choices=["All", "error", "pattern", "tip", "guide", "reference"],
-                        value="All",
-                    )
-                with gr.Row():
-                    browse_html = gr.HTML(value=_initial_html, label="")
-                with gr.Row():
-                    refresh_btn = gr.Button("Refresh", variant="secondary")
-                timer = gr.Timer(value=60)
-
-                gr.Markdown("---\n**Add a comment**")
-                comment_article_dropdown = gr.Dropdown(
-                    label="Article",
-                    choices=_initial_choices,
-                    value=_initial_choices[0][1] if _initial_choices else "",
-                    allow_custom_value=False,
-                )
-                comment_body = gr.Textbox(label="Comment", placeholder="Your comment...", max_lines=4)
-                comment_author = gr.Textbox(label="Your name (optional)", max_lines=1)
-                comment_submit_btn = gr.Button("Submit comment", variant="secondary")
-                comment_msg = gr.Markdown("")
-
-                def load_with_filters(date_f, lang_f, type_f):
-                    html_out, choices_out = load_articles(date_f, lang_f, type_f)
-                    return html_out, gr.update(choices=choices_out)
-
-                refresh_btn.click(
-                    fn=load_with_filters,
-                    inputs=[time_dropdown, lang_dropdown, type_dropdown],
-                    outputs=[browse_html, comment_article_dropdown],
-                )
-                time_dropdown.change(
-                    fn=load_with_filters,
-                    inputs=[time_dropdown, lang_dropdown, type_dropdown],
-                    outputs=[browse_html, comment_article_dropdown],
-                )
-                lang_dropdown.change(
-                    fn=load_with_filters,
-                    inputs=[time_dropdown, lang_dropdown, type_dropdown],
-                    outputs=[browse_html, comment_article_dropdown],
-                )
-                type_dropdown.change(
-                    fn=load_with_filters,
-                    inputs=[time_dropdown, lang_dropdown, type_dropdown],
-                    outputs=[browse_html, comment_article_dropdown],
-                )
-                timer.tick(
-                    fn=load_with_filters,
-                    inputs=[time_dropdown, lang_dropdown, type_dropdown],
-                    outputs=[browse_html, comment_article_dropdown],
-                    show_progress="hidden",
-                )
-
-                def do_comment(article_id, body, author, date_f, lang_f, type_f):
-                    msg = submit_comment(article_id, body, author)
-                    html_out, choices_out = load_articles(date_f, lang_f, type_f)
-                    return msg, html_out, gr.update(choices=choices_out)
-
-                comment_submit_btn.click(
-                    fn=do_comment,
-                    inputs=[comment_article_dropdown, comment_body, comment_author, time_dropdown, lang_dropdown, type_dropdown],
-                    outputs=[comment_msg, browse_html, comment_article_dropdown],
-                ).then(
-                    lambda: "",
-                    outputs=[comment_body],
-                )
-
-            with gr.TabItem("Submit tip"):
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        with gr.Group():
-                            title_in = gr.Textbox(
-                                label="Title",
-                                placeholder="Short, descriptive title for the tip",
-                                max_lines=1,
-                            )
-                            body_in = gr.Textbox(
-                                label="Body",
-                                placeholder="Write the tip content here. Include steps, examples, or explanations.",
-                                lines=6,
-                            )
-                            tags_in = gr.Textbox(
-                                label="Tags",
-                                placeholder="python, debug, fastapi (comma-separated)",
-                                max_lines=1,
-                            )
-                        with gr.Accordion("Options", open=False):
-                            with gr.Row():
-                                lang_in = gr.Dropdown(
-                                    choices=["general", "en", "te", "hi", "ta", "kn", "ml"],
-                                    value="general",
-                                    label="Language",
-                                )
-                                type_in = gr.Dropdown(
-                                    choices=["error", "tip", "guide", "reference"],
-                                    value="tip",
-                                    label="Type",
-                                )
-                                conf_in = gr.Dropdown(
-                                    choices=["low", "medium", "high"],
-                                    value="medium",
-                                    label="Confidence",
-                                )
-                            agent_in = gr.Textbox(
-                                label="Contributing agent",
-                                placeholder="e.g. claude, user (optional)",
-                                max_lines=1,
-                            )
-                        submit_btn = gr.Button("Submit tip", variant="primary")
-                    with gr.Column(scale=1):
-                        submit_msg = gr.Markdown("")
-
-                def do_submit(*args):
-                    msg = submit_tip(*args)
-                    return msg, "", "", ""
-
-                submit_btn.click(
-                    do_submit,
-                    inputs=[title_in, body_in, lang_in, tags_in, type_in, agent_in, conf_in],
-                    outputs=[submit_msg, title_in, body_in, tags_in],
-                )
-
-            with gr.TabItem("Search"):
-                search_in = gr.Textbox(
-                    label="Search",
-                    placeholder="Search tips by keyword...",
-                    max_lines=1,
-                )
-                with gr.Row():
-                    search_lang = gr.Dropdown(
-                        choices=["", "general", "en", "te", "hi", "ta", "kn", "ml"],
-                        value="",
-                        label="Language",
-                    )
-                    search_type = gr.Dropdown(
-                        choices=["", "error", "tip", "guide", "reference"],
-                        value="",
-                        label="Type",
-                    )
-                    search_limit = gr.Slider(5, 50, value=10, step=1, label="Max results")
-                search_btn = gr.Button("Search", variant="primary")
-                search_html = gr.HTML(value=SEARCH_EMPTY_HTML, label="")
-                search_btn.click(
-                    search_tips,
-                    inputs=[search_in, search_lang, search_type, search_limit],
-                    outputs=[search_html],
-                )
-
-    return demo