fix

backend/api/demo.py

@@ -42,7 +42,7 @@ _DIFFICULTY_MAP = {
     "hard": "complex_queries",
 }
 from env.tasks import TASKS, get_task
-from env.sql_env import SQLAgentEnv, Action, get_env, BASE_SYSTEM_PROMPT, _clean_sql
+from env.sql_env import SQLAgentEnv, Action, get_env, BASE_SYSTEM_PROMPT, get_system_prompt, _clean_sql
 from rl.environment import get_bandit_state
 from rl.types import RepairAction, REPAIR_ACTION_NAMES, REPAIR_ACTION_BY_NAME
 from rl.error_classifier import classify_error, extract_offending_token
@@ -196,7 +196,7 @@ async def execute_query_stream(req: ExecuteQueryRequest):
         # Multi-turn conversation — grows with each failed attempt so the LLM
         # sees its own history and doesn't repeat the same mistake.
         conversation: list[dict] = [
-            {"role": "system", "content": BASE_SYSTEM_PROMPT},
+            {"role": "system", "content": get_system_prompt()},
             {"role": "user", "content": initial_user_msg},
         ]
 
@@ -222,14 +222,14 @@ async def execute_query_stream(req: ExecuteQueryRequest):
                 # Update system prompt with repair-specific guidance
                 conversation[0] = {
                     "role": "system",
-                    "content": BASE_SYSTEM_PROMPT + get_repair_system_suffix(repair_enum),
+                    "content": get_system_prompt() + get_repair_system_suffix(repair_enum),
                 }
             elif attempt > 1:
                 repair_enum = RepairAction.REWRITE_FULL
                 action = Action(repair_action="rewrite_full")
                 conversation[0] = {
                     "role": "system",
-                    "content": BASE_SYSTEM_PROMPT + get_repair_system_suffix(repair_enum),
+                    "content": get_system_prompt() + get_repair_system_suffix(repair_enum),
                 }
 
             # Stream SQL generation using the full conversation history
@@ -498,7 +498,7 @@ async def run_benchmark(req: BenchmarkRequest):
             ep = env._episode  # type: ignore[union-attr]
 
             gepa = get_gepa()
-            system_prompt = gepa.get_current_prompt()
+            system_prompt = gepa.get_current_prompt() or get_system_prompt()
             from env.sql_env import _make_client, _MODEL
 
             for attempt in range(1, max_attempts + 1):

backend/env/database.py

@@ -1,14 +1,8 @@
 """
-SQLite database setup and schema for the benchmark marketplace.
+Database abstraction supporting SQLite and PostgreSQL.
 
-Tables:
-  sellers   (id, name, email, country, rating)
-  users     (id, name, email, created_at, country)
-  products  (id, name, category, price, stock_quantity, seller_id)
-  orders    (id, user_id, product_id, quantity, total_price, status, created_at)
-  reviews   (id, user_id, product_id, rating, comment, created_at)
-
-~50 rows per table of realistic seed data.
+Active connection is set via connect_external_db(). Defaults to the built-in
+SQLite benchmark database.
 """
 
 from __future__ import annotations
@@ -21,23 +15,59 @@ from typing import Any
 _DATA_DIR = Path(os.environ.get("DATA_DIR", Path(__file__).parent.parent / "data"))
 DB_PATH = _DATA_DIR / "benchmark.db"
 
-# Active DB path — can be overridden via connect_external_db()
-_active_db_path: str = str(DB_PATH)
+# ─── Active-connection state ──────────────────────────────────────
+_active_dsn: str = str(DB_PATH)          # SQLite path OR postgres DSN
 _active_db_label: str = "benchmark (built-in)"
+_active_db_type: str = "sqlite"          # "sqlite" | "postgres"
+
+
+def _is_postgres(dsn: str) -> bool:
+    return dsn.startswith(("postgresql://", "postgres://"))
 
 
-def connect_external_db(path: str) -> tuple[bool, str]:
-    """Switch the active SQLite database. Returns (success, message)."""
-    global _active_db_path, _active_db_label
+def _pg_label(dsn: str) -> str:
+    """Extract a short display label from a postgres DSN."""
     try:
-        conn = sqlite3.connect(path)
-        tables = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
-        ).fetchall()
-        conn.close()
-        _active_db_path = path
-        _active_db_label = Path(path).name
-        return True, f"Connected to {Path(path).name} ({len(tables)} tables)"
+        # postgresql://user:pass@host:port/dbname → host/dbname
+        without_scheme = dsn.split("://", 1)[1]
+        at_split = without_scheme.rsplit("@", 1)
+        hostdb = at_split[-1]  # host:port/dbname
+        parts = hostdb.split("/", 1)
+        host = parts[0].split(":")[0]
+        dbname = parts[1] if len(parts) > 1 else "?"
+        return f"{host}/{dbname}"
+    except Exception:
+        return "postgres"
+
+
+def connect_external_db(dsn: str) -> tuple[bool, str]:
+    """Switch active database. Accepts a SQLite file path or a PostgreSQL DSN."""
+    global _active_dsn, _active_db_label, _active_db_type
+    try:
+        if _is_postgres(dsn):
+            import psycopg2  # type: ignore[import]
+            conn = psycopg2.connect(dsn)
+            cur = conn.cursor()
+            cur.execute(
+                "SELECT table_name FROM information_schema.tables "
+                "WHERE table_schema='public' AND table_type='BASE TABLE'"
+            )
+            tables = cur.fetchall()
+            conn.close()
+            _active_dsn = dsn
+            _active_db_label = _pg_label(dsn)
+            _active_db_type = "postgres"
+            return True, f"Connected to PostgreSQL: {_active_db_label} ({len(tables)} tables)"
+        else:
+            conn = sqlite3.connect(dsn)
+            tables = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+            ).fetchall()
+            conn.close()
+            _active_dsn = dsn
+            _active_db_label = Path(dsn).name if dsn != ":memory:" else "in-memory"
+            _active_db_type = "sqlite"
+            return True, f"Connected to {_active_db_label} ({len(tables)} tables)"
     except Exception as e:
         return False, str(e)
 
@@ -46,8 +76,9 @@ def get_active_db_label() -> str:
     return _active_db_label
 
 
-def _get_db_path() -> str:
-    return _active_db_path
+def get_active_db_type() -> str:
+    """Returns 'sqlite' or 'postgres'."""
+    return _active_db_type
 
 
 # ─── Schema ───────────────────────────────────────────────────────
@@ -333,10 +364,7 @@ def get_db_path() -> Path:
 
 
 def ensure_seeded() -> bool:
-    """
-    Create the database and populate seed data if not already done.
-    Returns True if seed was needed (first run), False if already seeded.
-    """
+    """Create the database and populate seed data if not already done."""
     _DATA_DIR.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(DB_PATH))
     try:
@@ -345,7 +373,7 @@ def ensure_seeded() -> bool:
 
         count = conn.execute("SELECT COUNT(*) FROM users").fetchone()[0]
         if count >= 50:
-            return False  # Already seeded
+            return False
 
         conn.execute("DELETE FROM reviews")
         conn.execute("DELETE FROM orders")
@@ -353,43 +381,29 @@ def ensure_seeded() -> bool:
         conn.execute("DELETE FROM users")
         conn.execute("DELETE FROM sellers")
 
-        conn.executemany(
-            "INSERT OR REPLACE INTO sellers VALUES (?,?,?,?,?)", _SELLERS
-        )
-        conn.executemany(
-            "INSERT OR REPLACE INTO users VALUES (?,?,?,?,?)", _USERS
-        )
-        conn.executemany(
-            "INSERT OR REPLACE INTO products VALUES (?,?,?,?,?,?)", _PRODUCTS
-        )
-        conn.executemany(
-            "INSERT OR REPLACE INTO orders VALUES (?,?,?,?,?,?,?)", _ORDERS
-        )
-        conn.executemany(
-            "INSERT OR REPLACE INTO reviews VALUES (?,?,?,?,?,?)", _REVIEWS
-        )
+        conn.executemany("INSERT OR REPLACE INTO sellers VALUES (?,?,?,?,?)", _SELLERS)
+        conn.executemany("INSERT OR REPLACE INTO users VALUES (?,?,?,?,?)", _USERS)
+        conn.executemany("INSERT OR REPLACE INTO products VALUES (?,?,?,?,?,?)", _PRODUCTS)
+        conn.executemany("INSERT OR REPLACE INTO orders VALUES (?,?,?,?,?,?,?)", _ORDERS)
+        conn.executemany("INSERT OR REPLACE INTO reviews VALUES (?,?,?,?,?,?)", _REVIEWS)
         conn.commit()
         return True
     finally:
         conn.close()
 
 
