Update app.py

app.py

@@ -1,107 +1,254 @@
+# ============================================================================
+# 1. CONSOLIDATED IMPORTS
+# ============================================================================
 import gradio as gr
 import sqlite3
 import pandas as pd
 from huggingface_hub import hf_hub_download, HfApi
-from fastapi import FastAPI
+from fastapi import FastAPI, Response
 from fastapi.responses import JSONResponse
 import os
 import time
 import json
-from typing import Optional
+from typing import Optional, Dict, List, Any
+import uvicorn
+import traceback
 
-# ===== CONFIGURATION =====
+# ============================================================================
+# 2. SHARED GLOBALS & CONFIGURATION
+# ============================================================================
+
+# --- Languages ---
 TARGET_LANGUAGES = ['de', 'en', 'es', 'fr', 'it', 'ja', 'nl', 'pl', 'pt', 'ru', 'zh']
+print(f"🌍 Target Languages: {', '.join([l.upper() for l in TARGET_LANGUAGES])}")
+
+# --- Hugging Face & DB Config ---
 INDEXED_REPO_ID = "cstr/conceptnet-de-indexed"
 INDEXED_DB_FILENAME = "conceptnet-de-indexed.db"
 PROGRESS_FILENAME = "indexing_progress.json"
-CONCEPTNET_BASE = "http://conceptnet.io"
-# =========================
-
-print(f"🌍 Languages: {', '.join([l.upper() for l in TARGET_LANGUAGES])}")
+CONCEPTNET_BASE_URI = "http://conceptnet.io"
+DB_PATH: Optional[str] = None # Will be set by setup_database()
 
+# --- HF Token ---
 HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_TOKEN") or os.environ.get("HF_API_TOKEN")
 
+# --- Full list of 34 ConceptNet Relations (as requested) ---
+# We use this to populate dropdowns and guide the semantic profile
+CONCEPTNET_RELATIONS: Dict[str, str] = {
+    # Main Relations
+    "RelatedTo": "/r/RelatedTo",
+    "IsA": "/r/IsA",
+    "PartOf": "/r/PartOf",
+    "HasA": "/r/HasA",
+    "UsedFor": "/r/UsedFor",
+    "CapableOf": "/r/CapableOf",
+    "AtLocation": "/r/AtLocation",
+    "Causes": "/r/Causes",
+    "HasSubevent": "/r/HasSubevent",
+    "HasFirstSubevent": "/r/HasFirstSubevent",
+    "HasLastSubevent": "/r/HasLastSubevent",
+    "HasPrerequisite": "/r/HasPrerequisite",
+    "HasProperty": "/r/HasProperty",
+    "MotivatedByGoal": "/r/MotivatedByGoal",
+    "ObstructedBy": "/r/ObstructedBy",
+    "Desires": "/r/Desires",
+    "CreatedBy": "/r/CreatedBy",
+    "Synonym": "/r/Synonym",
+    "Antonym": "/r/Antonym",
+    "DistinctFrom": "/r/DistinctFrom",
+    "DerivedFrom": "/r/DerivedFrom",
+    "SymbolOf": "/r/SymbolOf",
+    "DefinedAs": "/r/DefinedAs",
+    "MannerOf": "/r/MannerOf",
+    "LocatedNear": "/r/LocatedNear",
+    "HasContext": "/r/HasContext",
+    "SimilarTo": "/r/SimilarTo",
+    "EtymologicallyRelatedTo": "/r/EtymologicallyRelatedTo",
+    "EtymologicallyDerivedFrom": "/r/EtymologicallyDerivedFrom",
+    "CausesDesire": "/r/CausesDesire",
+    "MadeOf": "/r/MadeOf",
+    "ReceivesAction": "/r/ReceivesAction",
+    "ExternalURL": "/r/ExternalURL",
+    # Negative Relations (from deprecated list, but useful)
+    "NotDesires": "/r/NotDesires",
+    "NotUsedFor": "/r/NotUsedFor",
+    "NotCapableOf": "/r/NotCapableOf",
+    "NotHasProperty": "/r/NotHasProperty",
+}
+
+# Sorted list of (Label, URI) tuples for Gradio dropdowns
+RELATION_CHOICES = sorted(CONCEPTNET_RELATIONS.items())
+
+# ============================================================================
+# 3. DATABASE SETUP & HELPERS
+# ============================================================================
+
 def log_progress(message, level="INFO"):
+    """Helper for logging with emoji prefixes."""
     timestamp = time.strftime("%H:%M:%S")
     prefix = {"INFO": "ℹ️ ", "SUCCESS": "✅", "ERROR": "❌", "WARN": "⚠️ ", "DEBUG": "🔍"}.get(level, "")
     print(f"[{timestamp}] {prefix} {message}")
 
 def check_remote_progress():
+    """Check HF Hub for the indexing progress file."""
     if not HF_TOKEN:
-        return {"indexing_complete": False}
+        log_progress("No HF_TOKEN. Assuming local DB or public repo.", "WARN")
+        # Try public download first
+        try:
+            progress_path = hf_hub_download(
+                repo_id=INDEXED_REPO_ID,
+                filename=PROGRESS_FILENAME,
+                repo_type="dataset"
+            )
+            with open(progress_path, 'r') as f:
+                return json.load(f)
+        except Exception:
+             return {"indexing_complete": False} # Fallback
+    
+    # Try with token if available
     try:
         api = HfApi()
         api.repo_info(repo_id=INDEXED_REPO_ID, repo_type="dataset", token=HF_TOKEN)
-        progress_path = hf_hub_download(repo_id=INDEXED_REPO_ID, filename=PROGRESS_FILENAME, repo_type="dataset", token=HF_TOKEN)
+        progress_path = hf_hub_download(
+            repo_id=INDEXED_REPO_ID,
+            filename=PROGRESS_FILENAME,
+            repo_type="dataset",
+            token=HF_TOKEN
+        )
         with open(progress_path, 'r') as f:
             return json.load(f)
