# jparkerweb/mcp-sqlite [Health: Active]

**Category:** 🗄️ Databases  
**Repository:** https://github.com/jparkerweb/mcp-sqlite  
**GitHub Stars:** 131  
**npm Downloads (last month):** 3408  
**Views:** 5  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/jparkerweb-mcp-sqlite

## Description
Model Context Protocol (MCP) server that provides comprehensive SQLite database interaction capabilities.

## Tools
Capabilities this server exposes over MCP:

- **db_info** — Get information about the SQLite database including path, existence, size, and table count
- **query** — Execute a raw SQL query against the database with optional parameter values
- **list_tables** — List all user tables in the SQLite database (excludes system tables)
- **get_table_schema** — Get the schema information for a specific table including column details
- **create_record** — Insert a new record into a table with specified data
- **read_records** — Read records from a table with optional conditions, limit, and offset
- **update_records** — Update records in a table based on specified conditions
- **delete_records** — Delete records from a table based on specified conditions

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "mcp-sqlite": {
    "command": "npx",
    "args": ["-y","mcp-sqlite"]
  }
}
```

## Documentation

## What jparkerweb/mcp-sqlite MCP server does

The jparkerweb/mcp-sqlite MCP server exposes a SQLite database to an MCP-compatible AI client. It accepts the path to a database file when the server starts, then provides tools for examining the database, running SQL, and changing table records. The repository identifies the project as built with the Model Context Protocol SDK and the `sqlite3` package.

This fits the 🗄️ Databases category because its scope is limited to SQLite database access. It does not describe a hosted database connection, an ORM, migrations, authentication, or support for database engines other than SQLite.

## How it works

The client starts the server as a stdio process and passes the database path as an argument. Once connected, an agent can call inspection tools to determine whether the database exists, view its size and table count, list user tables, or retrieve the columns and schema details for a named table.

For data access, the server offers both structured record operations and a general SQL entry point. Record operations accept table names and key-value objects for data or conditions. The `read_records` tool also accepts an optional limit and offset. The `query` tool accepts SQL text and an optional array of values, allowing parameterized statements such as a lookup using a positional placeholder.

## Setup and configuration

Install and configure the server through an MCP client's server settings. The database path is required as the final argument.

A Cursor configuration uses a server entry with `command` set to `npx` and arguments equivalent to `-y`, `mcp-sqlite`, and the path to the SQLite file. The VS Code example uses the same command and arguments, with the server type set to `stdio`. Replace the placeholder path with the database file the agent should access.

## Tools and capabilities

The jparkerweb/mcp-sqlite MCP server includes these tools:

- `db_info`: Reports the database path, whether it exists, its size, and its table count.
- `list_tables`: Lists user tables while excluding system tables.
- `get_table_schema`: Returns column and schema information for a specified table.
- `query`: Executes raw SQL with optional parameter values.
- `create_record`: Inserts a record using key-value data.
- `read_records`: Retrieves records with optional conditions, limit, and offset.
- `update_records`: Changes values in rows matching supplied conditions.
- `delete_records`: Removes rows matching supplied conditions.

Together, these tools cover database inspection, custom SQL, and CRUD workflows. The jparkerweb/mcp-sqlite MCP server can therefore support agents that need to understand an existing SQLite schema before reading or modifying its data.

## Limitations and notes

The documented database target is SQLite, and the examples show local stdio configuration rather than a network service. Because the server exposes raw SQL and write operations, configure the client with an appropriate database file and review agent access before allowing changes to important data.

_Full upstream README: https://allmcps.com/mcp/jparkerweb-mcp-sqlite/readme_