-def get_schema_info() -> str:
-    """
-    Return a concise textual schema summary for use in prompts.
-    """
-    conn = sqlite3.connect(_get_db_path())
+# ─── Schema info ──────────────────────────────────────────────────
+
+def _schema_info_sqlite() -> str:
+    conn = sqlite3.connect(_active_dsn)
     try:
         cur = conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
-        tables_in_db = [r[0] for r in cur.fetchall()]
-        # Fall back to all tables if schema is unknown
-        tables = tables_in_db if tables_in_db else ["sellers", "users", "products", "orders", "reviews"]
+        tables = [r[0] for r in cur.fetchall()] or ["sellers", "users", "products", "orders", "reviews"]
         lines = []
         for table in tables:
             info = conn.execute(f"PRAGMA table_info({table})").fetchall()
             cols = ", ".join(
-                f"{col[1]} {col[2]}{'(PK)' if col[5] else ''}"
-                for col in info
+                f"{col[1]} {col[2]}{'(PK)' if col[5] else ''}" for col in info
             )
             row_count = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
             lines.append(f"Table: {table} ({row_count} rows)\n  Columns: {cols}")
@@ -398,12 +412,59 @@ def get_schema_info() -> str:
         conn.close()
 
 
-def execute_query(sql: str) -> tuple[list[dict], str | None]:
-    """
-    Execute a SQL query and return (rows, error_message).
-    rows is a list of dicts; error_message is None on success.
-    """
-    conn = sqlite3.connect(_get_db_path())
+def _schema_info_postgres() -> str:
+    import psycopg2  # type: ignore[import]
+    conn = psycopg2.connect(_active_dsn)
+    try:
+        cur = conn.cursor()
+        cur.execute(
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema='public' AND table_type='BASE TABLE' ORDER BY table_name"
+        )
+        tables = [r[0] for r in cur.fetchall()]
+
+        # Primary keys per table
+        cur.execute(
+            "SELECT tc.table_name, kcu.column_name "
+            "FROM information_schema.table_constraints tc "
+            "JOIN information_schema.key_column_usage kcu "
+            "  ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema "
+            "WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = 'public'"
+        )
+        pks: dict[str, set[str]] = {}
+        for tbl, col in cur.fetchall():
+            pks.setdefault(tbl, set()).add(col)
+
+        lines = []
+        for table in tables:
+            cur.execute(
+                "SELECT column_name, data_type FROM information_schema.columns "
+                "WHERE table_name = %s AND table_schema = 'public' ORDER BY ordinal_position",
+                (table,),
+            )
+            cols_info = cur.fetchall()
+            cols = ", ".join(
+                f"{col} {dtype}{'(PK)' if col in pks.get(table, set()) else ''}"
+                for col, dtype in cols_info
+            )
+            cur.execute(f'SELECT COUNT(*) FROM "{table}"')
+            row_count = cur.fetchone()[0]
+            lines.append(f"Table: {table} ({row_count} rows)\n  Columns: {cols}")
+        return "\n\n".join(lines)
+    finally:
+        conn.close()
+
+
+def get_schema_info() -> str:
+    if _active_db_type == "postgres":
+        return _schema_info_postgres()
+    return _schema_info_sqlite()
+
+
+# ─── Execute query ────────────────────────────────────────────────
+
+def _execute_sqlite(sql: str) -> tuple[list[dict], str | None]:
+    conn = sqlite3.connect(_active_dsn)
     conn.row_factory = sqlite3.Row
     try:
         cursor = conn.execute(sql)
@@ -415,49 +476,156 @@ def execute_query(sql: str) -> tuple[list[dict], str | None]:
         conn.close()
 
 
