sql-mcp 0.1.0__py3-none-any.whl

sql_mcp/safety.py

@@ -0,0 +1,173 @@
+"""Read-only statement gate for sql-mcp (CONCEPT:SQL-1.3).
+
+``sql_query`` accepts only read statements. The gate strips string literals,
+quoted identifiers, and comments, then classifies the statement by its first
+significant keyword against an allowlist (``SELECT``, ``WITH``, ``EXPLAIN``,
+``SHOW``, ``DESCRIBE``, ``PRAGMA``, ``VALUES``). CTEs are inspected at paren
+depth zero so ``WITH ... INSERT`` cannot smuggle a write, ``SELECT ... INTO``
+is rejected, and multi-statement payloads are refused outright. Writes go
+through ``sql_execute`` and only when the server was started with
+``SQL_ALLOW_WRITES=True``.
+"""
+
+import re
+
+READ_ONLY_STARTERS = {
+    "select",
+    "with",
+    "explain",
+    "show",
+    "describe",
+    "desc",
+    "pragma",
+    "values",
+}
+
+MUTATING_KEYWORDS = {
+    "insert",
+    "update",
+    "delete",
+    "merge",
+    "replace",
+    "truncate",
+    "create",
+    "alter",
+    "drop",
+    "grant",
+    "revoke",
+    "call",
+    "exec",
+    "execute",
+    "set",
+    "copy",
+    "vacuum",
+    "attach",
+    "detach",
+}
+
+_TOKEN_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*|\(|\)|;")
+
+
+class StatementNotAllowedError(ValueError):
+    """Raised when a statement violates the read-only or single-statement gate."""
+
+
+def strip_literals_and_comments(sql: str) -> str:
+    """Replace string literals, quoted identifiers, and comments with spaces.
+
+    Keeps offsets stable so keyword scanning cannot be fooled by SQL keywords
+    embedded in strings, quoted identifiers, or comments.
+    """
+    out: list[str] = []
+    i, n = 0, len(sql)
+    while i < n:
+        ch = sql[i]
+        if ch in ("'", '"', "`"):
+            quote = ch
+            out.append(" ")
+            i += 1
+            while i < n:
+                if sql[i] == quote:
+                    # Doubled quote = escaped quote inside the literal.
+                    if i + 1 < n and sql[i + 1] == quote:
+                        out.append("  ")
+                        i += 2
+                        continue
+                    out.append(" ")
+                    i += 1
+                    break
+                out.append(" " if sql[i] != "\n" else "\n")
+                i += 1
+        elif ch == "[":
+            # T-SQL bracketed identifier.
+            out.append(" ")
+            i += 1
+            while i < n and sql[i] != "]":
+                out.append(" ")
+                i += 1
+            if i < n:
+                out.append(" ")
+                i += 1
+        elif ch == "-" and sql[i : i + 2] == "--":
+            while i < n and sql[i] != "\n":
+                out.append(" ")
+                i += 1
+        elif ch == "/" and sql[i : i + 2] == "/*":
+            out.append("  ")
+            i += 2
+            while i < n and sql[i : i + 2] != "*/":
+                out.append(" " if sql[i] != "\n" else "\n")
+                i += 1
+            if i < n:
+                out.append("  ")
+                i += 2
+        else:
+            out.append(ch)
+            i += 1
+    return "".join(out)
+
+
+def assert_single_statement(sql: str) -> str:
+    """Reject payloads containing more than one SQL statement.
+
+    Returns the stripped (literal/comment-free) text for further inspection.
+    """
+    stripped = strip_literals_and_comments(sql)
+    head, sep, tail = stripped.partition(";")
+    if sep and tail.strip():
+        raise StatementNotAllowedError(
+            "Multiple SQL statements in one call are not allowed; "
+            "send one statement per call (sql_execute action 'script' runs "
+            "a list of statements in a single transaction)."
+        )
+    if not head.strip():
+        raise StatementNotAllowedError("Empty SQL statement.")
+    return stripped
+
+
+def first_keyword(stripped_sql: str) -> str:
+    """Return the first significant keyword of a stripped statement."""
+    for match in _TOKEN_RE.finditer(stripped_sql):
+        tok = match.group(0)
+        if tok in ("(", ")", ";"):
+            continue
+        return tok.lower()
+    return ""
+
+
+def assert_read_only(sql: str) -> None:
+    """Raise :class:`StatementNotAllowedError` unless ``sql`` is a read.
+
+    Checks, in order: single statement, allowlisted first keyword, no
+    depth-zero mutating keyword inside a CTE, and no depth-zero ``INTO``
+    (``SELECT INTO`` / ``INTO OUTFILE`` are writes).
+    """
+    stripped = assert_single_statement(sql)
+    keyword = first_keyword(stripped)
+    if keyword not in READ_ONLY_STARTERS:
+        allowed = ", ".join(sorted(k.upper() for k in READ_ONLY_STARTERS))
+        raise StatementNotAllowedError(
+            f"Statement type {keyword.upper()!r} is not allowed by sql_query "
+            f"(read-only). Allowed: {allowed}. Use sql_execute for writes "
+            "(requires SQL_ALLOW_WRITES=True on the server)."
+        )
+
+    depth = 0
+    for match in _TOKEN_RE.finditer(stripped):
+        tok = match.group(0)
+        if tok == "(":
+            depth += 1
+        elif tok == ")":
+            depth = max(0, depth - 1)
+        elif depth == 0:
+            lowered = tok.lower()
+            if lowered in MUTATING_KEYWORDS:
+                raise StatementNotAllowedError(
+                    f"Top-level {lowered.upper()!r} is not allowed in sql_query "
+                    "(read-only). Use sql_execute for writes."
+                )
+            if lowered == "into":
+                raise StatementNotAllowedError(
+                    "Top-level 'INTO' is not allowed in sql_query "
+                    "(SELECT INTO creates objects). Use sql_execute for writes."
+                )