-    except:
+    except Exception as e:
+        log_progress(f"Could not check remote progress: {e}", "WARN")
         return {"indexing_complete": False}
 
-def create_indexed_database():
+def setup_database():
+    """
+    Downloads the pre-indexed database from Hugging Face Hub.
+    """
+    global DB_PATH
+    log_progress("Attempting to load indexed database...", "INFO")
+    
+    # Check if we already have it locally
+    local_path = Path(INDEXED_DB_FILENAME)
+    if local_path.exists() and local_path.stat().st_size > 1000000:
+         log_progress(f"Found existing local DB: {local_path.resolve()}", "SUCCESS")
+         DB_PATH = str(local_path.resolve())
+         return DB_PATH
+
     progress = check_remote_progress()
     if progress.get("indexing_complete"):
         try:
-            path = hf_hub_download(repo_id=INDEXED_REPO_ID, filename=INDEXED_DB_FILENAME, repo_type="dataset", token=HF_TOKEN)
-            log_progress("Indexed DB loaded", "SUCCESS")
+            log_progress(f"Downloading {INDEXED_DB_FILENAME} from {INDEXED_REPO_ID}...", "INFO")
+            path = hf_hub_download(
+                repo_id=INDEXED_REPO_ID,
+                filename=INDEXED_DB_FILENAME,
+                repo_type="dataset",
+                token=HF_TOKEN # Will be None if not set, which is fine for public repos
+            )
+            DB_PATH = path
+            log_progress(f"Indexed DB loaded successfully from Hub: {path}", "SUCCESS")
             return path
-        except:
-            pass
-    return None
-
-DB_PATH = create_indexed_database()
+        except Exception as e:
+            log_progress(f"Failed to download indexed DB: {e}", "ERROR")
+            return None
+    else:
+        log_progress("Remote indexing is not complete or progress file not found.", "ERROR")
+        return None
 
-def get_db_connection():
-    conn = sqlite3.connect(DB_PATH, check_same_thread=False)
-    conn.execute("PRAGMA cache_size = -256000")
-    conn.execute("PRAGMA mmap_size = 4294967296")
+def get_db_connection() -> sqlite3.Connection:
+    """
+    Returns a new SQLite connection to the database.
+    Includes performance PRAGMAs.
+    """
+    if DB_PATH is None:
+        raise ConnectionError("Database path is not set. Call setup_database() first.")
+    
+    # check_same_thread=False is generally safe for read-only operations
+    # in a multi-threaded server like FastAPI/uvicorn.
+    conn = sqlite3.connect(f"file:{DB_PATH}?mode=ro", uri=True, check_same_thread=False)
+    
+    # Performance tuning for read-only connections
+    conn.execute("PRAGMA journal_mode = OFF")
+    conn.execute("PRAGMA synchronous = 0")
+    conn.execute("PRAGMA cache_size = -256000") # 256MB cache
+    conn.execute("PRAGMA mmap_size = 4294967296") # 4GB mmap
+    conn.execute("PRAGMA temp_store = MEMORY")
+    
     return conn
 
-RELATIONS = [
-    ("IsA", f"{CONCEPTNET_BASE}/r/IsA"),
-    ("PartOf", f"{CONCEPTNET_BASE}/r/PartOf"),
-    ("HasA", f"{CONCEPTNET_BASE}/r/HasA"),
-    ("UsedFor", f"{CONCEPTNET_BASE}/r/UsedFor"),
-    ("CapableOf", f"{CONCEPTNET_BASE}/r/CapableOf"),
-    ("Causes", f"{CONCEPTNET_BASE}/r/Causes"),
-    ("HasProperty", f"{CONCEPTNET_BASE}/r/HasProperty"),
-    ("Synonym", f"{CONCEPTNET_BASE}/r/Synonym"),
-    ("Antonym", f"{CONCEPTNET_BASE}/r/Antonym"),
-    ("AtLocation", f"{CONCEPTNET_BASE}/r/AtLocation"),
-    ("RelatedTo", f"{CONCEPTNET_BASE}/r/RelatedTo"),
-    ("DerivedFrom", f"{CONCEPTNET_BASE}/r/DerivedFrom"),
-]
-
-def get_semantic_profile_json(word: str, lang: str = 'en', max_per_relation: int = 10):
-    """Get semantic profile as JSON"""
+# ============================================================================
+# 4. API (FASTAPI) ENDPOINTS
+# (These functions return JSON data and are called by the API)
+# ============================================================================
+
+# --- Create FastAPI app FIRST ---
+app = FastAPI(
+    title="ConceptNet Explorer API",
+    version="1.0",
+    description="A versatile API for querying a ConceptNet SQLite database."
+)
+
+@app.get("/api", tags=["API"])
+def api_docs():
+    """API documentation - accessible at /api"""
+    return {
+        "name": "ConceptNet Explorer API",
+        "version": "1.0",
+        "endpoints": {
+            "/api/profile/{word}": "Get a full semantic profile for a word.",
+            "/api/query": "Run a specific query for edges.",
+            "/api/relations": "List all available relation types.",
+            "/api/languages": "List all supported languages."
+        },
+        "examples": {
+            "profile": "/api/profile/dog?lang=en&limit=10",
+            "query": "/api/query?start_node=dog&relation_uri=/r/IsA&limit=20"
+        },
+        "note": "Visit the root path (/) for the Gradio UI."
+    }
+
+@app.get("/api/profile/{word}", tags=["API"])
+def get_semantic_profile_json(word: str, lang: str = 'en', limit: int = 10):
+    """
+    API Endpoint: Get a full semantic profile for a word as JSON.
+    Queries all 34 relation types.
+    """
     if not word or lang not in TARGET_LANGUAGES:
-        return {"error": "Invalid input"}
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Invalid input. 'word' is required and 'lang' must be valid."}
+        )
     
-    word = word.strip().lower().replace(' ', '_')
-    like_path = f"{CONCEPTNET_BASE}/c/{lang}/{word}%"
+    word_normalized = word.strip().lower().replace(' ', '_')
+    like_path = f"{CONCEPTNET_BASE_URI}/c/{lang}/{word_normalized}%"
     
     result = {
-        "word": word,
-        "language": lang,
-        "nodes": [],
+        "query": {"word": word, "normalized": word_normalized, "lang": lang, "limit_per_relation": limit},
+        "nodes_found": [],
         "relations": {},
-        "total_edges": 0
+        "total_edges_found": 0
     }
     
     try:
         with get_db_connection() as conn:
             cursor = conn.cursor()
             
+            # 1. Find matching nodes
             cursor.execute("SELECT id, label FROM node WHERE id LIKE ? LIMIT 5", (like_path,))
-            result["nodes"] = [{"id": nid, "label": label} for nid, label in cursor.fetchall()]
+            result["nodes_found"] = [{"id": nid, "label": label} for nid, label in cursor.fetchall()]
             
-            if not result["nodes"]:
-                return {"error": "Word not found"}
+            if not result["nodes_found"]:
+                return JSONResponse(
+                    status_code=404,
+                    content={"error": f"Word '{word}' (normalized: '{word_normalized}') not found in language '{lang}'."}
+                )
             
-            for rel_name, rel_url in RELATIONS:
+            # 2. Query all relations
+            for rel_name, rel_uri in RELATION_CHOICES:
                 outgoing = []
                 incoming = []
                 
+                # Outgoing (word -> relation -> target)
                 cursor.execute("""
                     SELECT en.label, e.weight, en.id
                     FROM edge e
@@ -109,11 +256,12 @@ def get_semantic_profile_json(word: str, lang: str = 'en', max_per_relation: int
                     WHERE e.start_id LIKE ? AND e.rel_id = ?
                     ORDER BY e.weight DESC
                     LIMIT ?
-                """, (like_path, rel_url, max_per_relation))
+                """, (like_path, rel_uri, limit))
                 
-                outgoing = [{"target": label, "weight": weight, "target_id": eid} 
+                outgoing = [{"target_label": label, "weight": weight, "target_id": eid} 
                            for label, weight, eid in cursor.fetchall()]
                 
+                # Incoming (source -> relation -> word)
                 cursor.execute("""
                     SELECT s.label, e.weight, s.id
                     FROM edge e
@@ -121,35 +269,122 @@ def get_semantic_profile_json(word: str, lang: str = 'en', max_per_relation: int
                     WHERE e.end_id LIKE ? AND e.rel_id = ?
                     ORDER BY e.weight DESC
                     LIMIT ?
-                """, (like_path, rel_url, max_per_relation))
+                """, (like_path, rel_uri, limit))
                 
