db-mcp (SQLite MCP Server)

Insert multiple rows in a single statement.

Simulate the impact of a DELETE, DROP, or TRUNCATE on a table. Shows which tables would be affected through cascading foreign key actions, with severity scoring.

Read the current _version of a specific row for optimistic concurrency control.

Update a row only if its _version matches expectedVersion. Prevents lost updates in multi-agent environments.

Analyze database schema for constraint health issues: missing primary keys, columns that should be NOT NULL, foreign keys without indexes, and tables that could benefit from FK relationships.

Count rows in a table, optionally filtered by a WHERE clause.

Create a virtual table from a CSV file. Requires the csv extension.

Create an index on one or more columns to improve query performance.

Create an optimized JSON document collection table with ID, data column, optional timestamps, and JSON path indexes.

Create an R-Tree virtual table for spatial indexing. Supports 2-5 dimensions.

Create a table populated with a series of numbers. Unlike generate_series, this creates a persistent table.

Create a new table in the database with specified columns and constraints. Idempotent if ifNotExists is set to true.

Create a database trigger that fires on INSERT, UPDATE, or DELETE events. Supports BEFORE/AFTER/INSTEAD OF timing, column-specific UPDATE triggers, and WHEN conditions. Use for audit trails, updated_at timestamps, FTS5 sync, and data validation.

Create a view based on a SELECT query.

Analyze data patterns and provide insights

Add or subtract time from a date column

Calculate the difference between two date/time columns

Get database storage statistics using dbstat virtual table.

Interactive walkthrough demonstrating MCP SQLite capabilities

Build a foreign key dependency graph showing relationships between all tables. Returns nodes (tables), edges (FK references), circular dependency detection, and root/leaf table identification.

Get detailed schema information for a table including columns, types, and constraints.

Detach a previously attached database by its schema alias. Cannot detach 'main' or 'temp'.

Disable optimistic concurrency control (OCC) on a table. Drops the _version column and its trigger.

Drop (delete) an index from the database.

Drop (delete) a table from the database. This is irreversible!

Drop (delete) a database trigger. This is irreversible.

Drop (delete) a view from the database.

Drop a virtual table.

Export the database schema and data as a SQL text dump

Enable optimistic concurrency control (OCC) on a table. Adds a _version column and an auto-increment trigger.

Execute JS in a sandbox using the sqlite.* API (e.g. sqlite.core.listTables()). Use sqlite.help() for docs. WARNING: Code can modify the DB unless readonly: true is passed.

Check whether rows exist in a table, optionally filtered by a WHERE clause.

Create an FTS5 full-text search virtual table.

Generate highlighted snippets from FTS5 full-text search results. Returns headline (highlight) and snippet (context window) for each match.

Get FTS5 match ranking information using bm25.

Rebuild an FTS5 index to optimize search performance.

Search an FTS5 table using full-text query syntax.

Find fuzzy matches using Levenshtein distance. By default, splits values into tokens and matches against each word (use tokenize:false to match entire value). Use maxDistance 1-3 for similar-length strings.

Generate a series of numbers using generate_series() virtual table.

Find points within a rectangular bounding box.

Cluster geographic points into grid cells.

Calculate the distance between two geographic points using Haversine formula.

Find points within a radius of a center point.

List all indexes in the database, optionally filtered by table.

Hybrid search combining full-text search and vector similarity using Reciprocal Rank Fusion (RRF).

Hybrid keyword + semantic search implementation workflow

Audit index effectiveness: find redundant indexes (prefix duplicates), missing foreign key indexes, and large tables without secondary indexes. Returns actionable suggestions.

Get detailed statistics for database indexes.

Check database integrity for corruption or errors.

Analyze JSON data in a column to infer its schema (types, nullability, counts).

Append a value to a JSON array using json_insert().

Get the length of a JSON array at the specified path.

Compare two JSON paths within the same row to find differences. Returns each row's values at both paths and whether they are identical. Useful for before/after comparisons in JSON columns.

Expand a JSON array or object into rows using json_each().

Extract a value from a JSON column at the specified path using json_extract().

Aggregate column values into a JSON array using json_group_array().

Aggregate key-value pairs into a JSON object using json_group_object().

Insert a new row with JSON data into a JSON column. Note: This creates a new table row, rather than modifying an existing JSON object.

Get the distinct keys of JSON objects at the specified path (returns unique keys across all matching rows).