sql_mcp/sql_input_models.py

@@ -0,0 +1,63 @@
+#!/usr/bin/python
+"""Pydantic input models for sql-mcp tool parameters (CONCEPT:SQL-1.5).
+
+Typed contracts for the ``params_json`` payloads accepted by the four
+action-dispatch MCP tools (``sql_query``, ``sql_execute``, ``sql_schema``,
+``sql_admin``).
+"""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class QueryInput(BaseModel):
+    """Input model for ``sql_query`` actions (execute / explain)."""
+
+    sql: str = Field(description="Single read-only statement with :name binds.")
+    params: dict[str, Any] | None = Field(
+        default=None, description="Bound parameter values."
+    )
+    max_rows: int | None = Field(
+        default=None, description="Row cap (clamped to the server cap)."
+    )
+    timeout: float | None = Field(
+        default=None, description="Statement timeout in seconds."
+    )
+
+
+class ExecuteInput(BaseModel):
+    """Input model for ``sql_execute`` action 'execute' (DML/DDL)."""
+
+    sql: str = Field(description="Single DML/DDL statement with :name binds.")
+    params: dict[str, Any] | list[dict[str, Any]] | None = Field(
+        default=None, description="Bound values; a list runs executemany."
+    )
+    timeout: float | None = Field(
+        default=None, description="Statement timeout in seconds."
+    )
+
+
+class ScriptInput(BaseModel):
+    """Input model for ``sql_execute`` action 'script'."""
+
+    statements: list[str] = Field(
+        description="Statements run in one all-or-nothing transaction."
+    )
+    timeout: float | None = Field(
+        default=None, description="Per-statement timeout in seconds."
+    )
+
+
+class SchemaInput(BaseModel):
+    """Input model for ``sql_schema`` actions."""
+
+    table: str | None = Field(
+        default=None, description="Table name (columns/indexes/foreign_keys/ddl)."
+    )
+    schema_name: str | None = Field(
+        default=None, alias="schema", description="Schema/namespace to inspect."
+    )
+    limit: int | None = Field(
+        default=10, description="Row preview limit for the 'sample' action."
+    )

sql_mcp/sql_response_models.py

