Upload folder using huggingface_hub

mcp_database_universal/__init__.py

@@ -1,3 +1,3 @@
 """MCP Database Server — Reasoning interface for databases."""
 
-__version__ = "0.1.1"
+__version__ = "0.1.3"

mcp_database_universal/__main__.py

@@ -88,4 +88,7 @@ async def main():
 
 
 if __name__ == "__main__":
+    if sys.platform == "win32":
+        # psycopg async does not work with ProactorEventLoop (Windows default)
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
     asyncio.run(main())

mcp_database_universal/engines/base.py

@@ -1,5 +1,6 @@
 """Abstract base class for database engines."""
 
+import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 
@@ -79,10 +80,28 @@ class QueryResult:
     warning: str | None = None
 
 
+_NAMED_PARAM_RE = re.compile(r":([A-Za-z_][A-Za-z0-9_]*)")
+
+
+def _named_to_pyformat(sql: str) -> str:
+    """Convert :name named params (SQLite style) to %(name)s (DBAPI pyformat style).
+
+    Used by psycopg (PostgreSQL), pymysql (MySQL) and MSSQL drivers,
+    which do not understand the :name syntax.
+    """
+    return _NAMED_PARAM_RE.sub(r"%(\1)s", sql)
+
+
 class BaseEngine(ABC):
     @abstractmethod
     async def connect(self) -> None: ...
 
+    def _translate_params(self, sql: str, params: dict | None) -> tuple[str, dict | None]:
+        """Normalize :name params to the driver-native style when params are given."""
+        if params:
+            sql = _named_to_pyformat(sql)
+        return sql, params
+
     @abstractmethod
     async def disconnect(self) -> None: ...
 

mcp_database_universal/engines/mssql.py

@@ -134,6 +134,7 @@ class MSSQLEngine(BaseEngine):
         conn = self._ensure_conn()
         start = time.monotonic()
         try:
+            sql, params = self._translate_params(sql, params)
             cur = conn.cursor()
             if params:
                 cur.execute(sql, params)

mcp_database_universal/engines/mysql.py

@@ -4,6 +4,7 @@ import time
 from mcp_database_universal.engines.base import (
     BaseEngine, DBInfo, ColumnInfo, TableInfo, TableDetail,
     IndexInfo, ForeignKeyInfo, TableStats, QueryResult,
+    _named_to_pyformat,
 )
 
 
@@ -139,6 +140,7 @@ class MySQLEngine(BaseEngine):
         conn = self._ensure_conn()
         start = time.monotonic()
         try:
+            sql, params = self._translate_params(sql, params)
             with conn.cursor() as cur:
                 if params:
                     cur.execute(sql, params)