-                incoming = [{"source": label, "weight": weight, "source_id": sid} 
+                incoming = [{"source_label": label, "weight": weight, "source_id": sid} 
                            for label, weight, sid in cursor.fetchall()]
                 
                 if outgoing or incoming:
                     result["relations"][rel_name] = {
+                        "uri": rel_uri,
                         "outgoing": outgoing,
                         "incoming": incoming,
                         "count": len(outgoing) + len(incoming)
                     }
-                    result["total_edges"] += len(outgoing) + len(incoming)
+                    result["total_edges_found"] += len(outgoing) + len(incoming)
             
-            return result
+            return JSONResponse(content=result)
             
     except Exception as e:
-        return {"error": str(e)}
+        log_progress(f"API /profile error: {e}", "ERROR")
+        traceback.print_exc()
+        return JSONResponse(status_code=500, content={"error": str(e)})
 
-def get_semantic_profile(word, lang='en', progress=gr.Progress()):
-    """Get semantic profile with progress"""
-    log_progress(f"Profile: {word} ({lang})", "INFO")
+@app.get("/api/query", tags=["API"])
+def query_edges_json(
+    start_node: Optional[str] = None, 
+    relation_uri: Optional[str] = None,
+    end_node: Optional[str] = None,
+    lang: str = 'en',
+    limit: int = 50
+):
+    """
+    API Endpoint: Query edges with flexible filters.
+    Nodes (start/end) can be partial words (e.g., 'dog') or full URIs.
+    """
+    query = """
+        SELECT
+            e.id as edge_id,
+            s.id as start_id,
+            r.id as relation_id,
+            en.id as end_id,
+            e.weight,
+            s.label as start_label,
+            r.label as relation_label,
+            en.label as end_label
+        FROM edge e
+        JOIN relation r ON e.rel_id = r.id
+        JOIN node s ON e.start_id = s.id
+        JOIN node en ON e.end_id = en.id
+        WHERE 1=1
+    """
+    params: List[Any] = []
+    
+    try:
+        def build_node_pattern(node_str: str) -> str:
+            if node_str.startswith(f'{CONCEPTNET_BASE_URI}/c/'):
+                return f"{node_str}%"
+            # Assume it's a plain word
+            return f"{CONCEPTNET_BASE_URI}/c/{lang}/{node_str.strip().lower().replace(' ', '_')}%"
+
+        with get_db_connection() as conn:
+            if start_node:
+                query += " AND s.id LIKE ?"
+                params.append(build_node_pattern(start_node))
+            
+            if relation_uri:
+                # Expecting a full URI like /r/IsA
+                query += " AND r.id = ?"
+                params.append(relation_uri)
+            
+            if end_node:
+                query += " AND en.id LIKE ?"
+                params.append(build_node_pattern(end_node))
+            
+            query += " ORDER BY e.weight DESC LIMIT ?"
+            params.append(limit)
+            
+            df = pd.read_sql_query(query, conn, params=params)
+            
+            return {
+                "query": {"start_node": start_node, "relation_uri": relation_uri, "end_node": end_node, "lang": lang, "limit": limit},
+                "results": df.to_dict(orient='records'),
+                "count": len(df)
+            }
+            
+    except Exception as e:
+        log_progress(f"API /query error: {e}", "ERROR")
+        traceback.print_exc()
+        return JSONResponse(status_code=500, content={"error": str(e)})
+
+@app.get("/api/relations", tags=["API"])
+def api_relations():
+    """API Endpoint: List all configured relations."""
+    return JSONResponse(content={"relations": CONCEPTNET_RELATIONS})
+
+@app.get("/api/languages", tags=["API"])
+def api_languages():
+    """API Endpoint: List all configured languages."""
+    return JSONResponse(content={"languages": TARGET_LANGUAGES})
+
+# ============================================================================
+# 5. GRADIO UI HELPER FUNCTIONS
+# (These functions are called by Gradio button clicks and return UI components)
+# ============================================================================
+
+def get_semantic_profile_ui(word: str, lang: str, progress=gr.Progress()):
+    """
+    Gradio UI Function: Get semantic profile formatted as Markdown.
+    """
+    log_progress(f"UI Profile: {word} ({lang})", "INFO")
     
     if not word or lang not in TARGET_LANGUAGES:
-        return "⚠️ Invalid input"
+        return "⚠️ Invalid input. Please provide a word and select a language."
     
     progress(0, desc="🔍 Starting...")
     
-    word = word.strip().lower().replace(' ', '_')
-    like_path = f"{CONCEPTNET_BASE}/c/{lang}/{word}%"
+    word_normalized = word.strip().lower().replace(' ', '_')
+    like_path = f"{CONCEPTNET_BASE_URI}/c/{lang}/{word_normalized}%"
     
     output_md = f"# 🧠 Semantic Profile: '{word}' ({lang.upper()})\n\n"
     
@@ -163,24 +398,22 @@ def get_semantic_profile(word, lang='en', progress=gr.Progress()):
             nodes = cursor.fetchall()
             
             if not nodes:
-                return f"# 🧠 '{word}'\n\n⚠️ Not found"
+                return f"# 🧠 '{word}'\n\n⚠️ **Word not found** (as `.../c/{lang}/{word_normalized}...`)"
             
             log_progress(f"Found {len(nodes)} nodes", "SUCCESS")
             
+            output_md += "**Matching Nodes:**\n"
             for node_id, label in nodes[:3]:
-                output_md += f"**Node:** `{node_id}` → **{label}**\n"
-            output_md += "\n"
+                output_md += f"- **{label}** (ID: `{node_id}`)\n"
+            output_md += "\n---\n"
             
-            total = 0
-            num_relations = len(RELATIONS)
+            total_found = 0
+            num_relations = len(RELATION_CHOICES)
             
-            for i, (rel_name, rel_url) in enumerate(RELATIONS):
+            # Use the FULL list of relations
+            for i, (rel_name, rel_uri) in enumerate(RELATION_CHOICES):
                 progress((i + 0.1) / num_relations, desc=f"🔎 {rel_name}...")
                 
-                output_md += f"## {rel_name}\n\n"
-                found = False
-                
-                start_time = time.time()
                 cursor.execute("""
                     SELECT en.label, e.weight
                     FROM edge e
@@ -188,17 +421,8 @@ def get_semantic_profile(word, lang='en', progress=gr.Progress()):
                     WHERE e.start_id LIKE ? AND e.rel_id = ?
                     ORDER BY e.weight DESC
                     LIMIT 10
-                """, (like_path, rel_url))
-                
-                results = cursor.fetchall()
-                elapsed = time.time() - start_time
-                
-                log_progress(f"  {rel_name} out: {len(results)} in {elapsed:.3f}s", "DEBUG")
-                
-                for label, weight in results:
-                    output_md += f"- **{word}** {rel_name} → *{label}* `[{weight:.3f}]`\n"
-                    found = True
-                    total += 1
+                """, (like_path, rel_uri))
+                outgoing = cursor.fetchall()
                 
                 cursor.execute("""
                     SELECT s.label, e.weight
@@ -207,149 +431,87 @@ def get_semantic_profile(word, lang='en', progress=gr.Progress()):
                     WHERE e.end_id LIKE ? AND e.rel_id = ?
                     ORDER BY e.weight DESC
                     LIMIT 10
-                """, (like_path, rel_url))
-                
-                results = cursor.fetchall()
-                
-                for label, weight in results:
-                    output_md += f"- *{label}* {rel_name} → **{word}** `[{weight:.3f}]`\n"
-                    found = True
-                    total += 1
-                
-                if not found:
-                    output_md += "*No results*\n"
+                """, (like_path, rel_uri))
+                incoming = cursor.fetchall()
+
+                if outgoing or incoming:
+                    output_md += f"### {rel_name} (`{rel_uri}`)\n\n"
+                    total_found += len(outgoing) + len(incoming)
+                    
+                    for label, weight in outgoing:
+                        output_md += f"- **{word}** → *{label}* `[{weight:.3f}]`\n"
+                    
+                    for label, weight in incoming:
+                        output_md += f"- *{label}* → **{word}** `[{weight:.3f}]`\n"
+                    
+                    output_md += "\n"
                 
-                output_md += "\n"
                 progress((i + 1) / num_relations, desc=f"✓ {rel_name}")
             
             progress(1.0, desc="✅ Complete!")
             
-            output_md += f"---\n**Total relations:** {total}\n"
-            log_progress(f"Complete: {total} relations", "SUCCESS")
+            output_md += f"---\n**Total relations found:** {total_found}\n"
+            log_progress(f"Complete: {total_found} relations", "SUCCESS")
             
             return output_md
             
     except Exception as e:
-        log_progress(f"Error: {e}", "ERROR")
-        import traceback
+        log_progress(f"UI Profile Error: {e}", "ERROR")
         traceback.print_exc()
-        return f"**❌ Error:** {e}"
+        return f"**❌ An unexpected error occurred:**\n\n```\n{e}\n```"
 
-def query_edges_json(start_node: Optional[str] = None, 
-                    relation: Optional[str] = None,
-                    end_node: Optional[str] = None,
-                    limit: int = 50):
-    """Query edges JSON"""
-    query = """
-        SELECT
-            e.id, s.id, r.label, en.id, e.weight, s.label, en.label
-        FROM edge e
-        JOIN relation r ON e.rel_id = r.id
-        JOIN node s ON e.start_id = s.id
-        JOIN node en ON e.end_id = en.id
-        WHERE 1=1
+def run_query_ui(start_node: str, relation_uri: str, end_node: str, lang: str, limit: int, progress=gr.Progress()):
     """
+    Gradio UI Function: Query builder.
+    """
+    log_progress(f"UI Query: start={start_node}, rel={relation_uri}, end={end_node}, lang={lang}", "INFO")
     
-    params = []
-    
-    try:
-        with get_db_connection() as conn:
-            if start_node:
-                if start_node.startswith('http://'):
-                    pattern = f"{start_node}%"
-                else:
-                    pattern = f"{CONCEPTNET_BASE}/c/en/{start_node}%"
-                query += " AND s.id LIKE ?"
-                params.append(pattern)
-            
-            if relation:
-                if relation.startswith('http://'):
-                    rel_value = relation
-                elif relation.startswith('/r/'):
-                    rel_value = f"{CONCEPTNET_BASE}{relation}"
-                else:
-                    rel_value = f"{CONCEPTNET_BASE}/r/{relation}"
-                query += " AND r.id = ?"
-                params.append(rel_value)
-            
-            if end_node:
-                if end_node.startswith('http://'):
-                    pattern = f"{end_node}%"
-                else:
-                    pattern = f"{CONCEPTNET_BASE}/c/en/{end_node}%"
-                query += " AND en.id LIKE ?"
-                params.append(pattern)
-            
-            query += " ORDER BY e.weight DESC LIMIT ?"
-            params.append(limit)
-            
-            df = pd.read_sql_query(query, conn, params=params)
-            
-            if df.empty:
-                return {"results": [], "count": 0}
-            
-            df.columns = ['edge_id', 'start_id', 'relation', 'end_id', 'weight', 'start_label', 'end_label']
-            
-            return {
-                "results": df.to_dict(orient='records'),
-                "count": len(df)
-            }
-            
-    except Exception as e:
-        return {"error": str(e)}
-
-def run_query(start_node, relation, end_node, limit, progress=gr.Progress()):
-    """Query builder"""
-    log_progress(f"Query: start={start_node}, rel={relation}, end={end_node}", "INFO")
-    
-    progress(0, desc="🔍 Building...")
+    progress(0, desc="🔍 Building query...")
     
     query = """
         SELECT