@@ -0,0 +1,51 @@
+#!/usr/bin/python
+"""Pydantic response models for sql-mcp result envelopes (CONCEPT:SQL-1.4).
+
+Typed contracts for the bounded envelopes returned by the
+:class:`~sql_mcp.api_client.Api` facade and surfaced through the MCP tools.
+"""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class QueryResponse(BaseModel):
+    """Bounded result envelope for read-only queries."""
+
+    columns: list[str] | None = Field(
+        default=None, description="Result column names, in select order."
+    )
+    rows: list[list[Any]] | None = Field(
+        default=None, description="Row values (JSON-safe), capped at max_rows."
+    )
+    row_count: int | None = Field(default=None, description="Number of rows returned.")
+    truncated: bool | None = Field(
+        default=None, description="True when the row cap cut the result short."
+    )
+    elapsed_seconds: float | None = Field(
+        default=None, description="Wall-clock execution time."
+    )
+
+
+class ExecuteResponse(BaseModel):
+    """Result envelope for DML/DDL statements."""
+
+    affected_rows: int | None = Field(
+        default=None, description="Rows affected by the statement."
+    )
+    elapsed_seconds: float | None = Field(
+        default=None, description="Wall-clock execution time."
+    )
+
+
+class PingResponse(BaseModel):
+    """Connection health envelope for ``sql_admin`` action 'ping'."""
+
+    ok: bool | None = Field(default=None, description="Connection succeeded.")
+    latency_seconds: float | None = Field(
+        default=None, description="Round-trip latency of SELECT 1."
+    )
+    raw: dict[str, Any] | None = Field(
+        default=None, description="Raw response payload."
+    )