@@ -149,7 +151,7 @@ class MySQLEngine(BaseEngine):
                 elapsed = int((time.monotonic() - start) * 1000)
                 return QueryResult(
                     columns=columns,
-                    rows=rows,
+                    rows=list(rows),
                     row_count=len(rows),
                     truncated=False,
                     execution_time_ms=elapsed,

mcp_database_universal/engines/postgres.py

@@ -4,6 +4,7 @@ import time
 from mcp_database_universal.engines.base import (
     BaseEngine, DBInfo, ColumnInfo, TableInfo, TableDetail,
     IndexInfo, ForeignKeyInfo, TableStats, QueryResult,
+    _named_to_pyformat,
 )
 
 
@@ -54,12 +55,14 @@ class PostgresEngine(BaseEngine):
 
     async def get_db_info(self) -> DBInfo:
         conn = self._ensure_conn()
-        row = await conn.execute("SELECT version()").fetchone()
+        cur = await conn.execute("SELECT version()")
+        row = await cur.fetchone()
         version = row[0] if row else "unknown"
         try:
-            row2 = await conn.execute(
+            cur = await conn.execute(
                 "SELECT pg_size_pretty(pg_database_size(current_database()))"
-            ).fetchone()
+            )
+            row2 = await cur.fetchone()
             size = row2[0] if row2 else "unknown"
         except Exception:
             size = "unknown"
@@ -67,27 +70,30 @@ class PostgresEngine(BaseEngine):
 
     async def get_tables(self) -> list[TableInfo]:
         conn = self._ensure_conn()
-        rows = await conn.execute("""
+        cur = await conn.execute("""
             SELECT t.table_name
             FROM information_schema.tables t
             WHERE t.table_schema = 'public' AND t.table_type = 'BASE TABLE'
             ORDER BY t.table_name
-        """).fetchall()
+        """)
+        rows = await cur.fetchall()
 
         tables = []
         for row in rows:
             name = row[0]
             try:
-                cnt = await conn.execute(f'SELECT COUNT(*) FROM "{name}"').fetchone()
+                cur = await conn.execute(f'SELECT COUNT(*) FROM "{name}"')
+                cnt = await cur.fetchone()
                 row_count = cnt[0] if cnt else 0
             except Exception:
                 row_count = 0
 
             try:
-                cols = await conn.execute("""
+                cur = await conn.execute("""
                     SELECT COUNT(*) FROM information_schema.columns
                     WHERE table_schema = 'public' AND table_name = %s
-                """, [name]).fetchone()
+                """, [name])
+                cols = await cur.fetchone()
                 col_count = cols[0] if cols else 0
             except Exception:
                 col_count = 0
@@ -103,7 +109,7 @@ class PostgresEngine(BaseEngine):
     async def get_table_detail(self, table: str) -> TableDetail:
         conn = self._ensure_conn()
 
-        col_rows = await conn.execute("""
+        cur = await conn.execute("""
             SELECT c.column_name, c.data_type, c.is_nullable, c.column_default,
                    CASE WHEN pk.column_name IS NOT NULL THEN true ELSE false END as is_pk
             FROM information_schema.columns c
@@ -116,7 +122,8 @@ class PostgresEngine(BaseEngine):
             ) pk ON c.column_name = pk.column_name
             WHERE c.table_schema = 'public' AND c.table_name = %s
             ORDER BY c.ordinal_position
-        """, [table, table]).fetchall()
+        """, [table, table])
+        col_rows = await cur.fetchall()
 
         columns = []
         pk_name = None
@@ -132,7 +139,7 @@ class PostgresEngine(BaseEngine):
                 is_primary_key=is_pk,
             ))
 
-        fk_rows = await conn.execute("""
+        cur = await conn.execute("""
             SELECT
                 kcu.column_name,
                 ccu.table_name AS foreign_table_name,
@@ -143,7 +150,8 @@ class PostgresEngine(BaseEngine):
             JOIN information_schema.constraint_column_usage ccu
                 ON tc.constraint_name = ccu.constraint_name
             WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_name = %s
-        """, [table]).fetchall()
+        """, [table])
+        fk_rows = await cur.fetchall()
 
         foreign_keys = []
         fk_cols = set()
@@ -164,11 +172,12 @@ class PostgresEngine(BaseEngine):
                         col.foreign_key_column = fk.references_column
                         break
 
-        idx_rows = await conn.execute("""
+        cur = await conn.execute("""
             SELECT indexname, indexdef
             FROM pg_indexes
             WHERE tablename = %s AND schemaname = 'public'
-        """, [table]).fetchall()
+        """, [table])
+        idx_rows = await cur.fetchall()
 
         indexes = []
         for idx in idx_rows:
@@ -177,10 +186,11 @@ class PostgresEngine(BaseEngine):
             indexes.append(IndexInfo(name=name, columns=[], unique=unique))
 
         try:
-            sample = await conn.execute(f'SELECT * FROM "{table}" LIMIT 5').fetchall()
-            if sample:
-                cols_desc = sample[0].keys() if hasattr(sample[0], 'keys') else []
-                sample_data = [dict(row) for row in sample]
+            cur = await conn.execute(f'SELECT * FROM "{table}" LIMIT 5')
+            sample_rows = await cur.fetchall()
+            if sample_rows:
+                cols_d = [d.name for d in cur.description] if cur.description else []
+                sample_data = [dict(zip(cols_d, row)) for row in sample_rows]
             else:
                 sample_data = []
         except Exception:
@@ -202,6 +212,7 @@ class PostgresEngine(BaseEngine):
         conn = self._ensure_conn()
         start = time.monotonic()
         try:
+            sql, params = self._translate_params(sql, params)
             if params:
                 cur = await conn.execute(sql, params)
             else:
@@ -209,7 +220,7 @@ class PostgresEngine(BaseEngine):
             rows = await cur.fetchall()
             columns = [desc.name for desc in cur.description] if cur.description else []
             elapsed = int((time.monotonic() - start) * 1000)
-            result_rows = [dict(row) for row in rows]
+            result_rows = [dict(zip(columns, row)) for row in rows]
             return QueryResult(
                 columns=columns,
                 rows=result_rows,
@@ -232,15 +243,17 @@ class PostgresEngine(BaseEngine):
     async def get_table_stats(self, table: str) -> TableStats:
         conn = self._ensure_conn()
         try:
-            row = await conn.execute(f'SELECT COUNT(*) FROM "{table}"').fetchone()
+            cur = await conn.execute(f'SELECT COUNT(*) FROM "{table}"')
+            row = await cur.fetchone()
             row_count = row[0] if row else 0
         except Exception:
             row_count = 0
 
         try:
-            row = await conn.execute(
+            cur = await conn.execute(
                 "SELECT pg_size_pretty(pg_total_relation_size(%s))", [table]
-            ).fetchone()
+            )
+            row = await cur.fetchone()
             total_size = row[0] if row else "unknown"
         except Exception:
             total_size = "unknown"

mcp_database_universal/nl2sql.py

@@ -0,0 +1,269 @@
+"""Natural-language to SQL translation.
+
+Two strategies:
+
+1. ``llm_translate``  — real LLM-backed translation. Calls OpenAI or
+   Anthropic over plain HTTP (``urllib``, no extra dependencies) when an
+   API key is configured.
+2. ``offline_translate`` — dependency-free rules-based parser that covers
+   common English question shapes against the database's real table names.
+"""
+
+import asyncio
+import json
+import re
+import urllib.request
+from dataclasses import dataclass
+
+OPENAI_URL = "https://api.openai.com/v1/chat/completions"
+ANTHROPIC_URL = "https://api.anthropic.com/v1/messages"
+ANTHROPIC_VERSION = "2023-06-01"
+
+DEFAULT_OPENAI_MODEL = "gpt-4o-mini"
+DEFAULT_ANTHROPIC_MODEL = "claude-3-5-haiku-20241022"
+
+LLM_TIMEOUT = 25.0
+
+
+@dataclass
+class Translation:
+    sql: str | None
+    source: str  # "llm" or "offline"
+    error: str | None = None
+
+
+def _build_prompt(table_names: list[str]) -> str:
+    quoted = ", ".join(f'"{t}"' for t in table_names)
+    return (
+        "You translate a user question into a single read-only SQL query. "
+        "The database contains these tables: " + quoted + ".\n\n"
+        "Rules:\n"
+        "- Output ONLY the SQL statement. No explanations, no markdown.\n"
+        "- Use SELECT (or WITH ... SELECT). Never INSERT/UPDATE/DELETE/DROP.\n"
+        "- Quote identifiers that need quoting, values must be quoted properly.\n"
+        "- Return plain text SQL ending with a newline."
+    )
+
+
+def _extract_sql(response: str) -> str | None:
+    text = response.strip()
+    if not text:
+        return None
+    # strip triple-backtick fences (with or without a language tag)
+    fenced = re.search(r"```(?:sql)?\s*(.*?)```", text, re.IGNORECASE | re.DOTALL)
+    if fenced:
+        text = fenced.group(1).strip()
+    else:
+        # if the model wrapped the answer in prose, grab the first statement
+        for ln in text.splitlines():
+            ln = ln.strip()
+            if re.match(r"^(SELECT|WITH)\b", ln, re.IGNORECASE):
+                text = ln
+                break
+    text = text.rstrip(";").strip()
+    if re.match(r"^(SELECT|WITH)\b", text, re.IGNORECASE):
+        return text
+    return None
+
+
+def _call_openai(api_key: str, prompt: str, question: str, model: str) -> str:
+    body = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": question},
+        ],
+        "temperature": 0,
+    }
+    req = urllib.request.Request(
+        OPENAI_URL,
+        data=json.dumps(body).encode("utf-8"),
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}",
+        },
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=LLM_TIMEOUT) as resp:
+        data = json.loads(resp.read().decode("utf-8"))
+    return data["choices"][0]["message"]["content"]
+
+
+def _call_anthropic(api_key: str, prompt: str, question: str, model: str) -> str:
+    body = {
+        "model": model,
+        "max_tokens": 512,
+        "system": prompt,
+        "messages": [{"role": "user", "content": question}],
+    }
+    req = urllib.request.Request(
+        ANTHROPIC_URL,
+        data=json.dumps(body).encode("utf-8"),
+        headers={
+            "Content-Type": "application/json",
+            "x-api-key": api_key,
+            "anthropic-version": ANTHROPIC_VERSION,
+        },
+        method="POST",
+    )
+    with urllib.request.urlopen(req, timeout=LLM_TIMEOUT) as resp:
+        data = json.loads(resp.read().decode("utf-8"))
+    content = data.get("content", [])
+    return "".join(block.get("text", "") for block in content)
+
+
+async def llm_translate(
+    question: str,
+    table_names: list[str],
+    *,
+    openai_key: str | None = None,
+    anthropic_key: str | None = None,
+    openai_model: str = DEFAULT_OPENAI_MODEL,
+    anthropic_model: str = DEFAULT_ANTHROPIC_MODEL,
+) -> Translation:
+    """Translate via a real LLM API call (OpenAI preferred, then Anthropic)."""
+    prompt = _build_prompt(table_names)
+
+    if openai_key:
+        try:
+            raw = await asyncio.wait_for(
+                asyncio.to_thread(_call_openai, openai_key, prompt, question, openai_model),
+                timeout=LLM_TIMEOUT,
+            )
+            sql = _extract_sql(raw)
+            if sql:
+                return Translation(sql=sql, source="llm")
+            return Translation(sql=None, source="llm", error="LLM returned no usable SQL")
+        except Exception as e:  # network, timeout, bad response
+            return Translation(sql=None, source="llm", error=str(e))
+
+    if anthropic_key:
+        try:
+            raw = await asyncio.wait_for(
+                asyncio.to_thread(_call_anthropic, anthropic_key, prompt, question, anthropic_model),
+                timeout=LLM_TIMEOUT,
+            )
+            sql = _extract_sql(raw)
+            if sql:
+                return Translation(sql=sql, source="llm")
+            return Translation(sql=None, source="llm", error="LLM returned no usable SQL")
+        except Exception as e:
+            return Translation(sql=None, source="llm", error=str(e))
+
+    return Translation(sql=None, source="llm", error="No API key configured")
+
+
+def offline_translate(question: str, table_names: list[str]) -> Translation:
+    """Rule-based fallback. English-only patterns, matched against real tables."""
+    table_map = {t.lower(): t for t in table_names}
+    q = question.lower().strip()
+
+    def table_match(words: tuple[str, ...]) -> tuple[str, list[str]] | None:
+        """Return (real_name, matched_words) if any consecutive table matches."""
+        if not words:
+            return None
+        for i in range(len(words)):
+            for size in (2, 1):
+                if i + size > len(words):
+                    continue
+                chunk = " ".join(words[i : i + size])
+                candidates = {chunk}
+                folded = chunk.replace("_", "")
+                candidates.add(folded)
+                # singular/plural tolerance ("user" -> "users", "users" -> "user")
+                candidates.add(chunk + "s")
+                if size == 1 and chunk.endswith("s"):
+                    candidates.add(chunk[:-1])
+                for cand in candidates:
+                    if cand in table_map:
+                        return table_map[cand], list(words[i : i + size])
+        return None
+
+    words = re.findall(r"[\w_]+", q)
+
+    # "how many <table>." / "count of <table>." / "how many <table> are there"
+    m = re.search(r"\b(?:how many|count|number of)\b\s+([\w\s]+?)\s*$", q)
+    if m:
+        hit = table_match(tuple(m.group(1).split()))
+        if hit:
+            tbl = hit[0]
+            return Translation(sql=f'SELECT COUNT(*) AS count FROM "{tbl}"', source="offline")
+
+    # "top N <col> of <table>" / "highest/lowest/most/least ... <col> in <table>"
+    m = re.search(
+        r"\b(top|best|worst|highest|lowest|most expensive|least expensive|max|min)\b\s*"
+        r"(\d+)?\s*([\w_]+?)\s+(?:in|of|from)\s+([\w\s]+)",
+        q,
+    )
+    if m:
+        order, num_s, col_part, tbl_part = m.groups()
+        hit = table_match(tuple(tbl_part.split()))
+        if hit:
+            tbl = hit[0]
+            col_cand = col_part.strip()
+            limit = int(num_s) if num_s else 10
+            direction = "ASC" if order in ("lowest", "least expensive", "min") else "DESC"
+            return Translation(
+                sql=f'SELECT * FROM "{tbl}" ORDER BY "{col_cand}" {direction} LIMIT {limit}',
+                source="offline",
+            )
+
+    # "show/list/get/select ... <col> from <table>" or "select * from <table>"
+    m = re.search(r"\bfrom\s+([\w\s]+)", q)
+    if m:
+        hit = table_match(tuple(m.group(2).split()))
+        if hit:
+            tbl = hit[0]
+            return Translation(sql=f'SELECT * FROM "{tbl}" LIMIT 100', source="offline")
+
+    # "<table> where <col> = <value>"
+    m = re.search(r"\bwhere\b\s+([\w_]+)\s*[=:]\s*['\"]?([\w\s.,%]+?)['\"]?$", q)
+    if m:
+        col_cand, val = m.groups()
+        hit = table_match(tuple(words))
+        if hit:
+            tbl = hit[0]
+            if re.fullmatch(r"\d+(\.\d+)?", val.strip()):
+                return Translation(
+                    sql=f'SELECT * FROM "{tbl}" WHERE "{col_cand}" = {val.strip()} LIMIT 100',
+                    source="offline",
+                )
+            return Translation(
+                sql=f'SELECT * FROM "{tbl}" WHERE "{col_cand}" = \'{val.strip()}\' LIMIT 100',
+                source="offline",
+            )
+
+    # table mentioned at all → return the table as a fallback listing
+    if words:
+        hit = table_match(tuple(words))
+        if hit:
+            tbl = hit[0]
+            return Translation(sql=f'SELECT * FROM "{tbl}" LIMIT 100', source="offline")
+
+    return Translation(sql=None, source="offline")
+
+
+async def translate(
+    question: str,
+    table_names: list[str],
+    *,
+    openai_key: str | None = None,
+    anthropic_key: str | None = None,
+) -> Translation:
+    """Prefer the LLM path when a key is available, otherwise use the parser."""
+    llm = await llm_translate(
+        question,
+        table_names,
+        openai_key=openai_key,
+        anthropic_key=anthropic_key,
+    )
+    if llm.sql:
+        return llm
+
+    offline = offline_translate(question, table_names)
+    if offline.sql:
+        return offline
+
+    if llm.error and llm.error != "No API key configured":
+        return Translation(sql=None, source="llm", error=llm.error)
+    return Translation(sql=None, source="offline")