Merge JSON object into existing JSON column using json_patch().

Normalize JSON data in a column (sort keys, compact format) for consistent storage and comparison.

Format JSON string with indentation for readability.

Query JSON data with path-based filters and projections.

Remove a value at a JSON path using json_remove().

Scan a JSON column for security issues (sensitive keys, SQL injection, XSS patterns). Use larger sampleSize for thorough scans.

Select rows and optionally extract specific JSON paths.

Set a value at a JSON path using json_set(). Creates path if it does not exist.

Analyze storage format of a JSON column (text vs JSONB) and report statistics.

Get the JSON type (null, true, false, integer, real, text, array, object) at a path.

Update a value at a specific JSON path using json_replace(). Only updates if the key already exists.

Check if a string is valid JSON.

Validate a JSON path syntax without executing a query.

Convert a text JSON column to JSONB binary format for faster processing. Requires SQLite 3.45+.

List all constraints for a table: primary key columns, foreign keys, unique indexes, and CHECK constraints. Provides a unified view of table integrity rules.

List all tables and views in the database with their column counts.

List database triggers. Optionally filter by associated table name. Shows trigger name, table, event type (INSERT/UPDATE/DELETE), timing (BEFORE/AFTER/INSTEAD OF), and full SQL definition.

List all views in the database.

List all virtual tables in the database.

Execute migration SQL and record it atomically. If the SQL fails, no record is created. Uses SHA-256 hashing for dedup.

Query migration history with optional filters by status and source system. Supports pagination.

Initialize the migration tracking system by creating the _mcp_migrations table. Safe to call multiple times — idempotent.

Record a migration that was applied externally (not executed by this tool). Uses SHA-256 hashing for dedup — duplicate SQL blocks are rejected.

Analyze DDL statements for SQLite-specific migration risks. Detects ALTER TABLE limitations, large table operations, column type changes, destructive operations, and FTS5 rebuild requirements.

Roll back a migration by ID or version. Requires that rollback SQL was recorded with the migration. Supports dry-run mode to preview the rollback SQL without executing.

Get a summary of migration tracking state — latest version, counts by status, and unique source systems.

Optimize database by reindexing and/or analyzing.

Find phonetically similar values using Soundex (SQLite native) or Metaphone algorithm.

Get the compile-time options used to build SQLite. Use the filter parameter to reduce output (~50+ options by default).

List all attached databases.

Run PRAGMA optimize to update query planner statistics

Get or set a PRAGMA value.

Get detailed column information for a table.

Analyze a SQL query's execution plan. Returns structured EXPLAIN QUERY PLAN output with scan-type classification (full scan, index scan, covering index) and optimization suggestions.

Execute a SELECT query on the SQLite database. Returns rows as JSON. Use parameter binding for safety.

Extract text matching a regex pattern. Processed in JavaScript after fetching data.

Find rows where column matches a regex pattern. Processed in JavaScript.

Rebuild indexes to fix corruption or update after collation changes. Targets a specific index, all indexes on a table, or all indexes in the database. Use after sqlite_integrity_check reports index issues.

Restore database from a backup file. WARNING: This replaces the current database.

Compare two schema snapshots and report structured drift — added, removed, and modified tables, views, indexes, and triggers. Accepts 'current' to capture the live database, or an inline snapshot object from a previous sqlite_schema_snapshot call.

Generate a comprehensive snapshot of the database schema — tables, views, indexes, and triggers — in a single call. Useful for understanding an unfamiliar database or diffing schema changes.

Get or update runtime configuration values for the server. Currently supports updating the log level.

Perform spatial analysis: nearest neighbor, point in polygon, distance matrix. For point_in_polygon, sourceTable should contain POINTs and targetTable should contain POLYGONs.

Create a spatial table with geometry column using SpatiaLite.

Import geometry data from WKT or GeoJSON into a spatial table.

Create, drop, or check spatial R-Tree index on geometry column.

Load SpatiaLite extension for geospatial capabilities. Required before using other spatial tools.

Execute spatial SQL queries using SpatiaLite functions (ST_Distance, ST_Within, etc.).

Perform geometry operations: buffer, intersection, union, centroid, simplify.

Get basic statistics (count, sum, avg, min, max) for a numeric column.

Calculate Pearson correlation coefficient between two numeric columns.

Count rows, optionally distinct values in a column.