-            e.id, s.id, r.label, en.id, e.weight, s.label, en.label
+            s.label as start_label,
+            r.label as relation_label,
+            en.label as end_label,
+            e.weight,
+            s.id as start_id,
+            r.id as relation_id,
+            en.id as end_id,
+            e.id as edge_id
         FROM edge e
         JOIN relation r ON e.rel_id = r.id
         JOIN node s ON e.start_id = s.id
         JOIN node en ON e.end_id = en.id
         WHERE 1=1
     """
-    
-    params = []
+    params: List[Any] = []
     
     try:
+        def build_node_pattern(node_str: str) -> str:
+            if node_str.strip().startswith(f'{CONCEPTNET_BASE_URI}/c/'):
+                return f"{node_str.strip()}%"
+            # Assume it's a plain word
+            return f"{CONCEPTNET_BASE_URI}/c/{lang}/{node_str.strip().lower().replace(' ', '_')}%"
+
         with get_db_connection() as conn:
-            progress(0.3, desc="📝 Filters...")
+            progress(0.3, desc="📝 Applying filters...")
             
             if start_node and start_node.strip():
-                if start_node.startswith('http://'):
-                    pattern = f"{start_node}%"
-                else:
-                    pattern = f"{CONCEPTNET_BASE}/c/en/{start_node}%"
                 query += " AND s.id LIKE ?"
-                params.append(pattern)
-            
-            if relation and relation.strip():
-                if relation.startswith('http://'):
-                    rel_value = relation
-                elif relation.startswith('/r/'):
-                    rel_value = f"{CONCEPTNET_BASE}{relation}"
-                else:
-                    rel_value = f"{CONCEPTNET_BASE}/r/{relation}"
+                params.append(build_node_pattern(start_node))
+            
+            if relation_uri and relation_uri.strip():
                 query += " AND r.id = ?"
-                params.append(rel_value)
+                params.append(relation_uri)
             
             if end_node and end_node.strip():
-                if end_node.startswith('http://'):
-                    pattern = f"{end_node}%"
-                else:
-                    pattern = f"{CONCEPTNET_BASE}/c/en/{end_node}%"
                 query += " AND en.id LIKE ?"
-                params.append(pattern)
+                params.append(build_node_pattern(end_node))
             
             query += " ORDER BY e.weight DESC LIMIT ?"
             params.append(limit)
             
-            progress(0.6, desc="⚡ Running...")
+            progress(0.6, desc="⚡ Running query...")
             
             start_time = time.time()
             df = pd.read_sql_query(query, conn, params=params)
@@ -357,23 +519,31 @@ def run_query(start_node, relation, end_node, limit, progress=gr.Progress()):
             
             progress(1.0, desc="✅ Done!")
             
-            log_progress(f"Done: {len(df)} rows in {elapsed:.2f}s", "SUCCESS")
+            log_progress(f"Query Done: {len(df)} rows in {elapsed:.2f}s", "SUCCESS")
             
             if df.empty:
-                return pd.DataFrame(), f"⚠️ No results ({elapsed:.2f}s)"
+                return pd.DataFrame(), f"⚠️ No results found ({elapsed:.2f}s)"
+            
+            # Reorder columns for better display
+            cols_to_show = [
+                'start_label', 'relation_label', 'end_label', 'weight',
+                'start_id', 'relation_id', 'end_id'
+            ]
+            df = df[cols_to_show]
             
-            df.columns = ['edge_id', 'start_id', 'relation', 'end_id', 'weight', 'start_label', 'end_label']
             return df, f"✅ {len(df)} results in {elapsed:.2f}s"
             
     except Exception as e:
-        log_progress(f"Error: {e}", "ERROR")
-        import traceback
+        log_progress(f"UI Query Error: {e}", "ERROR")
         traceback.print_exc()
-        return pd.DataFrame(), f"❌ {e}"
+        return pd.DataFrame(), f"❌ **Error:**\n\n```\n{e}\n```"
 
-def run_raw_query(sql_query):
+def run_raw_query_ui(sql_query: str):
+    """
+    Gradio UI Function: Raw SQL query.
+    """
     if not sql_query.strip().upper().startswith("SELECT"):
-        return pd.DataFrame(), "❌ Only SELECT"
+        return pd.DataFrame(), "❌ **Error:** Only `SELECT` statements are allowed."
     try:
         with get_db_connection() as conn:
             start = time.time()
@@ -381,161 +551,227 @@ def run_raw_query(sql_query):
             elapsed = time.time() - start
             return df, f"✅ {len(df)} rows in {elapsed:.3f}s"
     except Exception as e:
-        return pd.DataFrame(), f"❌ {e}"
+        return pd.DataFrame(), f"❌ **Error:**\n\n```\n{e}\n```"
 
-def get_schema_info():
-    md = f"# 📚 Schema\n\n"
-    md += f"**Repo:** [{INDEXED_REPO_ID}](https://huggingface.co/datasets/{INDEXED_REPO_ID})\n\n"
+def get_schema_info_ui():
+    """
+    Gradio UI Function: Display schema information.
+    """
+    md = f"# 📚 Database Schema\n\n"
+    md += f"**Repo:** [{INDEXED_REPO_ID}](https://huggingface.co/datasets/{INDEXED_REPO_ID})\n"
+    md += f"**Database File:** `{DB_PATH}`\n\n"
     
     try:
         with get_db_connection() as conn:
             cursor = conn.cursor()
             
-            md += "## Relations\n\n"
-            cursor.execute("SELECT id, label FROM relation ORDER BY label LIMIT 20")
-            for rel_id, label in cursor.fetchall():
-                md += f"- **{label}:** `{rel_id}`\n"
-            
-            md += "\n## Tables\n\n"
+            md += "## Tables & Row Counts\n\n"
             cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
-            for table, in cursor.fetchall():
+            tables = [row[0] for row in cursor.fetchall()]
+            
+            for table in tables:
                 cursor.execute(f"SELECT COUNT(*) FROM {table}")
-                md += f"- **{table}:** {cursor.fetchone()[0]:,} rows\n"
+                count = cursor.fetchone()[0]
+                md += f"- **{table}:** {count:,} rows\n"
+
+            md += "\n## Configured Relations\n\n"
+            md += "This list is used to populate the 'Query Builder' dropdown and 'Semantic Profile'.\n\n"
+            for name, uri in RELATION_CHOICES:
+                 md += f"- **{name}:** `{uri}`\n"
     
     except Exception as e:
-        md += f"\nError: {e}\n"
+        md += f"\n**❌ Error loading schema:**\n\n```\n{e}\n```\n"
     
     return md
 
-# ===== FASTAPI - Create app FIRST =====
-app = FastAPI(title="ConceptNet API", version="1.0")
-
-@app.get("/api")
-def api_docs():
-    """API documentation - accessible at /api"""
-    return {
-        "name": "ConceptNet API",
-        "version": "1.0",
-        "endpoints": {
-            "/api/profile/{word}": "Semantic profile (params: lang, limit)",
-            "/api/query": "Query edges (params: start, relation, end, limit)",
-            "/api/relations": "List relations",
-            "/api/languages": "List languages"
-        },
-        "examples": {
-            "profile": "/api/profile/dog?lang=en&limit=10",
-            "query": "/api/query?start=dog&relation=IsA&limit=20"
-        },
-        "note": "Visit root (/) for the Gradio UI"
-    }
-
-@app.get("/api/profile/{word}")
-def api_profile(word: str, lang: str = "en", limit: int = 10):
-    """Get semantic profile"""
-    return JSONResponse(get_semantic_profile_json(word, lang, limit))
-
-@app.get("/api/query")
-def api_query(start: Optional[str] = None, 
-              relation: Optional[str] = None,
-              end: Optional[str] = None,
-              limit: int = 50):
-    """Query edges"""
-    return JSONResponse(query_edges_json(start, relation, end, limit))
+# ============================================================================
+# 6. GRADIO UI DEFINITION
+# ============================================================================
 
-@app.get("/api/relations")
-def api_relations():
-    """List relations"""
-    return JSONResponse({"relations": [{"name": name, "url": url} for name, url in RELATIONS]})
-
-@app.get("/api/languages")
-def api_languages():
-    """List languages"""
-    return JSONResponse({"languages": TARGET_LANGUAGES})
-
-# ===== GRADIO UI =====
-with gr.Blocks(title="ConceptNet Explorer", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🧠 ConceptNet Explorer")
-    gr.Markdown(
-        f"**Multi-language semantic network** | "
-        f"**Languages:** {', '.join([l.upper() for l in TARGET_LANGUAGES])} | "
-        f"**API:** `/api/profile/{{word}}` `/api/query`"
-    )
+def create_gradio_ui():
+    """Builds the consolidated Gradio interface."""
     
-    with gr.Tabs():
-        with gr.TabItem("🔍 Semantic Profile"):
-            gr.Markdown("**Explore semantic relations for any word**")
-            
-            with gr.Row():
-                word_input = gr.Textbox(label="Word", placeholder="dog", value="dog")
-                lang_input = gr.Dropdown(choices=TARGET_LANGUAGES, value="en", label="Language")
-            
-            semantic_btn = gr.Button("🔍 Get Semantic Profile", variant="primary", size="lg")
-            semantic_output = gr.Markdown()
-            
-            gr.Examples(
-                examples=[["dog", "en"], ["hund", "de"], ["perro", "es"], ["chien", "fr"]],
-                inputs=[word_input, lang_input]
-            )
+    with gr.Blocks(title="ConceptNet Explorer", theme=gr.themes.Soft(primary_hue="blue")) as demo:
+        gr.Markdown(
+            "# 🧠 ConceptNet Explorer\n"
+            "An interface for querying the ConceptNet semantic network."
+        )
+        gr.Markdown(
+            f"**Languages:** {', '.join([l.upper() for l in TARGET_LANGUAGES])} | "
+            f"**Database:** `{INDEXED_REPO_ID}` | "
+            f"**JSON API:** Access at `/api`"
+        )
         
-        with gr.TabItem("⚡ Query Builder"):
-            with gr.Row():
-                start_input = gr.Textbox(label="Start", placeholder="dog")
-                rel_input = gr.Textbox(label="Relation", placeholder="IsA", value="IsA")
-                end_input = gr.Textbox(label="End", placeholder="")
-            
-            limit_slider = gr.Slider(label="Limit", minimum=1, maximum=200, value=50)
-            query_btn = gr.Button("▶️ Run Query", variant="primary", size="lg")
+        with gr.Tabs():
+            with gr.TabItem("🔍 Semantic Profile"):
+                gr.Markdown("Explore all semantic relations for a single word. This queries all 34 relation types.")
+                
+                with gr.Row():
+                    profile_word_input = gr.Textbox(label="Word", placeholder="e.g., dog", value="dog")
+                    profile_lang_input = gr.Dropdown(choices=TARGET_LANGUAGES, value="en", label="Language")
+                
+                profile_btn = gr.Button("🔍 Get Semantic Profile", variant="primary")
+                profile_output = gr.Markdown(label="Profile Results")
+                
+                gr.Examples(
+                    examples=[["dog", "en"], ["Hund", "de"], ["perro", "es"], ["chien", "fr"], ["gatto", "it"]],
+                    inputs=[profile_word_input, profile_lang_input]
+                )
             
-            status_output = gr.Markdown()
-            results_output = gr.DataFrame(wrap=True)
+            with gr.TabItem("⚡ Query Builder"):
+                gr.Markdown("Construct a specific query using nodes and a relation.")
+                
+                with gr.Row():
+                    query_lang_input = gr.Dropdown(choices=TARGET_LANGUAGES, value="en", label="Node Language")
+                    query_limit_slider = gr.Slider(label="Result Limit", minimum=1, maximum=500, value=50, step=10)
+
+                with gr.Row():
+                    query_start_input = gr.Textbox(
+                        label="Start Node",
+                        placeholder="e.g., dog (word) or /c/en/dog (URI)"
+                    )
+                    
+                    # --- THIS IS THE KEY UI IMPROVEMENT ---
+                    query_rel_input = gr.Dropdown(
+                        label="Relation",
+                        choices=RELATION_CHOICES, # Use the full list
+                        value="/r/IsA" # Default to a common one
+                    )
+                    
+                    query_end_input = gr.Textbox(
+                        label="End Node",
+                        placeholder="e.g., animal (word) or /c/en/animal (URI)"
+                    )
+                
+                query_btn = gr.Button("▶️ Run Query", variant="primary")
+                
+                query_status_output = gr.Markdown()
+                query_results_output = gr.DataFrame(
+                    label="Query Results",
+                    wrap=True,
+                    interactive=False
+                )
+            
+            with gr.TabItem("💻 Raw SQL"):
+                gr.Markdown(
+                    "**Warning:** Directly query the SQLite database. Only `SELECT` statements are allowed. "
+                    "Use the 'Schema' tab to see table names."
+                )
+                raw_sql_input = gr.Textbox(
+                    label="SQL Query",
+                    value=f"SELECT s.label, r.label, en.label, e.weight\nFROM edge e\nJOIN relation r ON e.rel_id = r.id\nJOIN node s ON e.start_id = s.id\nJOIN node en ON e.end_id = en.id\nWHERE s.id LIKE '{CONCEPTNET_BASE_URI}/c/en/dog%'\n  AND r.id = '/r/IsA'\nORDER BY e.weight DESC\nLIMIT 10",
+                    lines=5,
+                    max_lines=20
+                )
+                raw_btn = gr.Button("▶️ Execute SQL")
+                raw_status = gr.Markdown()
+                raw_results = gr.DataFrame(label="SQL Results", interactive=False)
+            
+            with gr.TabItem("📊 Schema"):
+                gr.Markdown("View the database schema and table counts.")
+                schema_btn = gr.Button("📊 Load Schema Info")
+                schema_output = gr.Markdown()
+            
+            with gr.TabItem("🔌 API Docs"):
+                gr.Markdown(
+                    "## JSON API Endpoints\n"
+                    "This Gradio app is mounted on a FastAPI server. You can use the following JSON API endpoints directly."
+                )
+                gr.JSON({
+                    "docs": "/api",
+                    "profile": "/api/profile/{word}?lang=en&limit=10",
+                    "query": "/api/query?start_node=dog&relation_uri=/r/IsA&lang=en&limit=50",
+                    "relations": "/api/relations",
+                    "languages": "/api/languages"
+                }, label="API Endpoints")
+                gr.Markdown(
+                    "### Example (cURL)\n"
+                    "```bash\n# (Assumes app is running at localhost:7860)\ncurl http://localhost:7860/api/profile/dog?lang=en\n```\n"
+                    "```bash\ncurl 'http://localhost:7860/api/query?start_node=dog&relation_uri=/r/IsA&limit=10'\n```"
+                )
+
+        # --- Link UI components to functions ---
+        profile_btn.click(
+            fn=get_semantic_profile_ui,
+            inputs=[profile_word_input, profile_lang_input],
+            outputs=[profile_output],
+            api_name="get_semantic_profile" # Gradio-native API
+        )
         
-        with gr.TabItem("💻 Raw SQL"):
-            raw_sql_input = gr.Textbox(
-                label="SQL",
-                value=f"SELECT e.*, r.label FROM edge e JOIN relation r ON e.rel_id = r.id WHERE e.start_id = '{CONCEPTNET_BASE}/c/en/dog' LIMIT 10",
-                lines=3
-            )
-            raw_btn = gr.Button("▶️ Execute")
-            raw_status = gr.Markdown()
-            raw_results = gr.DataFrame()
+        query_btn.click(
+            fn=run_query_ui,
+            inputs=[query_start_input, query_rel_input, query_end_input, query_lang_input, query_limit_slider],
+            outputs=[query_results_output, query_status_output],
+            api_name="run_query" # Gradio-native API
+        )
         
-        with gr.TabItem("📊 Schema"):
-            schema_btn = gr.Button("📊 Load Schema")
-            schema_output = gr.Markdown()
+        raw_btn.click(
+            fn=run_raw_query_ui,
+            inputs=[raw_sql_input],
+            outputs=[raw_results, raw_status]
+        )
         
-        with gr.TabItem("🔌 API"):
-            gr.Markdown("## JSON API Endpoints\n")
-            gr.Markdown("### API Documentation\n```\nGET /api\n```")
-            gr.Markdown("### Get Semantic Profile\n```\nGET /api/profile/{word}?lang=en&limit=10\n```")
-            gr.Markdown("### Query Edges\n```\nGET /api/query?start=dog&relation=IsA&limit=50\n```")
-            gr.Markdown("### List Relations\n```\nGET /api/relations\n```")
-            gr.Markdown("### Examples\n")
-            gr.Markdown("```\ncurl https://your-space.hf.space/api/profile/dog?lang=en\n```")
-            gr.Markdown("```\ncurl 'https://your-space.hf.space/api/query?start=dog&relation=IsA&limit=10'\n```")
-    
-    gr.Markdown(
-        "---\n"
-        "**Performance:** Exact match on rel_id for fast queries | "
-        "**API:** Full REST API at `/api/*` endpoints"
-    )
-    
-    semantic_btn.click(get_semantic_profile, [word_input, lang_input], semantic_output)
-    query_btn.click(run_query, [start_input, rel_input, end_input, limit_slider], [results_output, status_output])
-    raw_btn.click(run_raw_query, raw_sql_input, [raw_results, raw_status])
-    schema_btn.click(get_schema_info, None, schema_output)
+        # Use .load() to run this when the tab is first clicked
+        schema_output.load(
+            fn=get_schema_info_ui,
+            inputs=None,
+            outputs=[schema_output]
+        )
+        schema_btn.click(
+            fn=get_schema_info_ui,
+            inputs=None,
+            outputs=[schema_output]
+        )
+        
+        return demo
+
+# ============================================================================
+# 7. APP MOUNTING & LAUNCH
+# ============================================================================
 
-# ===== MOUNT GRADIO TO FASTAPI - Gradio at root, API at /api/* =====
+# --- 1. Setup the Database (Download from HF Hub) ---
+# This runs *before* the UI is created
+try:
+    if not setup_database():
+        print("\n" + "="*70)
+        print("❌ CRITICAL ERROR: Could not set up the database.")
+        print(f"   Please check your connection or manually download '{INDEXED_DB_FILENAME}'")
+        print(f"   from '{INDEXED_REPO_ID}' and place it in this directory.")
+        print("="*70 + "\n")
+        # We don't exit, Gradio will just show errors
+    else:
+        print(f"✅ Database is ready at: {DB_PATH}")
+except Exception as e:
+    print(f"❌ CRITICAL ERROR during database setup: {e}")
+    traceback.print_exc()
+
+
+# --- 2. Create the Gradio UI ---
+log_progress("Creating Gradio UI...", "INFO")
+demo = create_gradio_ui()
+
+# --- 3. Mount Gradio onto the FastAPI app ---
+# This combines FastAPI (at /api/*) and Gradio (at /)
+log_progress("Mounting Gradio UI onto FastAPI app...", "INFO")
 app = gr.mount_gradio_app(app, demo, path="/")
 
+
+# ============================================================================
+# 8. MAIN EXECUTION BLOCK
+# ============================================================================
+
 if __name__ == "__main__":
     log_progress("="*60, "SUCCESS")
-    log_progress("🚀 APP READY!", "SUCCESS")
+    log_progress("🚀 CONCEPTNET EXPLORER APP READY!", "SUCCESS")
     log_progress("="*60, "SUCCESS")
     log_progress("UI:  http://localhost:7860/", "INFO")
     log_progress("API: http://localhost:7860/api", "INFO")
     log_progress("     http://localhost:7860/api/profile/dog", "INFO")
-    log_progress("     http://localhost:7860/api/query?start=dog&relation=IsA", "INFO")
+    log_progress("     http://localhost:7860/api/query?start_node=dog&relation_uri=/r/IsA", "INFO")
     log_progress("="*60, "SUCCESS")
     
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860
+    )