mcp_database_universal/server.py

@@ -1,7 +1,6 @@
 """MCP Database Server — main server with 7 reasoning tools."""
 
 import json
-import re
 import sys
 import logging
 from mcp.server.mcpserver import MCPServer
@@ -10,6 +9,8 @@ from mcp_database_universal.engines.base import BaseEngine
 from mcp_database_universal.safety import SafetyValidator
 from mcp_database_universal.schema_inspector import SchemaInspector
 from mcp_database_universal.formatters.llm import LLMFormatter
+from mcp_database_universal.nl2sql import translate
+from mcp_database_universal import __version__
 
 logger = logging.getLogger("mcp-db")
 
@@ -17,7 +18,7 @@ logger = logging.getLogger("mcp-db")
 async def create_server(config: DatabaseConfig, engine: BaseEngine) -> MCPServer:
     server = MCPServer(
         name="mcp-database-server",
-        version="0.1.0",
+        version=__version__,
     )
 
     safety = SafetyValidator(
@@ -118,51 +119,30 @@ async def create_server(config: DatabaseConfig, engine: BaseEngine) -> MCPServer
         about the data. Examples: "How many users have orders?",
         "What product sells the best?"
 
+        Translation: an LLM (OpenAI/Anthropic) is used when OPENAI_API_KEY or
+        ANTHROPIC_API_KEY is configured; otherwise a built-in rules-based
+        parser handles common English question shapes.
+
         Returns: generated SQL + results + explanation.
         """
-        question_lower = question.lower().strip()
         tables = await engine.get_tables()
         table_names = [t.name for t in tables]
-        table_map = {t.name.lower(): t.name for t in tables}
-
-        sql = None
-
-        count_match = re.search(r'(?:kolik|count|how many)\s+(\w+)', question_lower)
-        if count_match:
-            candidate = count_match.group(1)
-            if candidate in table_map:
-                real_name = table_map[candidate]
-                sql = f'SELECT COUNT(*) as count FROM "{real_name}"'
-
-        if not sql:
-            select_match = re.search(r'(?:vsechny|zobraz|ukaž|show|select|get)\s+(\w+)', question_lower)
-            if select_match:
-                candidate = select_match.group(1)
-                if candidate in table_map:
-                    real_name = table_map[candidate]
-                    sql = f'SELECT * FROM "{real_name}" LIMIT 100'
 
-        if not sql:
-            where_match = re.search(r'(\w+)\s+(?:s|where|with)\s+(\w+)\s*[=:]\s*["\']?(\w+)["\']?', question_lower)
-            if where_match:
-                table_cand, col_cand, val = where_match.groups()
-                if table_cand in table_map:
-                    real_name = table_map[table_cand]
-                    sql = f'SELECT * FROM "{real_name}" WHERE "{col_cand}" = ? LIMIT 100'
-
-        if not sql:
-            top_match = re.search(r'nej(?:vetsi|mensi|lepsi|drazsi|levnejsi|best|worst|top)\s+(\w+)\s+v\s+(\w+)', question_lower)
-            if not top_match:
-                top_match = re.search(r'(?:top|best|worst|highest|lowest)\s+(\w+)\s+(?:in|from)\s+(\w+)', question_lower)
-            if top_match:
-                col_cand, table_cand = top_match.groups()
-                if table_cand in table_map:
-                    real_name = table_map[table_cand]
-                    sql = f'SELECT * FROM "{real_name}" ORDER BY "{col_cand}" DESC LIMIT 10'
+        translation = await translate(
+            question,
+            table_names,
+            openai_key=config.openai_key,
+            anthropic_key=config.anthropic_key,
+        )
 
+        sql = translation.sql
         if not sql:
+            reason = translation.error or "no matching pattern"
+            source_note = f" (LLM: {reason})" if translation.source == "llm" else ""
             return (
-                "Could not automatically translate your question to SQL.\n\n"
+                "Could not automatically translate your question to SQL"
+                + source_note
+                + ".\n\n"
                 "Try using the `query` tool directly with SQL, or rephrase your question.\n"
                 f"Available tables: {', '.join(table_names)}\n\n"
                 "Examples:\n"
@@ -171,13 +151,15 @@ async def create_server(config: DatabaseConfig, engine: BaseEngine) -> MCPServer
                 "- 'What products cost more than 100?'"
             )
 
-        validation = safety.validate(sql)
+        safe_sql = safety.ensure_limit(sql)
+        validation = safety.validate(safe_sql)
         if not validation.approved:
             return f"Generated query was blocked: {validation.reason}"
 
-        result = await engine.execute_query(sql)
+        result = await engine.execute_query(safe_sql)
         output = formatter.format_query_result(result)
-        output = f"**Question:** {question}\n\n{output}"
+        source_note = "LLM" if translation.source == "llm" else "rules-based"
+        output = f"**Question:** {question}\n**Generated SQL** ({source_note}): `{safe_sql}`\n\n{output}"
         return output
 
     @server.tool()