sql_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.4
+Name: sql-mcp
+Version: 0.1.0
+Summary: Generic SQL database (Postgres, MySQL/MariaDB, MSSQL, Oracle, SQLite) API + MCP Server + A2A Server for Agentic AI!
+Author-email: Audel Rouhi <knucklessg1@gmail.com>
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: <3.15,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: agent-utilities>=0.47.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: sqlalchemy>=2.0.0
+Provides-Extra: mcp
+Requires-Dist: agent-utilities[mcp]>=0.47.0; extra == "mcp"
+Provides-Extra: agent
+Requires-Dist: agent-utilities[agent,logfire]>=0.47.0; extra == "agent"
+Provides-Extra: postgres
+Requires-Dist: psycopg[binary]>=3.1.0; extra == "postgres"
+Provides-Extra: mysql
+Requires-Dist: pymysql>=1.1.0; extra == "mysql"
+Provides-Extra: mssql
+Requires-Dist: pyodbc>=5.0.0; extra == "mssql"
+Provides-Extra: oracle
+Requires-Dist: oracledb>=2.0.0; extra == "oracle"
+Provides-Extra: all
+Requires-Dist: sql-mcp[agent,logfire,mcp,mssql,mysql,oracle,postgres]>=0.1.0; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest-xdist>=3.6.0; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# Sql Mcp
+## API | MCP Server | A2A Agent
+
+![PyPI - Version](https://img.shields.io/pypi/v/sql-mcp)
+![MCP Server](https://badge.mcpx.dev?type=server 'MCP Server')
+![PyPI - Downloads](https://img.shields.io/pypi/dd/sql-mcp)
+![GitHub Repo stars](https://img.shields.io/github/stars/Knuckles-Team/sql-mcp)
+![GitHub forks](https://img.shields.io/github/forks/Knuckles-Team/sql-mcp)
+![GitHub contributors](https://img.shields.io/github/contributors/Knuckles-Team/sql-mcp)
+![PyPI - License](https://img.shields.io/pypi/l/sql-mcp)
+![GitHub](https://img.shields.io/github/license/Knuckles-Team/sql-mcp)
+![GitHub last commit (by committer)](https://img.shields.io/github/last-commit/Knuckles-Team/sql-mcp)
+![GitHub pull requests](https://img.shields.io/github/issues-pr/Knuckles-Team/sql-mcp)
+![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/Knuckles-Team/sql-mcp)
+![GitHub issues](https://img.shields.io/github/issues/Knuckles-Team/sql-mcp)
+![GitHub top language](https://img.shields.io/github/languages/top/Knuckles-Team/sql-mcp)
+![GitHub language count](https://img.shields.io/github/languages/count/Knuckles-Team/sql-mcp)
+![GitHub repo size](https://img.shields.io/github/repo-size/Knuckles-Team/sql-mcp)
+![PyPI - Wheel](https://img.shields.io/pypi/wheel/sql-mcp)
+![PyPI - Implementation](https://img.shields.io/pypi/implementation/sql-mcp)
+
+Generic SQL database **API + MCP Server + A2A Agent** for the agent-utilities
+ecosystem — one connector for **PostgreSQL, MySQL/MariaDB, Microsoft SQL Server,
+Oracle, and SQLite** over SQLAlchemy 2.x Core.
+
+*Version: 0.1.0*
+
+> **Documentation** — Installation, deployment, and usage across the API, CLI, and
+> MCP interfaces are maintained in [`docs/`](docs/index.md).
+
+## Table of Contents
+
+- [Overview](#overview)
+- [What it provides](#what-it-provides)
+- [MCP tools](#mcp-tools)
+- [Dialects & extras](#dialects--extras)
+- [Configuration (environment)](#configuration-environment)
+- [Installation](#installation)
+- [Usage](#usage)
+- [MCP config](#mcp-config)
+- [Docker deployment](#docker-deployment)
+- [Safety model](#safety-model)
+- [Tests](#tests)
+
+## Overview
+
+`sql-mcp` exposes read-only queries, gated DML/DDL, schema reflection, and
+connection administration as typed, deterministic MCP tools, and ships an optional
+Pydantic-AI agent server. It is **read-only by default**: every query passes a
+statement-type allowlist, every result is bounded by a row cap and a timeout, and
+all values travel as bound parameters — never interpolated into SQL strings.
+
+## What it provides
+
+- **`SqlApi`** (`sql_mcp.api.api_client_sql`) — a SQLAlchemy 2.x Core facade with
+  named multi-connection support, lazy engine creation, the read-only statement
+  gate, row-cap/timeout enforcement, and bounded result envelopes
+  (`{columns, rows, row_count, truncated}`).
+- **Four MCP tools** (`sql-mcp` console script): `sql_query` (execute/explain),
+  `sql_execute` (execute/script — gated by `SQL_ALLOW_WRITES`), `sql_schema`
+  (schemas/tables/views/columns/indexes/foreign_keys/ddl/sample), and `sql_admin`
+  (ping/version/active_connections/connections/dialects). See
+  [`docs/usage.md`](docs/usage.md) for the full action surface.
+- **A dialect registry** (`sql_mcp.dialects`) — per-engine driver, URL scheme, pip
+  extra, EXPLAIN prefix, and admin SQL. Core ships SQLite only; the other drivers
+  install via extras.
+- **An A2A agent server** (`sql-agent` console script) — a Pydantic-AI graph agent
+  wired to the MCP server via `MCP_URL`.
+
+## MCP tools
+
+| Tool | Actions | Description |
+|---|---|---|
+| `sql_query` | `execute`, `explain` | Run a read-only SELECT/CTE with bound parameters, or return the dialect's query plan |
+| `sql_execute` | `execute`, `script` | One DML/DDL statement (or an all-or-nothing statement list) in a transaction — requires `SQL_ALLOW_WRITES=True` |
+| `sql_schema` | `schemas`, `tables`, `views`, `columns`, `indexes`, `foreign_keys`, `ddl`, `sample` | Reflect schemas, tables, columns, indexes, FKs, CREATE DDL, and preview rows |
+| `sql_admin` | `ping`, `version`, `active_connections`, `connections`, `dialects` | Connection health, server version, server sessions, registry info, driver availability |
+
+Every tool takes `action`, `params_json`, and an optional `connection` naming one
+of the configured connections. The whole set is toggled with `SQLTOOL`.
+
+## Dialects & extras
+
+| Dialect | SQLAlchemy scheme | Driver | Install |
+|---|---|---|---|
+| SQLite | `sqlite+pysqlite` | stdlib | `pip install sql-mcp` (core) |
+| PostgreSQL | `postgresql+psycopg` | psycopg 3 | `pip install sql-mcp[postgres]` |
+| MySQL / MariaDB | `mysql+pymysql` | PyMySQL | `pip install sql-mcp[mysql]` |
+| SQL Server | `mssql+pyodbc` | pyodbc | `pip install sql-mcp[mssql]` |
+| Oracle | `oracle+oracledb` | python-oracledb | `pip install sql-mcp[oracle]` |
+
+`pip install sql-mcp[all]` pulls every driver plus the MCP and agent extras.
+
+## Configuration (environment)
+
+| Var | Default | Meaning |
+|---|---|---|
+| `SQL_CONNECTIONS` | _(empty)_ | JSON map of named connections: DSN strings or `{dialect, host, port, username, password, database, options}` objects |
+| `SQL_URL` | _(empty)_ | Single DSN registered as connection `default` |
+| `SQL_DIALECT` / `SQL_HOST` / `SQL_PORT` / `SQL_USERNAME` / `SQL_PASSWORD` / `SQL_DATABASE` / `SQL_OPTIONS` | _(empty)_ | Discrete fields for a single `default` connection |
+| `SQL_ALLOW_WRITES` | `False` | Enable `sql_execute` (DML/DDL). **Read-only by default** |
+| `SQL_MAX_ROWS` | `500` | Per-call row cap; tool requests are clamped to it |
+| `SQL_TIMEOUT_SECONDS` | `30` | Per-statement timeout |
+| `SQLTOOL` | `True` | Register the SQL tool set |
+
+With nothing configured the server registers a zero-infra in-memory SQLite
+connection named `memory`, so it works out of the box. Tools take an optional
+`connection` parameter naming one of the configured connections; it defaults to
+the sole/first one. Passwords are parsed into `sqlalchemy.URL` objects and only
+ever rendered redacted. Copy [`.env.example`](.env.example) to `.env` and
+populate only what you use.
+
+## Installation
+
+```bash
+pip install sql-mcp            # core (SQLite, MCP server, API)
+pip install sql-mcp[all]       # every driver + MCP + agent extras
+pip install -e .               # from source
+```
+
+Or pull the container image:
+
+```bash
+docker pull knucklessg1/sql-mcp:latest
+```
+
+## Usage
+
+```bash
+sql-mcp                        # stdio MCP server (default transport)
+sql-mcp --transport streamable-http --host 0.0.0.0 --port 8000
+```
+
+Point it at a database:
+
+```bash
+export SQL_URL="postgresql+psycopg://svc:****@db.example.com:5432/app"
+sql-mcp
+```
+
+Or several:
+
+```bash
+export SQL_CONNECTIONS='{
+  "warehouse": "postgresql+psycopg://svc:****@dw.example.com:5432/dw",
+  "erp": {"dialect": "mysql", "host": "erp.example.com", "username": "svc",
+           "password": "****", "database": "erp"}
+}'
+sql-mcp
+```
+
+Run the agent server against a live MCP server:
+
+```bash
+sql-agent --mcp-url http://localhost:8000/mcp --host 0.0.0.0 --port 8080
+```
+
+## MCP config
+
+```json
+{
+  "mcpServers": {
+    "sql-mcp": {
+      "command": "uv",
+      "args": ["run", "sql-mcp"],
+      "env": {
+        "SQL_URL": "postgresql+psycopg://svc:****@db.example.com:5432/app",
+        "SQL_ALLOW_WRITES": "False"
+      }
+    }
+  }
+}
+```
+
+## Docker deployment
+
+```bash
+docker compose -f docker/mcp.compose.yml up -d      # MCP server only
+docker compose -f docker/agent.compose.yml up -d    # MCP + A2A agent
+curl -s http://localhost:8000/health                 # {"status":"OK"}
+```
+
+Both services read configuration from `../.env` (copy
+[`.env.example`](.env.example)); see [`docs/deployment.md`](docs/deployment.md).
+
+## Safety model
+
+- **Read-only by default** — `sql_execute` refuses to run unless the *server* was
+  started with `SQL_ALLOW_WRITES=True`; agents cannot flip the flag per call.
+- **Statement allowlist** — `sql_query` accepts only `SELECT`/`WITH`/`EXPLAIN`/
+  `SHOW`/`DESCRIBE`/`PRAGMA`/`VALUES`; CTEs are inspected at paren depth zero so
+  `WITH ... INSERT` cannot smuggle a write, `SELECT INTO` is rejected, and
+  multi-statement payloads are refused.
+- **Bounded results** — per-call row caps clamp to `SQL_MAX_ROWS`; statements run
+  under `SQL_TIMEOUT_SECONDS` on a worker thread.
+- **Parameterized only** — values bind via `:name` parameters; identifiers are
+  quoted by SQLAlchemy reflection, never hand-interpolated.
+
+## Tests
+
+```bash
+python -m pytest          # full suite against in-memory SQLite (no live DBs)
+pre-commit run --all-files
+```

sql_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+sql_mcp/__init__.py,sha256=UKk2kQcTfuziAS-zLROroHvh-hE_CwhrKGKg2nLDE8w,1969
+sql_mcp/__main__.py,sha256=zTRw8hiXzH7JYZXbXIU82pPTwE79CTdY0yeDd_unPvo,93
+sql_mcp/agent_server.py,sha256=4hNLUgwEyBDk_DvHzVN1sfWt7WEssuUoO8Tnt4Weyy0,2246
+sql_mcp/api_client.py,sha256=ecO-M6gqFR4fbQurXbGzGmcnN4XIL8X7udXeyeyrlJ4,216
+sql_mcp/auth.py,sha256=Bd8MhGyWD7nOTq4WmEAd7-R1LVC6kj5TtO5dwzOGeVE,4907
+sql_mcp/dialects.py,sha256=_yTIqRqdOwjBrJVLg53j2M1JuporDPpjGbugUYu3KK8,5796
+sql_mcp/main_agent.json,sha256=3IQ-xaWgPF_3FNCxTXUUbZTvPYZ86YlAXuyVRvUeKnE,761
+sql_mcp/mcp_config.json,sha256=cNNBmPPOMlHq8Qy7dNuOqIPf11ksjldHxrmXBBypl04,1024
+sql_mcp/mcp_server.py,sha256=FkWsa7iC5A0-VdnSWPjWbu5cPjRlbJB-qJ245j6gSFk,1850
+sql_mcp/safety.py,sha256=8C_sZkqBedDyrmmQKAP342VXQQoIaUIR0fgY7cyzXo8,5527
+sql_mcp/sql_input_models.py,sha256=8BRrWicjQeNEC6mVQsFsy64JJuyPdeTxmKf2cvivuHc,2024
+sql_mcp/sql_response_models.py,sha256=lEoXfUnAgyTAEVe4hW03YB4xPPMIIidRuvIqKaxKCFc,1673
+sql_mcp/api/__init__.py,sha256=l6AnvVhbuZwNKTvNBBTyRYCh-LbqCjdo1Uv72Qu8rHw,197
+sql_mcp/api/api_client_sql.py,sha256=1hHr6WC18EZVEc1CrdEeg1rbGCCBzz7QAnFv_Ou5n1s,18504
+sql_mcp/mcp/__init__.py,sha256=LtlFYBHC_ic-cBeut2eK0mtUhWEbHQCmGt1yPa94qXk,127
+sql_mcp/mcp/mcp_sql.py,sha256=G8L3cBNifgAop93mrphXBUjWC4YZ8CvlKcXeLgwaZsk,8942
+sql_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=jF72OTufeQjenEQ8LJ_eSx7TAyClBHShwYcqjiTLrss,1070
+sql_mcp-0.1.0.dist-info/METADATA,sha256=MuoaV-DoH54msglRACtEoL_ggLfkQ_gzXWnLpqZRuEc,10037
+sql_mcp-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sql_mcp-0.1.0.dist-info/entry_points.txt,sha256=2fm-CH-KJ9_uLt5Nnqw7_y89Jw0TcpE8g1GtmVlrz8I,104
+sql_mcp-0.1.0.dist-info/top_level.txt,sha256=8obmI-aU_EX11fzddBJK87KRYU3jQaaOzIi2VHAsMMs,8
+sql_mcp-0.1.0.dist-info/RECORD,,

sql_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sql_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+sql-agent = sql_mcp.agent_server:agent_server
+sql-mcp = sql_mcp.mcp_server:mcp_server

sql_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Knuckles-Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sql_mcp-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sql_mcp