spice-mcp 0.1.3__tar.gz → 0.1.5__tar.gz

{spice_mcp-0.1.3 → spice_mcp-0.1.5}/.gitignore

@@ -24,3 +24,5 @@ debug_api.py
 
 # Local testing environment
 test_spice_mcp/
+scripts/
+test_mcp_cursor/

spice_mcp-0.1.5/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: spice-mcp
+Version: 0.1.5
+Summary: mcp server built ontop of dune api endpoint
+Author-email: Evan-Kim2028 <ekcopersonal@gmail.com>
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: aiohttp>=3.9.5
+Requires-Dist: fastmcp>=0.3.0
+Requires-Dist: mcp>=0.9.0
+Requires-Dist: polars>=1.35.1
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich-argparse>=1.5.2
+Requires-Dist: rich>=13.3.3
+Description-Content-Type: text/markdown
+
+# spice-mcp
+
+[![PyPI version](https://img.shields.io/pypi/v/spice-mcp.svg)](https://pypi.org/project/spice-mcp/)
+<a href="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp/badge" alt="Spice MCP server" />
+</a>
+
+An MCP server that provides AI agents with direct access to [Dune Analytics](https://dune.com/) data. Execute queries, discover schemas and tables, and manage saved queries—all through a clean, type-safe interface optimized for AI workflows.
+
+**Discover High-Quality Tables**: Leverages [Dune Spellbook](https://github.com/duneanalytics/spellbook), Dune's official GitHub repository of curated dbt models, to surface verified, production-ready tables with rich metadata.
+
+## Why spice-mcp?
+
+- **Agent-friendly**: Designed for AI agents using the Model Context Protocol (MCP)
+- **High-Quality Discovery**: Leverages Dune Spellbook's GitHub repository to find verified, production-ready tables with rich metadata
+- **Efficient**: Polars-first pipeline keeps data lazy until needed, reducing memory usage
+- **Discovery**: Built-in tools to explore Dune's extensive blockchain datasets from both Dune API and Spellbook
+- **Type-safe**: Fully typed parameters and responses with FastMCP
+- **Reproducible**: Automatic query history logging and SQL artifact storage
+
+## Quick Start
+
+1. **Install**:
+   ```bash
+   uv pip install spice-mcp
+   ```
+
+2. **Set API key** (choose one method):
+   - **Option A**: Create a `.env` file in your project root:
+     ```bash
+     echo "DUNE_API_KEY=your-api-key-here" > .env
+     ```
+   - **Option B**: Export in your shell:
+     ```bash
+     export DUNE_API_KEY=your-api-key-here
+     ```
+
+3. **Use with Cursor IDE**:
+   Add to Cursor Settings → MCP Servers:
+   ```json
+   {
+     "name": "spice-mcp",
+     "command": "spice-mcp",
+     "env": {
+       "DUNE_API_KEY": "your-dune-api-key-here"
+     }
+   }
+   ```
+
+**Note**: Query history logging is enabled by default. Logs are saved to `logs/queries.jsonl` (or `~/.spice_mcp/logs/queries.jsonl` if not in a project directory). To customize paths, set `SPICE_QUERY_HISTORY` and `SPICE_ARTIFACT_ROOT` environment variables.
+
+## Core Tools
+
+| Tool | Description | Key Parameters |
+|------|-------------|----------------|
+| `dune_query` | Execute queries by ID, URL, or raw SQL | `query` (str), `parameters` (object), `limit` (int), `offset` (int), `format` (`preview\|raw\|metadata\|poll`), `refresh` (bool), `timeout_seconds` (float) |
+| `dune_query_info` | Get metadata for a saved query | `query` (str - ID or URL) |
+| `dune_discover` | Unified discovery across Dune API and Spellbook (returns verified tables only). **Leverages Dune Spellbook GitHub repository** for high-quality, curated tables. | `keyword` (str\|list), `schema` (str), `limit` (int), `source` (`dune\|spellbook\|both`), `include_columns` (bool) |
+| `dune_describe_table` | Get column metadata for a table | `schema` (str), `table` (str) |
+| `dune_health_check` | Verify API key and configuration | (no parameters) |
+| `dune_query_create` | Create a new saved query | `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_update` | Update an existing saved query | `query_id` (int), `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_fork` | Fork an existing saved query | `source_query_id` (int), `name` (str) |
+
+## Resources
+
+- `spice:history/tail/{n}` — View last N lines of query history (1-1000)
+- `spice:artifact/{sha}` — Retrieve stored SQL by SHA-256 hash
+
+## What is Dune?
+
+[Dune](https://dune.com/) is a crypto data platform providing curated blockchain datasets and a public API. It aggregates on-chain data from Ethereum, Solana, Polygon, and other chains into queryable SQL tables. See the [Dune Docs](https://dune.com/docs) for more information.
+
+## What is Dune Spellbook?
+
+[Dune Spellbook](https://github.com/duneanalytics/spellbook) is Dune's official GitHub repository containing thousands of curated dbt models. These models represent high-quality, production-ready tables that are:
+
+- **Verified**: All tables are verified to exist in Dune before being returned
+- **Well-documented**: Rich metadata including column descriptions and types
+- **Maintained**: Regularly updated by the Dune community and team
+- **Production-ready**: Used by analysts and dashboards across the ecosystem
+
+spice-mcp automatically clones and parses the Spellbook repository to discover these high-quality tables, parsing dbt config blocks to resolve actual Dune table names and verifying their existence before returning them to you.
+
+## Installation
+
+**From PyPI** (recommended):
+```bash
+uv pip install spice-mcp
+```
+
+**From source**:
+```bash
+git clone https://github.com/Evan-Kim2028/spice-mcp.git
+cd spice-mcp
+uv sync
+uv pip install -e .
+```
+
+**Requirements**: Python 3.13+
+
+## Documentation
+
+- [Tool Reference](docs/tools.md) — Complete tool documentation with parameters
+- [Architecture](docs/architecture.md) — Code structure and design patterns
+- [Discovery Guide](docs/discovery.md) — How to explore Dune schemas and tables
+- [Dune API Guide](docs/dune_api.md) — Understanding Dune's data structure
+- [Configuration](docs/config.md) — Environment variables and settings
+
+## License
+
+See [LICENSE](LICENSE) file for details.

spice_mcp-0.1.5/README.md

@@ -0,0 +1,112 @@
+# spice-mcp
+
+[![PyPI version](https://img.shields.io/pypi/v/spice-mcp.svg)](https://pypi.org/project/spice-mcp/)
+<a href="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@Evan-Kim2028/spice-mcp/badge" alt="Spice MCP server" />
+</a>
+
+An MCP server that provides AI agents with direct access to [Dune Analytics](https://dune.com/) data. Execute queries, discover schemas and tables, and manage saved queries—all through a clean, type-safe interface optimized for AI workflows.
+
+**Discover High-Quality Tables**: Leverages [Dune Spellbook](https://github.com/duneanalytics/spellbook), Dune's official GitHub repository of curated dbt models, to surface verified, production-ready tables with rich metadata.
+
+## Why spice-mcp?
+
+- **Agent-friendly**: Designed for AI agents using the Model Context Protocol (MCP)
+- **High-Quality Discovery**: Leverages Dune Spellbook's GitHub repository to find verified, production-ready tables with rich metadata
+- **Efficient**: Polars-first pipeline keeps data lazy until needed, reducing memory usage
+- **Discovery**: Built-in tools to explore Dune's extensive blockchain datasets from both Dune API and Spellbook
+- **Type-safe**: Fully typed parameters and responses with FastMCP
+- **Reproducible**: Automatic query history logging and SQL artifact storage
+
+## Quick Start
+
+1. **Install**:
+   ```bash
+   uv pip install spice-mcp
+   ```
+
+2. **Set API key** (choose one method):
+   - **Option A**: Create a `.env` file in your project root:
+     ```bash
+     echo "DUNE_API_KEY=your-api-key-here" > .env
+     ```
+   - **Option B**: Export in your shell:
+     ```bash
+     export DUNE_API_KEY=your-api-key-here
+     ```
+
+3. **Use with Cursor IDE**:
+   Add to Cursor Settings → MCP Servers:
+   ```json
+   {
+     "name": "spice-mcp",
+     "command": "spice-mcp",
+     "env": {
+       "DUNE_API_KEY": "your-dune-api-key-here"
+     }
+   }
+   ```
+
+**Note**: Query history logging is enabled by default. Logs are saved to `logs/queries.jsonl` (or `~/.spice_mcp/logs/queries.jsonl` if not in a project directory). To customize paths, set `SPICE_QUERY_HISTORY` and `SPICE_ARTIFACT_ROOT` environment variables.
+
+## Core Tools
+
+| Tool | Description | Key Parameters |
+|------|-------------|----------------|
+| `dune_query` | Execute queries by ID, URL, or raw SQL | `query` (str), `parameters` (object), `limit` (int), `offset` (int), `format` (`preview\|raw\|metadata\|poll`), `refresh` (bool), `timeout_seconds` (float) |
+| `dune_query_info` | Get metadata for a saved query | `query` (str - ID or URL) |
+| `dune_discover` | Unified discovery across Dune API and Spellbook (returns verified tables only). **Leverages Dune Spellbook GitHub repository** for high-quality, curated tables. | `keyword` (str\|list), `schema` (str), `limit` (int), `source` (`dune\|spellbook\|both`), `include_columns` (bool) |
+| `dune_describe_table` | Get column metadata for a table | `schema` (str), `table` (str) |
+| `dune_health_check` | Verify API key and configuration | (no parameters) |
+| `dune_query_create` | Create a new saved query | `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_update` | Update an existing saved query | `query_id` (int), `name` (str), `query_sql` (str), `description` (str), `tags` (list), `parameters` (list) |
+| `dune_query_fork` | Fork an existing saved query | `source_query_id` (int), `name` (str) |
+
+## Resources
+
+- `spice:history/tail/{n}` — View last N lines of query history (1-1000)
+- `spice:artifact/{sha}` — Retrieve stored SQL by SHA-256 hash
+
+## What is Dune?
+
+[Dune](https://dune.com/) is a crypto data platform providing curated blockchain datasets and a public API. It aggregates on-chain data from Ethereum, Solana, Polygon, and other chains into queryable SQL tables. See the [Dune Docs](https://dune.com/docs) for more information.
+
+## What is Dune Spellbook?
+
+[Dune Spellbook](https://github.com/duneanalytics/spellbook) is Dune's official GitHub repository containing thousands of curated dbt models. These models represent high-quality, production-ready tables that are:
+
+- **Verified**: All tables are verified to exist in Dune before being returned
+- **Well-documented**: Rich metadata including column descriptions and types
+- **Maintained**: Regularly updated by the Dune community and team
+- **Production-ready**: Used by analysts and dashboards across the ecosystem
+
+spice-mcp automatically clones and parses the Spellbook repository to discover these high-quality tables, parsing dbt config blocks to resolve actual Dune table names and verifying their existence before returning them to you.
+
+## Installation
+
+**From PyPI** (recommended):
+```bash
+uv pip install spice-mcp
+```
+
+**From source**:
+```bash
+git clone https://github.com/Evan-Kim2028/spice-mcp.git
+cd spice-mcp
+uv sync
+uv pip install -e .
+```
+
+**Requirements**: Python 3.13+
+
+## Documentation
+
+- [Tool Reference](docs/tools.md) — Complete tool documentation with parameters
+- [Architecture](docs/architecture.md) — Code structure and design patterns
+- [Discovery Guide](docs/discovery.md) — How to explore Dune schemas and tables
+- [Dune API Guide](docs/dune_api.md) — Understanding Dune's data structure
+- [Configuration](docs/config.md) — Environment variables and settings
+
+## License
+
+See [LICENSE](LICENSE) file for details.

{spice_mcp-0.1.3 → spice_mcp-0.1.5}/docs/codex_cli.md

@@ -54,8 +54,8 @@ Verify configuration
 - `codex mcp list` should list `spice_mcp_beta` with the python command and no secrets in Env.
 
 Try some tools
-- Find schemas
-  - `mcp__spice_mcp_beta__dune_find_tables {"keyword": "dex"}`
+- Find schemas and tables
+  - `mcp__spice_mcp_beta__dune_discover {"keyword": "dex", "source": "dune"}`
 - Describe a table
   - `mcp__spice_mcp_beta__dune_describe_table {"schema": "dex", "table": "trades"}`
 - Query preview (with metadata/pagination)

{spice_mcp-0.1.3 → spice_mcp-0.1.5}/docs/discovery.md

@@ -2,20 +2,24 @@ Catalog Discovery
 
 Summary
 - There is no public REST endpoint to browse the full catalog. Discovery is best achieved using Dune SQL primitives and fallback probes.
+- **Native SHOW statements are preferred** - they're faster than information_schema queries. See issue #10 for details.
 
 Approach
 - Schemas
   - SHOW SCHEMAS
   - SHOW SCHEMAS LIKE '%keyword%'
+  - ⚠️ Avoid: information_schema.schemata (slower, causes lag)
 - Tables
   - SHOW TABLES FROM <schema>
   - If SHOW is blocked, probe candidate names via SELECT 1 FROM <schema>.<table> LIMIT 1
+  - ⚠️ Avoid: information_schema.tables (slower, causes lag)
 - Columns
   - SHOW COLUMNS FROM <schema>.<table>
   - Fallback: SELECT * FROM <schema>.<table> LIMIT 1, infer columns and Polars dtypes client-side
-- INFORMATION_SCHEMA
-  - Some deployments allow: information_schema.schemata/tables/columns
-  - If blocked, use SHOW + probes
+- INFORMATION_SCHEMA (Deprecated)
+  - Previously used for portability, but causes performance issues
+  - Native SHOW statements are now used directly (faster, no lag)
+  - Kept as fallback only if SHOW is blocked
 
 
 Helpers in this repo
@@ -23,5 +27,8 @@ Helpers in this repo
   - `find_schemas(keyword)`, `list_tables(schema, limit)`, `describe_table(schema, table)`
 
 MCP Tools
-- dune_find_tables: search schemas and list tables
+- dune_discover: **PRIMARY discovery tool** - unified search across Dune API and Spellbook, returns verified tables only
+  - Automatically parses dbt configs from Spellbook models to resolve actual Dune table names
+  - Verifies tables exist in Dune before returning (uses persistent cache)
+  - Filters out non-existent tables
 - dune_describe_table: describe columns with SHOW + fallback

spice_mcp-0.1.5/docs/tools.md

@@ -0,0 +1,118 @@
+Tools Reference
+
+All tools are exposed by the MCP server started with `spice-mcp`.
+
+1) dune_discover
+- Purpose: **PRIMARY discovery tool** for finding tables in Dune. Searches both Dune API and Spellbook repository. Returns ONLY verified, queryable tables.
+- ⚠️ **IMPORTANT**: Always use this tool instead of querying `information_schema` directly (which is slow and causes lag).
+- Input schema:
+  - keyword?: string | string[] — search term(s) to find schemas/tables (e.g., "walrus", ["layerzero", "dex"])
+  - schema?: string — schema name to list tables from (e.g., "dex", "sui_walrus")
+  - limit?: integer (default 50) — maximum number of tables to return
+  - source?: 'dune' | 'spellbook' | 'both' (default 'both') — where to search
+  - include_columns?: boolean (default true) — include column details for Spellbook models
+- Output fields:
+  - schemas: string[] — matching schema names
+  - tables: array of table objects, each with:
+    - schema: string — Spellbook subproject name (for Spellbook models) or Dune schema name
+    - table: string — Spellbook model name (for Spellbook models) or Dune table name
+    - fully_qualified_name: string — schema.table format
+    - source: 'dune' | 'spellbook'
+    - dune_schema?: string — actual Dune schema name (for Spellbook models, parsed from dbt config)
+    - dune_alias?: string — actual Dune table alias (for Spellbook models, parsed from dbt config)
+    - dune_table?: string — verified, queryable Dune table name (e.g., "sui_walrus.base_table")
+    - verified?: boolean — true (all returned tables are verified to exist)
+    - columns?: array — column details (if include_columns=true)
+  - source: string — the source parameter used
+  - message?: string — helpful message if no tables found
+- Features:
+  - Automatically parses dbt configs from Spellbook models to resolve actual Dune table names
+  - Verifies tables exist in Dune before returning (uses persistent cache)
+  - Filters out non-existent tables
+- Examples:
+  - Search for walrus tables (returns verified tables only):
+    - `dune_discover {"keyword":"walrus"}`
+    - → Returns tables with `dune_table` field like "sui_walrus.base_table"
+  - Use discovered table to query:
+    - `dune_query {"query":"SELECT * FROM sui_walrus.base_table LIMIT 10"}`
+  - Search only Spellbook:
+    - `dune_discover {"keyword":["layerzero","bridge"],"source":"spellbook"}`
+  - List tables in a schema:
+    - `dune_discover {"schema":"dex"}`
+
+2) dune_query
+- Purpose: Execute Dune queries (ID, URL, raw SQL) and return a compact preview plus Dune metadata/pagination hints.
+- ⚠️ **IMPORTANT**: Always use `dune_discover` FIRST to find verified table names. Do not guess table names or query `information_schema` directly.
+- Input schema:
+  - query: string (required) — Query ID, URL, or raw SQL using tables from `dune_discover`
+  - parameters?: object
+  - performance?: 'medium' | 'large'
+  - limit?: integer, offset?: integer, sort_by?: string, columns?: string[], sample_count?: integer
+  - refresh?: boolean, max_age?: number, timeout_seconds?: number
+  - format?: 'preview' | 'raw' | 'metadata' | 'poll' (preview by default)
+  - extras?: object (e.g., allow_partial_results, ignore_max_datapoints_per_request)
+- Output fields:
+  - type: 'preview' | 'metadata' | 'raw' | 'execution'
+  - rowcount: number, columns: string[]
+  - data_preview: object[] (first rows)
+  - execution_id: string, duration_ms: number
+  - metadata?: structured Dune metadata / execution state / error hints
+  - next_uri?: string, next_offset?: number
+  - Errors: `{ "ok": false, "error": { code, message, data: { suggestions }, context? } }`
+- Examples:
+  - Workflow: discover → query:
+    - `dune_discover {"keyword":"walrus"}` → get `dune_table="sui_walrus.base_table"`
+    - `dune_query {"query":"SELECT * FROM sui_walrus.base_table LIMIT 10"}`
+  - Preview latest metadata without rows:
+    - `dune_query {"query":"4388","format":"metadata"}`
+  - Preview first rows and metadata:
+    - `dune_query {"query":"4388","limit":10}`
+
+Logging & Artifacts
+- Successful calls are written to a JSONL audit log (see `docs/config.md` for path configuration via `QueryHistory`).
+- The canonical SQL is stored as a deduplicated artefact keyed by SHA‑256 (for raw SQL and query IDs/URLs), enabling reproducibility and offline review.
+- Result caching is handled by `adapters.dune.cache` (parquet files) and can be tuned via `SPICE_CACHE_*` environment variables.
+ 
+
+3) dune_describe_table
+- Purpose: Describe columns for a schema.table (SHOW + fallback to 1-row SELECT inference).
+- Input schema:
+  - schema: string
+  - table: string
+- Output fields:
+  - columns: [{ name, dune_type?, polars_dtype?, extra?, comment? }]
+  - Errors follow the standard MCP envelope.
+
+3) dune_health_check
+- Purpose: Basic environment and logging readiness check.
+- Output fields: ok, api_key_present, status
+
+4) dune_query_info
+- Purpose: Fetch Dune query object metadata (name, description, tags, parameter schema, SQL).
+- Input schema:
+  - query: string — ID or URL
+- Output fields:
+  - ok: boolean, status: number, query_id: number
+  - name?: string, description?: string, tags?: string[], parameters?: object[], version?: number, query_sql?: string
+
+5) dune_query_create
+- Purpose: Create a saved Dune query.
+- Input schema:
+  - name: string (required)
+  - query_sql: string (required)
+  - description?: string, tags?: string[], parameters?: object[]
+- Output: Dune query object
+
+6) dune_query_update
+- Purpose: Update a saved Dune query.
+- Input schema:
+  - query_id: integer (required)
+  - name?: string, query_sql?: string, description?: string, tags?: string[], parameters?: object[]
+- Output: Dune query object
+
+7) dune_query_fork
+- Purpose: Fork an existing saved Dune query.
+- Input schema:
+  - source_query_id: integer (required)
+  - name?: string (new name)
+- Output: Dune query object

{spice_mcp-0.1.3 → spice_mcp-0.1.5}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "spice-mcp"
-version = "0.1.3"
-description = "MCP server for Dune Analytics data access"
+version = "0.1.5"
+description = "mcp server built ontop of dune api endpoint"
 authors = [
     { name = "Evan-Kim2028", email = "ekcopersonal@gmail.com" }
 ]

{spice_mcp-0.1.3 → spice_mcp-0.1.5}/src/spice_mcp/adapters/dune/client.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import os
-import re
 import time
 from collections.abc import Mapping, Sequence
 from typing import Any
@@ -24,6 +23,10 @@ from ...polars_utils import collect_preview
 from ..http_client import HttpClient, HttpClientConfig
 from . import extract, urls
 
+# Use wrapper to avoid FastMCP detecting overloads in extract.query()
+# Note: We still import extract for _determine_input_type and other non-overloaded functions
+from .query_wrapper import execute_query as _execute_dune_query
+
 
 class DuneAdapter(QueryExecutor, CatalogExplorer):
     """Thin façade around the vendored extract module."""
@@ -43,11 +46,10 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
         self._ensure_api_key()
         start = time.time()
         q = request.query
-        if isinstance(q, str):
-            q_rewritten = _maybe_rewrite_show_sql(q)
-            if q_rewritten is not None:
-                q = q_rewritten
-        result = extract.query(
+        # Use native SHOW statements directly - they're faster than information_schema queries
+        # See issue #10: https://github.com/Evan-Kim2028/spice-mcp/issues/10
+        # Removed rewrite to avoid performance issues with information_schema queries
+        result = _execute_dune_query(
             query_or_execution=q,
             verbose=False,
             refresh=request.refresh,
@@ -123,9 +125,10 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
                     pass
 
             url = urls.get_query_results_url(query_id, parameters=params, csv=False)
+            from .user_agent import get_user_agent
             headers = {
                 "X-Dune-API-Key": self._api_key(),
-                "User-Agent": extract.get_user_agent(),
+                "User-Agent": get_user_agent(),
             }
             try:
                 resp = self._http.request("GET", url, headers=headers)
@@ -195,9 +198,11 @@ class DuneAdapter(QueryExecutor, CatalogExplorer):
     # Internal helpers --------------------------------------------------------------
     def _run_sql(self, sql: str, *, limit: int | None = None) -> pl.DataFrame:
         self._ensure_api_key()
-        sql_eff = _maybe_rewrite_show_sql(sql) or sql
-        df = extract.query(
-            sql_eff,
+        # Use native SHOW statements directly - they're faster than information_schema queries
+        # See issue #10: https://github.com/Evan-Kim2028/spice-mcp/issues/10
+        sql_eff = sql
+        df = _execute_dune_query(
+            query_or_execution=sql_eff,
             verbose=False,
             performance="medium",
             timeout_seconds=self.config.default_timeout_seconds,
@@ -228,28 +233,12 @@ def _build_preview(lf: pl.LazyFrame, columns: list[str], rowcount: int) -> Resul
 
 
 def _maybe_rewrite_show_sql(sql: str) -> str | None:
-    """Rewrite certain SHOW statements to information_schema SELECTs for portability.
-
-    This allows running discovery-style commands through the parameterized raw SQL
-    template which expects SELECT statements.
+    """DEPRECATED: This function is no longer used.
+    
+    Native SHOW statements are now used directly as they're faster than
+    information_schema queries in Dune. See issue #10 for details.
+    
+    This function is kept for backward compatibility but is not called.
     """
-    s = sql.strip()
-    m = re.match(r"^SHOW\s+SCHEMAS\s+LIKE\s+'([^']+)'\s*;?$", s, flags=re.IGNORECASE)
-    if m:
-        pat = m.group(1)
-        return (
-            "SELECT schema_name AS Schema FROM information_schema.schemata "
-            f"WHERE schema_name LIKE '{pat}'"
-        )
-    if re.match(r"^SHOW\s+SCHEMAS\s*;?$", s, flags=re.IGNORECASE):
-        return "SELECT schema_name AS Schema FROM information_schema.schemata"
-
-    m = re.match(r"^SHOW\s+TABLES\s+FROM\s+([A-Za-z0-9_\.]+)\s*;?$", s, flags=re.IGNORECASE)
-    if m:
-        schema = m.group(1)
-        return (
-            "SELECT table_name AS Table FROM information_schema.tables "
-            f"WHERE table_schema = '{schema}'"
-        )
-
+    # Function body kept for reference but not executed
     return None

{spice_mcp-0.1.3 → spice_mcp-0.1.5}/src/spice_mcp/adapters/dune/extract.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import io
+import os
 import time
 from typing import TYPE_CHECKING, overload
-import os
 
 from ..http_client import HttpClient
 from . import cache as _cache
@@ -289,6 +289,14 @@ def query(
 
         # execute or retrieve query
         if query_id:
+            # Check if this is a parameterized query (raw SQL via template or parameterized query)
+            # For parameterized queries, results don't exist until execution, so skip GET attempt
+            is_parameterized = (
+                parameters is not None 
+                and len(parameters) > 0 
+                and ('query' in parameters or any(k != 'query' for k in parameters))
+            )
+            
             if cache and load_from_cache and not refresh:
                 cache_result, cache_execution = _cache.load_from_cache(
                     execute_kwargs, result_kwargs, output_kwargs
@@ -301,7 +309,8 @@ def query(
                 age = get_query_latest_age(**execute_kwargs, verbose=verbose)  # type: ignore
                 if age is None or age > max_age:
                     refresh = True
-            if not refresh:
+            # Skip GET results attempt for parameterized queries - they need execution first
+            if not refresh and not is_parameterized:
                 df = get_results(**execute_kwargs, **result_kwargs)
                 if df is not None:
                     return process_result(df, execution, **output_kwargs)
@@ -334,9 +343,44 @@ def query(
             return execution
 
 
-@overload
-@overload
-@overload
+if TYPE_CHECKING:
+    @overload
+    def _process_result(
+        df: pl.DataFrame,
+        execution: Execution | None,
+        execute_kwargs: ExecuteKwargs,
+        result_kwargs: RetrievalKwargs,
+        cache: bool,
+        save_to_cache: bool,
+        cache_dir: str | None,
+        include_execution: Literal[False],
+    ) -> pl.DataFrame: ...
+
+    @overload
+    def _process_result(
+        df: pl.DataFrame,
+        execution: Execution | None,
+        execute_kwargs: ExecuteKwargs,
+        result_kwargs: RetrievalKwargs,
+        cache: bool,
+        save_to_cache: bool,
+        cache_dir: str | None,
+        include_execution: Literal[True],
+    ) -> tuple[pl.DataFrame, Execution]: ...
+
+    @overload
+    def _process_result(
+        df: pl.DataFrame,
+        execution: Execution | None,
+        execute_kwargs: ExecuteKwargs,
+        result_kwargs: RetrievalKwargs,
+        cache: bool,
+        save_to_cache: bool,
+        cache_dir: str | None,
+        include_execution: bool,
+    ) -> pl.DataFrame | tuple[pl.DataFrame, Execution]: ...
+
+
 def _process_result(
     df: pl.DataFrame,
     execution: Execution | None,