-def get_table_stats() -> list[dict]:
-    """Return [{name, rows}, ...] for all tables."""
-    conn = sqlite3.connect(_get_db_path())
+def _execute_postgres(sql: str) -> tuple[list[dict], str | None]:
+    import psycopg2  # type: ignore[import]
+    import psycopg2.extras  # type: ignore[import]
+    conn = psycopg2.connect(_active_dsn)
+    try:
+        cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
+        cur.execute(sql)
+        if cur.description is not None:
+            rows = [dict(row) for row in cur.fetchall()]
+        else:
+            rows = []
+        conn.commit()
+        return rows, None
+    except psycopg2.Error as e:
+        return [], str(e).strip()
+    finally:
+        conn.close()
+
+
+def execute_query(sql: str) -> tuple[list[dict], str | None]:
+    """Execute a SQL query and return (rows, error_message)."""
+    if _active_db_type == "postgres":
+        return _execute_postgres(sql)
+    return _execute_sqlite(sql)
+
+
+# ─── Table stats ──────────────────────────────────────────────────
+
+def _table_stats_sqlite() -> list[dict]:
+    conn = sqlite3.connect(_active_dsn)
     try:
         cur = conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
         tables = [r[0] for r in cur.fetchall()] or ["sellers", "users", "products", "orders", "reviews"]
         return [
-            {
-                "name": t,
-                "rows": conn.execute(f"SELECT COUNT(*) FROM {t}").fetchone()[0],
-            }
+            {"name": t, "rows": conn.execute(f"SELECT COUNT(*) FROM {t}").fetchone()[0]}
             for t in tables
         ]
     finally:
         conn.close()
 
 
-def get_schema_graph() -> dict:
-    """Return schema graph with tables, columns, and foreign keys."""
-    conn = sqlite3.connect(str(DB_PATH))
+def _table_stats_postgres() -> list[dict]:
+    import psycopg2  # type: ignore[import]
+    conn = psycopg2.connect(_active_dsn)
+    try:
+        cur = conn.cursor()
+        cur.execute(
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema='public' AND table_type='BASE TABLE' ORDER BY table_name"
+        )
+        tables = [r[0] for r in cur.fetchall()]
+        result = []
+        for t in tables:
+            cur.execute(f'SELECT COUNT(*) FROM "{t}"')
+            result.append({"name": t, "rows": cur.fetchone()[0]})
+        return result
+    finally:
+        conn.close()
+
+
+def get_table_stats() -> list[dict]:
+    if _active_db_type == "postgres":
+        return _table_stats_postgres()
+    return _table_stats_sqlite()
+
+
+# ─── Schema graph ─────────────────────────────────────────────────
+
+def _schema_graph_sqlite() -> dict:
+    conn = sqlite3.connect(_active_dsn)
     try:
+        cur = conn.execute("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
+        table_names = [r[0] for r in cur.fetchall()]
         tables = []
-        for table in ["sellers", "users", "products", "orders", "reviews"]:
+        for table in table_names:
             info = conn.execute(f"PRAGMA table_info({table})").fetchall()
-            columns = [
-                {"name": col[1], "type": col[2], "pk": bool(col[5])}
-                for col in info
-            ]
+            columns = [{"name": col[1], "type": col[2], "pk": bool(col[5])} for col in info]
             tables.append({"name": table, "columns": columns})
 
         foreign_keys = []
-        for table in ["sellers", "users", "products", "orders", "reviews"]:
+        for table in table_names:
             fks = conn.execute(f"PRAGMA foreign_key_list({table})").fetchall()
             for fk in fks:
-                foreign_keys.append(
-                    {
-                        "from_table": table,
-                        "from_col": fk[3],
-                        "to_table": fk[2],
-                        "to_col": fk[4],
-                    }
-                )
+                foreign_keys.append({
+                    "from_table": table,
+                    "from_col": fk[3],
+                    "to_table": fk[2],
+                    "to_col": fk[4],
+                })
+        return {"tables": tables, "foreign_keys": foreign_keys}
+    finally:
+        conn.close()
+
+
+def _schema_graph_postgres() -> dict:
+    import psycopg2  # type: ignore[import]
+    conn = psycopg2.connect(_active_dsn)
+    try:
+        cur = conn.cursor()
+        cur.execute(
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema='public' AND table_type='BASE TABLE' ORDER BY table_name"
+        )
+        table_names = [r[0] for r in cur.fetchall()]
+
+        cur.execute(
+            "SELECT tc.table_name, kcu.column_name "
+            "FROM information_schema.table_constraints tc "
+            "JOIN information_schema.key_column_usage kcu "
+            "  ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema "
+            "WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = 'public'"
+        )
+        pks: dict[str, set[str]] = {}
+        for tbl, col in cur.fetchall():
+            pks.setdefault(tbl, set()).add(col)
+
+        tables = []
+        for table in table_names:
+            cur.execute(
+                "SELECT column_name, data_type FROM information_schema.columns "
+                "WHERE table_name = %s AND table_schema = 'public' ORDER BY ordinal_position",
+                (table,),
+            )
+            columns = [
+                {"name": col, "type": dtype, "pk": col in pks.get(table, set())}
+                for col, dtype in cur.fetchall()
+            ]
+            tables.append({"name": table, "columns": columns})
 
+        cur.execute(
+            "SELECT kcu.table_name, kcu.column_name, ccu.table_name, ccu.column_name "
+            "FROM information_schema.table_constraints tc "
+            "JOIN information_schema.key_column_usage kcu "
+            "  ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema "
+            "JOIN information_schema.referential_constraints rc "
+            "  ON tc.constraint_name = rc.constraint_name "
+            "JOIN information_schema.constraint_column_usage ccu "
+            "  ON ccu.constraint_name = rc.unique_constraint_name AND ccu.table_schema = tc.table_schema "
+            "WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = 'public'"
+        )
+        foreign_keys = [
+            {"from_table": r[0], "from_col": r[1], "to_table": r[2], "to_col": r[3]}
+            for r in cur.fetchall()
+        ]
         return {"tables": tables, "foreign_keys": foreign_keys}
     finally:
         conn.close()
+
+
+def get_schema_graph() -> dict:
+    if _active_db_type == "postgres":
+        return _schema_graph_postgres()
+    return _schema_graph_sqlite()

backend/env/sql_env.py

@@ -84,6 +84,22 @@ Rules:
 - Use SQLite syntax
 - Do not include semicolons at the end"""
 
+_POSTGRES_SYSTEM_PROMPT = """You are a SQL expert. Given a natural language question and a PostgreSQL database schema, write a correct SQL query.
+
+Rules:
+- Output ONLY the SQL query, nothing else
+- No markdown, no code fences, no explanation
+- Use PostgreSQL syntax
+- Do not include semicolons at the end"""
+
+
+def get_system_prompt() -> str:
+    """Return the system prompt appropriate for the currently active database dialect."""
+    from env.database import get_active_db_type
+    if get_active_db_type() == "postgres":
+        return _POSTGRES_SYSTEM_PROMPT
+    return BASE_SYSTEM_PROMPT
+
 
 def _clean_sql(raw: str) -> str:
     """Strip markdown code fences and extra whitespace."""

backend/requirements.txt

@@ -7,3 +7,4 @@ aiofiles>=24.0.0
 python-multipart>=0.0.9
 sse-starlette>=2.1.0
 aiosqlite>=0.20.0
+psycopg2-binary>=2.9.0

frontend/src/components/ConnectDB.tsx

@@ -8,23 +8,45 @@ interface ConnectDBProps {
   onClose: () => void
 }
 
-const EXAMPLES = [
+type DbType = 'sqlite' | 'postgres'
+
+const SQLITE_EXAMPLES = [
   { label: 'In-memory (blank)', value: ':memory:' },
   { label: 'Custom path', value: '/path/to/your/database.db' },
 ]
 
+const POSTGRES_EXAMPLES = [
+  { label: 'Local default', value: 'postgresql://postgres:password@localhost:5432/mydb' },
+  { label: 'With SSL', value: 'postgresql://user:pass@host:5432/dbname?sslmode=require' },
+]
+
 export function ConnectDB({ onClose }: ConnectDBProps) {
   const { dbLabel, setDbLabel, setTables, setDbSeeded } = useStore()
-  const [path, setPath] = useState('')
+  const [dbType, setDbType] = useState<DbType>('sqlite')
+  const [value, setValue] = useState('')
   const [status, setStatus] = useState<'idle' | 'connecting' | 'success' | 'error'>('idle')
   const [message, setMessage] = useState('')
 
+  const placeholder = dbType === 'postgres'
+    ? 'postgresql://user:password@host:5432/dbname'
+    : '/path/to/database.db'
+
+  const examples = dbType === 'postgres' ? POSTGRES_EXAMPLES : SQLITE_EXAMPLES
+
+  const getDsn = () => {
+    if (dbType === 'postgres' && value.trim() && !value.trim().startsWith('postgresql://') && !value.trim().startsWith('postgres://')) {
+      return `postgresql://${value.trim()}`
+    }
+    return value.trim()
+  }
+
   const handleConnect = async () => {
-    if (!path.trim()) return
+    const dsn = getDsn()
+    if (!dsn) return
     setStatus('connecting')
     setMessage('')
     try {
-      const res = await connectExternalDb(path.trim())
+      const res = await connectExternalDb(dsn)
       if (res.success) {
         setDbLabel(res.dbLabel)
         setTables(res.tables)
@@ -86,7 +108,7 @@ export function ConnectDB({ onClose }: ConnectDBProps) {
             </div>
             <div>
               <h2 className="text-sm font-semibold theme-text-primary">Connect Database</h2>
-              <p className="text-[10px] text-gray-500">SQLite file path</p>
+              <p className="text-[10px] text-gray-500">SQLite file or PostgreSQL connection string</p>
             </div>
           </div>
           <button onClick={onClose} className="p-1.5 rounded-lg hover:bg-white/5 text-gray-500 hover:text-gray-300 transition-colors">
@@ -111,16 +133,38 @@ export function ConnectDB({ onClose }: ConnectDBProps) {
 
         {/* Body */}
         <div className="px-5 py-4 flex flex-col gap-4">
+          {/* DB Type toggle */}
           <div>
             <label className="text-[10px] font-semibold text-gray-500 uppercase tracking-wider block mb-1.5">
-              SQLite File Path
+              Database Type
+            </label>
+            <div className="flex rounded-xl overflow-hidden border" style={{ borderColor: 'var(--border-color)' }}>
+              {(['sqlite', 'postgres'] as DbType[]).map((type) => (
+                <button
+                  key={type}
+                  onClick={() => { setDbType(type); setValue(''); setStatus('idle') }}
+                  className="flex-1 py-2 text-xs font-medium transition-all"
+                  style={{
+                    background: dbType === type ? 'linear-gradient(135deg,#7c3aed,#2563eb)' : 'var(--bg-tertiary)',
+                    color: dbType === type ? '#fff' : 'var(--text-secondary)',
+                  }}
+                >
+                  {type === 'sqlite' ? 'SQLite' : 'PostgreSQL'}
+                </button>
+              ))}
+            </div>
+          </div>
+
+          <div>
+            <label className="text-[10px] font-semibold text-gray-500 uppercase tracking-wider block mb-1.5">
+              {dbType === 'postgres' ? 'Connection String' : 'File Path'}
             </label>
             <input
-              type="text"
-              value={path}
-              onChange={(e) => { setPath(e.target.value); setStatus('idle') }}
+              type={dbType === 'postgres' ? 'text' : 'text'}
+              value={value}
+              onChange={(e) => { setValue(e.target.value); setStatus('idle') }}
               onKeyDown={(e) => e.key === 'Enter' && void handleConnect()}
-              placeholder="/path/to/database.db"
+              placeholder={placeholder}
               className="w-full px-3 py-2.5 text-sm rounded-xl border focus:outline-none transition-all font-mono"
               style={{
                 background: 'var(--bg-tertiary)',
@@ -129,16 +173,21 @@ export function ConnectDB({ onClose }: ConnectDBProps) {
               }}
               autoFocus
             />
+            {dbType === 'postgres' && (
+              <p className="text-[10px] text-gray-600 mt-1">
+                Format: <span className="font-mono text-gray-500">postgresql://user:password@host:port/dbname</span>
+              </p>
+            )}
           </div>
 
           {/* Quick examples */}
           <div className="flex flex-col gap-1.5">
             <span className="text-[10px] text-gray-600 uppercase tracking-wider">Quick select</span>
             <div className="flex flex-wrap gap-1.5">
-              {EXAMPLES.map((ex) => (
+              {examples.map((ex) => (
                 <button
                   key={ex.value}
-                  onClick={() => { setPath(ex.value); setStatus('idle') }}
+                  onClick={() => { setValue(ex.value); setStatus('idle') }}
                   className="text-[10px] px-2.5 py-1 rounded-full border transition-all text-gray-500 hover:text-gray-300"
                   style={{ borderColor: 'var(--border-color)', background: 'var(--bg-tertiary)' }}
                 >
@@ -173,7 +222,7 @@ export function ConnectDB({ onClose }: ConnectDBProps) {
           </button>
           <button
             onClick={() => void handleConnect()}
-            disabled={!path.trim() || status === 'connecting'}
+            disabled={!value.trim() || status === 'connecting'}
             className="flex items-center gap-1.5 px-4 py-2 rounded-xl text-xs font-semibold text-white transition-all active:scale-95 disabled:opacity-40 disabled:cursor-not-allowed"
             style={{ background: 'linear-gradient(135deg,#7c3aed,#2563eb)' }}
           >