sqlite MCP server
Commit Aug 25, 2026Enables AI clients to perform CRUD operations and execute SQL queries on SQLCipher 4 encrypted SQLite databases.
Also known as rosch100/mcp-sqlite
- Stars
- 0
- Tools
- 11
- Downloads, 30 days
- —
- Latest version
- 0.2.4
- Last commit
- Aug 25, 2026
- License
- Apache-2.0
What is sqlite MCP?
sqlite enables AI clients to perform CRUD operations and execute SQL queries on SQLCipher 4 encrypted SQLite databases. It exposes 11 tools, such as db_path, passphrase, include_columns.
Summary generated from the project's README
About sqlite MCP server
Accessing sensitive data from encrypted applications like Signal, WhatsApp, 1Password, or Telegram is possible through this MCP server. It allows AI clients to interact with SQLCipher 4 encrypted SQLite databases, providing a way to read and manage data that is otherwise locked behind encryption. Users can perform standard database tasks such as listing tables, exploring schemas, and executing arbitrary SQL queries including SELECT, INSERT, UPDATE, and DELETE operations.
This server is designed for use with MCP-compatible clients like Claude Desktop and Cursor. It supports secure authentication through AES-256-GCM encrypted passphrases, which can be integrated with the macOS Keychain for enhanced security. Developers can run the server locally via STDIO or use a Docker container for deployment. The implementation includes specific tools for CRUD operations and allows for custom SQLCipher configurations through configurable cipher profiles to match specific database requirements.
What you can do with it
- 1Analyze encrypted messaging historyAn AI client can query the message databases of apps like Signal or WhatsApp to retrieve chat logs.
- 2Manage password vault dataA developer can use the server to inspect or update entries within a 1Password or KeePass local vault.
- 3Inspect financial application databasesYou can use the list_tables tool to explore the schema of a MoneyMoney database to understand its structure.
- 4Perform secure data updatesThe server enables executing DDL and DML statements to modify data within an encrypted SQLite file.
Written from the project's README. Every use case is checked against a quote from it.
How to install sqlite MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall sqlite MCP in Claude Code
$ claude mcp add --env 'DB_PASSPHRASE=<YOUR_DB_PASSPHRASE>' --env 'DB_PATH=<DB_PATH>' mcp-sqlite -- docker run -i --rm ghcr.io/rosch100/mcp-sqlite:0.2.4Install sqlite MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"mcp-sqlite": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/rosch100/mcp-sqlite:0.2.4"
],
"env": {
"DB_PASSPHRASE": "<YOUR_DB_PASSPHRASE>",
"DB_PATH": "<DB_PATH>"
}
}
}
}Install sqlite MCP in VS Code
.vscode/mcp.json
{
"servers": {
"mcp-sqlite": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/rosch100/mcp-sqlite:0.2.4"
],
"env": {
"DB_PASSPHRASE": "<YOUR_DB_PASSPHRASE>",
"DB_PATH": "<DB_PATH>"
}
}
}
}Install sqlite MCP in VS Code CLI
$ code --add-mcp '{"name":"mcp-sqlite","type":"stdio","command":"docker","args":["run","-i","--rm","ghcr.io/rosch100/mcp-sqlite:0.2.4"],"env":{"DB_PASSPHRASE":"<YOUR_DB_PASSPHRASE>","DB_PATH":"<DB_PATH>"}}'Install sqlite MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"mcp-sqlite": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/rosch100/mcp-sqlite:0.2.4"
],
"env": {
"DB_PASSPHRASE": "<YOUR_DB_PASSPHRASE>",
"DB_PATH": "<DB_PATH>"
}
}
}
}Install sqlite MCP in Codex
$ codex mcp add mcp-sqlite --env 'DB_PASSPHRASE=<YOUR_DB_PASSPHRASE>' --env 'DB_PATH=<DB_PATH>' -- docker run -i --rm ghcr.io/rosch100/mcp-sqlite:0.2.4Install sqlite MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.mcp-sqlite] command = "docker" args = ["run", "-i", "--rm", "ghcr.io/rosch100/mcp-sqlite:0.2.4"] [mcp_servers.mcp-sqlite.env] DB_PASSPHRASE = "<YOUR_DB_PASSPHRASE>" DB_PATH = "<DB_PATH>"
Install sqlite MCP in Gemini CLI
$ gemini mcp add -s user -e 'DB_PASSPHRASE=<YOUR_DB_PASSPHRASE>' -e 'DB_PATH=<DB_PATH>' mcp-sqlite docker -- run -i --rm ghcr.io/rosch100/mcp-sqlite:0.2.4Install sqlite MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"mcp-sqlite": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/rosch100/mcp-sqlite:0.2.4"
],
"env": {
"DB_PASSPHRASE": "<YOUR_DB_PASSPHRASE>",
"DB_PATH": "<DB_PATH>"
}
}
}
}sqlite MCP tools 11
Detected from the READMEdb_pathpassphraseinclude_columnstablecolumnsfilterslimitoffsetsqlprimary_keysrows
| db_path | — | |
| passphrase | — | |
| include_columns | — | |
| table | — | |
| columns | — | |
| filters | — | |
| limit | — | |
| offset | — | |
| sql | — | |
| primary_keys | — | |
| rows | — |
Configuration
DB_PASSPHRASERequiredSecretPassphrase for decrypting the database
DB_PATHRequiredPath to the encrypted SQLite database file
JAVA_HOMEMCP_DEBUGMCP_SQLITE_ENCRYPTION_KEY
| Name | Description | |
|---|---|---|
| DB_PASSPHRASE | Passphrase for decrypting the database | RequiredSecret |
| DB_PATH | Path to the encrypted SQLite database file | Required |
| JAVA_HOME | — | |
| MCP_DEBUG | — | |
| MCP_SQLITE_ENCRYPTION_KEY | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablerosch100/mcp-sqlite is public and reachablegithub.com/rosch100/mcp-sqlite ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-08-25github.com/rosch100/mcp-sqlite ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model11 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubEncrypted SQLite MCP Server
MCP server for encrypted SQLite databases
A Model Context Protocol (MCP) server for working with encrypted SQLite databases using SQLCipher. This server provides tools to read database structures, query tables, and perform CRUD operations on encrypted SQLite databases.
Compatible with all MCP clients (Cursor, Claude Desktop, and others).
Works with encrypted databases from: MoneyMoney, 1Password, Signal, WhatsApp, Firefox, Telegram, KeePass, and other applications using SQLCipher encryption.
Features
- Encrypted SQLite Support: Works with SQLCipher 4 encrypted databases - the key differentiator of this MCP server
- Encrypted Passphrases: Support for AES-256-GCM encrypted passphrases with macOS Keychain integration
- Database Exploration: List tables, columns, indexes, and schema metadata
- Query Support: Execute arbitrary SQL queries (SELECT, INSERT, UPDATE, DELETE, DDL)
- CRUD Operations: Insert, update, and delete rows with filtering
- Configurable Cipher Profiles: Support for different SQLCipher configurations
- MCP Protocol: Full Model Context Protocol implementation via STDIO
- Security: SQL identifier validation to prevent SQL injection
- Debug Mode: Optional debug output via
MCP_DEBUGenvironment variable - Input Validation: Comprehensive validation for limits, offsets, and identifiers
Why Encrypted SQLite?
Many popular applications use encrypted SQLite databases (SQLCipher) to protect sensitive data. This MCP server is specifically designed to work with these encrypted databases.
Applications Using Encrypted SQLite Databases
- MoneyMoney (macOS): Financial management app with encrypted local databases
- 1Password: Password manager using SQLCipher for local vault storage
- Signal: Encrypted messaging app with SQLCipher-protected message databases
- WhatsApp: Messaging app using encrypted SQLite for local message storage
- Firefox: Browser using SQLCipher for encrypted login databases
- Telegram: Messaging app with encrypted local database storage
- KeePass: Password manager supporting encrypted SQLite database files
If you need to access data from any of these applications or other SQLCipher-encrypted databases, this MCP server provides the tools you need. Note that you need the passphrase of the encrypted database.
Requirements
- Java 21 or higher (JDK)
- Gradle (wrapper included)
- SQLite JDBC driver with encryption support (
sqlite-jdbc-3.50.1.0.jarfrom sqlite-jdbc-crypt)
Quick Start
Cursor (One-Click Installation)
The easiest way to install this MCP server in Cursor is via the Cursor MCP Store:
- Visit cursor.store/mcp/rosch100/mcp-encrypted-sqlite
- Click "Add to Cursor"
- Follow the prompts to configure your database path and passphrase
Other MCP Clients
This server works with any MCP-compatible client. See the Configuration section below for setup instructions.
Installation
Docker (Recommended)
Use the pre-built Docker image from GitHub Container Registry:
docker pull ghcr.io/rosch100/mcp-encrypted-sqlite:latest
Quick Start: See DOCKER_QUICKSTART.md for Docker Desktop setup.
Detailed Configuration: See DOCKER_CONFIGURATION.md for advanced options.
From Source
-
Clone the repository:
git clone https://github.com/rosch100/mcp-encrypted-sqlite.gitcd mcp-encrypted-sqlite -
Build the project:
./gradlew build installDist
The build process will automatically download sqlite-jdbc-3.50.1.0.jar from sqlite-jdbc-crypt releases and place it in the libs/ directory.
The executable will be available at build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite.
Configuration
This MCP server works with any MCP-compatible client (Cursor, Claude Desktop, etc.). The configuration format follows the Model Context Protocol specification.
The server communicates via STDIO (standard input/output). Add the following configuration to your MCP client's configuration file:
Configuration file locations:
- Cursor:
~/.cursor/mcp.json - Claude Desktop (macOS):
~/Library/Application Support/Claude/claude_desktop_config.json - Claude Desktop (Windows):
%APPDATA%\Claude\claude_desktop_config.json - Other clients: Refer to your client's documentation
{
"mcpServers": {
"encrypted-sqlite": {
"command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
"args": [
"--args",
"{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
]
}
}
}
Optional Parameters:
transport: Defaults to"stdio"(can be omitted)cwd: Not needed when using absolute paths (can be omitted)immutable: Optional boolean in the--argsJSON. Whentrue, opens the DB with SQLite URIfile:…?immutable=1(no file locks). Use for peeking at DBs locked exclusively by another app (e.g. MoneyMoney). All write tools/SQL are disabled in this mode (insert_or_update/delete_rowsomitted;execute_sqlaccepts read-only statements only).env: Only needed if Java is not in your system PATH or for custom Java installation:
{
"mcpServers": {
"encrypted-sqlite": {
"command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
"args": [
"--args",
"{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
],
"env": {
"JAVA_HOME": "/path/to/java/home"
}
}
}
}
Docker Configuration
Plain Passphrase
{
"mcpServers": {
"encrypted-sqlite": {
"command": "docker",
"args": [
"run", "--rm", "-i",
"-v", "/path/to/your/database.sqlite:/data/database.sqlite:ro",
"ghcr.io/rosch100/mcp-encrypted-sqlite:latest",
"--args",
"{\"db_path\":\"/data/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
]
}
}
}
Encrypted Passphrase (Recommended)
When using encrypted passphrases, you must pass the encryption key as an environment variable:
{
"mcpServers": {
"encrypted-sqlite": {
"command": "docker",
"args": [
"run", "--rm", "-i",
"-e", "MCP_SQLITE_ENCRYPTION_KEY=your-encryption-key",
"-v", "/path/to/your/database.sqlite:/data/database.sqlite:ro",
"ghcr.io/rosch100/mcp-encrypted-sqlite:latest",
"--args",
"{\"db_path\":\"/data/database.sqlite\",\"passphrase\":\"encrypted:your-encrypted-passphrase\"}"
]
}
}
}
Important Notes:
- The
-eflag must come before the-vflag - macOS Keychain is NOT accessible from Docker containers - pass the encryption key explicitly
- Get your encryption key:
security find-generic-password -s "mcp-encrypted-sqlite" -a "encryption-key" -w - The database file is mounted as read-only (
:ro) by default. Remove:roif you need write access
Security Warning: Storing both the encryption key and encrypted passphrase as plain text in your configuration file is a security risk. See DOCKER_CONFIGURATION.md for secure alternatives.
Custom Cipher Profile
Override the default SQLCipher 4 settings by including a cipherProfile in the configuration JSON:
{
"mcpServers": {
"encrypted-sqlite": {
"command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
"args": [
"--args",
"{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\",\"cipherProfile\":{\"name\":\"SQLCipher 4 defaults\",\"pageSize\":4096,\"kdfIterations\":256000,\"hmacAlgorithm\":\"HMAC_SHA512\",\"kdfAlgorithm\":\"PBKDF2_HMAC_SHA512\"}}"
]
}
}
}
Note: All fields in cipherProfile are optional - only specify the ones you want to override from the defaults. You can also specify cipherProfile in individual tool calls, but it's recommended to configure it once in the MCP server configuration for consistency.
Encrypted Passphrases
For enhanced security, you can store passphrases in encrypted form. The server uses AES-256-GCM encryption, which provides authenticated encryption and is both secure and fast.
macOS Keychain (Recommended for macOS)
-
Generate and store key in Keychain: Run:
./store-key-in-keychain.sh --generate -
Encrypt your passphrase: Run:
./encrypt-passphrase.sh "your-plain-passphrase"
The key is automatically loaded from the Keychain when no environment variable is set.
Benefits:
- Key is securely encrypted and stored by macOS
- No environment variables needed
- Automatic unlock with macOS user password
- Works system-wide for all applications
Environment Variable (Cross-Platform)
-
Generate an encryption key: Run:
java -cp build/libs/mcp-encrypted-sqlite-VERSION.jar com.example.mcp.sqlite.config.PassphraseEncryption -
Set the encryption key: Run:
export MCP_SQLITE_ENCRYPTION_KEY="<your-generated-key>" -
Encrypt your passphrase: Run:
java -cp build/libs/mcp-encrypted-sqlite-VERSION.jar com.example.mcp.sqlite.util.EncryptPassphrase "your-plain-passphrase"
Usage
Use the encrypted passphrase (with encrypted: prefix) in your configuration:
On macOS with Keychain (recommended):
{
"mcpServers": {
"encrypted-sqlite": {
"command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
"args": [
"--args",
"{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"encrypted:<encrypted-passphrase>\"}"
]
}
}
}
Note: No env section needed - the key is automatically loaded from macOS Keychain.
With environment variable (cross-platform):
{
"mcpServers": {
"encrypted-sqlite": {
"command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
"args": [
"--args",
"{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"encrypted:<encrypted-passphrase>\"}"
],
"env": {
"MCP_SQLITE_ENCRYPTION_KEY": "<your-encryption-key>"
}
}
}
}
Important Security Notes:
- The encryption key MUST be available (macOS Keychain or
MCP_SQLITE_ENCRYPTION_KEYenvironment variable) - The server automatically detects encrypted passphrases (starting with
encrypted:) and decrypts them - Use
PassphraseEncryption.generateKey()to generate strong keys (256 bits / 32 bytes) - AES-256-GCM provides authenticated encryption
- Weak keys are automatically rejected
Available Tools
list_tables
List all tables in the database. By default only table names, with include_columns=true also column details.
Parameters:
db_path(optional if configured): Path to the database filepassphrase(optional if configured): Database passphraseinclude_columns(optional, default: false): If true, column details are also returned
Example:
{
"name": "list_tables",
"arguments": {
"include_columns": true
}
}
get_table_data
Read data from a table with optional filtering, column selection, and pagination.
Parameters:
table(required): Table namecolumns(optional): Array of column names to selectfilters(optional): Object with column-value pairs for filteringlimit(optional, default: 200): Maximum number of rowsoffset(optional, default: 0): Offset for pagination
Example:
{
"name": "get_table_data",
"arguments": {
"table": "accounts",
"columns": ["id", "name", "balance"],
"filters": {"status": "active"},
"limit": 50,
"offset": 0
}
}
execute_sql
Execute arbitrary SQL statements (SELECT, INSERT, UPDATE, DELETE, DDL).
Security Warning: This tool executes raw SQL without parameterization. Only use with trusted SQL or ensure proper validation and sanitization is performed before calling this tool. For safer operations, use the other tools (get_table_data, insert_or_update, delete_rows) which use parameterized queries.
Parameters:
sql(required): SQL statement to execute
Example:
{
"name": "execute_sql",
"arguments": {
"sql": "SELECT COUNT(*) FROM transactions WHERE amount > 1000"
}
}
insert_or_update
Perform UPSERT operations (INSERT or UPDATE on conflict).
Parameters:
table(required): Table nameprimary_keys(required): Array of primary key column namesrows(required): Array of row objects to insert/update
Example:
{
"name": "insert_or_update",
"arguments": {
"table": "accounts",
"primary_keys": ["id"],
"rows": [
{"id": 1, "name": "Account 1", "balance": 1000.0},
{"id": 2, "name": "Account 2", "balance": 2000.0}
]
}
}
delete_rows
Delete rows from a table based on filters.
Parameters:
table(required): Table namefilters(required): Object with column-value pairs for filtering
Example:
{
"name": "delete_rows",
"arguments": {
"table": "transactions",
"filters": {"status": "cancelled"}
}
}
get_table_schema
Retrieves detailed schema information for a table (columns, indexes, foreign keys, constraints).
Parameters:
table(required): Table name
Example:
{
"name": "get_table_schema",
"arguments": {
"table": "accounts"
}
}
list_indexes
Lists all indexes of a table.
Parameters:
table(required): Table name
Example:
{
"name": "list_indexes",
"arguments": {
"table": "accounts"
}
}
Debug Mode
The server supports optional debug output via the MCP_DEBUG environment variable. When enabled, detailed debug information is written to stderr (not stdout, to comply with MCP protocol requirements).
Enable debug mode:
{
"mcpServers": {
"encrypted-sqlite": {
"command": "/path/to/mcp-encrypted-sqlite/build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite",
"args": [
"--args",
"{\"db_path\":\"/path/to/your/database.sqlite\",\"passphrase\":\"your-passphrase\"}"
],
"env": {
"MCP_DEBUG": "true"
}
}
}
}
Debug output includes:
- Server startup information (Java version, OS, arguments)
- Configuration parsing details
- Request processing information
- Response sizes and structures
- Database connection details
Note: Debug output is disabled by default to keep logs clean. Only enable it when troubleshooting issues.
Default Cipher Profile
The server uses SQLCipher 4 defaults by default:
cipher_page_size: 4096kdf_iter: 256000cipher_hmac_algorithm: HMAC_SHA512cipher_kdf_algorithm: PBKDF2_HMAC_SHA512cipher_use_hmac: ONcipher_plaintext_header_size: 0
These settings match the defaults used by tools like "DB Browser for SQLite" with SQLCipher 4.
Development
See DEVELOPMENT.md for development setup, building, testing, and project structure.
Security Considerations
General Security
- Passphrases: Passphrases are only stored in memory and never logged
- Encrypted Passphrases: Use encrypted passphrases with AES-256-GCM for storing passphrases in configuration files (see Encrypted Passphrases section)
- Memory: Note that decrypted passphrases remain in memory as Java Strings (immutable). For maximum security, consider using
char[]arrays, though this is not currently implemented. - Transport: Use secure transport channels (e.g., encrypted sessions) when accessing the server remotely
- File Permissions: Ensure database files have appropriate file system permissions
Security Best Practices
- Use encrypted passphrases with AES-256-GCM encryption
- Generate strong keys using
PassphraseEncryption.generateKey()(256 bits / 32 bytes) - Store encryption keys securely: Use macOS Keychain (recommended on macOS) or secure secret storage
- Never store both encryption key and encrypted passphrase in the same configuration file - Use wrapper scripts or environment variables to load the key securely (see DOCKER_CONFIGURATION.md for details)
- Rotate keys periodically - when rotating, re-encrypt all passphrases with the new key
- Use different keys for different environments (development, staging, production)
- Never commit keys or encrypted passphrases to version control
- Restrict file permissions on configuration files containing secrets (
chmod 600)
Troubleshooting
Debugging MCP Server Communication Issues
The MCP server includes extensive debugging features to help diagnose communication problems.
Viewing Logs
In MCP clients:
- Check your client's log output (e.g., Cursor: Output panel → "MCP Logs")
- All debug output is written to
stderr
Manual testing:
Run: ./build/install/mcp-encrypted-sqlite/bin/mcp-encrypted-sqlite --args '{"db_path":"/path/to/db.sqlite","passphrase":"secret"}' 2>&1 | tee mcp-debug.log
Common Communication Problems
1. Server does not start
- Symptom: No logs visible, server does not respond
- Debugging: Check startup logs:
- Java version is logged
- Arguments are logged
- Configuration parsing is logged
- Solution:
- Verify Java is correctly installed
- Check the MCP configuration (
mcp.json) - Check paths in
commandandargsfields
2. JSON Parsing Errors
- Symptom: "Parse error" in logs
- Debugging: The server logs:
- First 500 characters of received JSON
- Exact exception with stack trace
- Solution:
- Check JSON structure in MCP configuration
- Ensure JSON is properly escaped
- Verify all required fields are present
3. Missing or Incorrect Responses
- Symptom: Requests are not answered or timeouts occur
- Debugging: The server logs:
- Each received request with ID and method
- Response size and status
- Flush status after writing
- Solution:
- Check if
STDOUTis available (logged at startup) - Check response size (very large responses can cause problems)
- Verify flush was successful
- Check if
4. Invalid Requests
- Symptom: "Invalid Request" errors
- Debugging: The server logs:
- Missing fields (e.g.,
method,id) - JSON-RPC version mismatches
- Invalid parameters
- Missing fields (e.g.,
- Solution:
- Ensure all requests comply with JSON-RPC 2.0 standard
- Verify
methodandidfields are present - Check parameter structure
5. Database Connection Problems
- Symptom: "Database error" errors
- Debugging: The server logs:
- Used DB paths (Default vs. Override)
- Passphrase status (encrypted/decrypted)
- CipherProfile configuration
- Solution:
- Check DB path in logs
- Verify passphrase was correctly decrypted
- Check CipherProfile settings
Debugging Features in Detail
The server automatically logs:
-
Startup Information:
- Java version and Java Home
- Operating system information
- Number and content of arguments
- Configuration parsing status
-
Request Processing:
- Each received request with number and length
- JSON-RPC validation
- Method calls with parameters
- Response size and status
-
Error Handling:
- Detailed exception information with stack traces
- JSON-RPC error codes according to specification
- Error responses with additional debug data
-
Database Operations:
- Used configurations (Default vs. Override)
- SQL queries (first 100 characters)
- Result sizes and affected rows
Database cannot be opened
- Verify the passphrase is correct
- Check that the database uses SQLCipher 4 defaults (or configure a custom cipher profile)
- Ensure the database file path is correct and accessible
- Check logs: The server logs detailed information about passphrase decryption and DB path
Connection issues
- Verify Java is installed:
java -version - Check that
JAVA_HOMEis set correctly in the MCP configuration - Review your MCP client logs for detailed error messages
FTS (Full-Text Search) tables
The server automatically handles FTS virtual tables that may not have accessible metadata. These tables will appear with empty column lists.
License
Licensed under the Apache License, Version 2.0. See LICENSE for details.
Third-Party Licenses
- sqlite-jdbc-crypt (Apache License 2.0) - SQLite JDBC driver with encryption support
- Gson (Apache License 2.0) - JSON library for Java
- Source: https://github.com/google/gson
- JUnit Jupiter (Eclipse Public License 2.0) - Testing framework
- Source: https://junit.org/junit5/
See NOTICE for detailed attribution information.
Acknowledgments
- sqlite-jdbc-crypt - SQLite JDBC driver with encryption support
- Model Context Protocol - MCP specification
Contributing
Contributions are welcome! Please feel free to submit a Pull Request. See CONTRIBUTING.md for guidelines.
Support
For issues, questions, or contributions, please open an issue on GitHub.
Buy me a coffee
Like this integration? Feel free to buy me a coffee! Your support helps me continue working on cool features.
sqlite MCP questions
How do I add sqlite MCP to Claude Code?
Run claude mcp add --env 'DB_PASSPHRASE=<YOUR_DB_PASSPHRASE>' --env 'DB_PATH=<DB_PATH>' mcp-sqlite -- docker run -i --rm ghcr.io/rosch100/mcp-sqlite:0.2.4 in your terminal. Add --scope user to make it available in every project.
How do I add sqlite MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does sqlite MCP provide?
It exposes 11 tools, including db_path, passphrase, include_columns, table, columns.
Which applications use encrypted SQLite databases that this server can access?
It works with databases from MoneyMoney, 1Password, Signal, WhatsApp, Firefox, Telegram, KeePass, and other SQLCipher-based apps.
Can I use this server to read databases that are currently locked by another application?
Yes, by setting the 'immutable' parameter to true, you can open the database in a way that avoids file locks, though write operations will be disabled.
How can I securely handle database passphrases?
You can use AES-256-GCM encrypted passphrases with macOS Keychain integration or provide an encryption key via the MCP_SQLITE_ENCRYPTION_KEY environment variable.