Detects data distribution anomalies in numeric columns using z-score analysis. Flags rows where values deviate beyond a configurable threshold from the column mean. Returns per-column anomaly counts, top deviations, and an overall risk level.

Scores database and tables by fragmentation/bloat risk using multiple factors: free page ratio, per-table size, auto_vacuum status, and journal mode. Returns per-table risk scores (0-100), database-level metrics, and actionable recommendations.

Scores tables by schema health risk using multiple factors: missing indexes on foreign key columns, tables without primary keys, wide tables (>20 columns), and large unindexed tables. Returns per-table risk scores (0-100) with actionable recommendations.

Get distinct values from a column.

Get frequency distribution of values in a column.

Aggregate statistics grouped by a column.

Create a histogram with specified number of buckets.

Perform statistical hypothesis tests: one-sample t-test, two-sample t-test, or chi-square test.

Detect outliers using IQR (Interquartile Range) or Z-score method.

Calculate percentiles (median, quartiles, etc.) for a column.

Perform linear or polynomial regression analysis between two columns.

Get a random sample of rows for exploratory analysis. Uses ORDER BY RANDOM() which is O(N) — may be slow on very large tables (>1M rows).

Get summary statistics for multiple columns at once.

Get top N values from a column.

Analyze database storage health: fragmentation, size breakdown per table, and optimization recommendations. Aggregates PRAGMA + dbstat data into an actionable report.

Intelligent table analysis and summary generation with key statistics

Convert text to uppercase or lowercase.

Concatenate multiple columns with optional separator.

Normalize text using Unicode normalization (NFC, NFD, NFKC, NFKD) or strip accents.

Replace text in a column using SQLite replace() function.

Perform basic sentiment analysis on text column using keyword matching.

Split a text column by delimiter into array results.

Extract a substring from text column using substr().

Trim whitespace from text column values.

Validate text values against patterns: email, phone, URL, UUID, IPv4, or custom regex.

Generate a safe DDL execution order for tables based on foreign key dependencies. 'create' direction lists parent tables first; 'drop' direction lists child tables first.

Begin a new transaction. Use immediate or exclusive mode for write-heavy operations.

Commit the current transaction, making all changes permanent.

Execute multiple SQL statements in a single transaction. Automatically commits on success or rolls back on error.

Release a savepoint, keeping the changes made since it was created.

Rollback the current transaction, discarding all changes.

Rollback to a savepoint, discarding changes made after it was created.

Create a savepoint within the current transaction for partial rollback.

Check whether a transaction is currently active. Returns status and a boolean flag. Read-only — does not alter transaction state.

Truncate a table (executes DELETE FROM table).

Insert a row or update it if it already exists (INSERT ON CONFLICT DO UPDATE / INSERT OR REPLACE).

Rebuild the database to reclaim space and optimize structure.

Create a compacted, defragmented copy of the database at the specified path using VACUUM INTO. Does not modify the original database. The output path must be within the same directory as the primary database.

Store multiple vectors in a batch operation.

Count vectors in a table.

Create a table optimized for vector storage with JSON vector column.

Delete vectors by their IDs.

Get the dimensions of vectors in a table.

Calculate distance or similarity between two vectors.

Retrieve a vector by its ID.

Normalize a vector to unit length.

Find similar vectors using cosine, euclidean, or dot product similarity.

Get statistics about vectors in a table.

Store or update a vector in the database.

Verify a backup file's integrity without restoring it.

Get metadata about a specific virtual table.

Manage SQLite Write-Ahead Logging (WAL) mode. WAL improves concurrent read/write performance and is recommended for production databases. Actions: 'status' = check current journal mode, 'enable' = switch to WAL mode, 'disable' = switch back to DELETE (default) mode, 'checkpoint' = force a WAL checkpoint to sync WAL file to database.

Access previous (LAG) or next (LEAD) row values. Useful for comparing consecutive rows.

Calculate moving (rolling) average. Useful for smoothing time series data.

Divide rows into N buckets. E.g., 4 buckets = quartiles, 10 = deciles, 100 = percentiles.

Calculate rank of rows. RANK leaves gaps after ties, DENSE_RANK does not, PERCENT_RANK gives 0-1 range.

Assign sequential row numbers based on ordering. Useful for pagination and ranking.

Calculate running (cumulative) total. Useful for balance tracking, cumulative metrics.

Execute an INSERT, UPDATE, or DELETE query. Returns affected row count. Use parameter binding for safety.