SQLite-Anet-MCP Server

A Rust implementation of the Model Control Protocol (MCP) server that provides SQLite database capabilities via a standardized protocol. This server enables AI agents to create, manage, and query SQLite databases directly.

This project is based on the Model Context Protocol SQLite Server reference implementation.

Features

• 🗃️ Create and manage SQLite database tables
• 🔍 Execute SELECT queries for data retrieval
• ✏️ Execute INSERT, UPDATE, and DELETE queries for data manipulation
• 📊 Describe table schemas and list available tables
• 📝 Save and synthesize business insights from data
• 🔄 NATS transport layer for message passing
• 🛠️ JSON-RPC 2.0 compatible API
• ⚡ Asynchronous request handling with Tokio

Requirements

• Rust 1.70+
• NATS server running locally or accessible via network
• SQLite (included as a Rust dependency)

Installation

Clone the repository and build the server:

git clone https://github.com/yourusername/sqlite-anet-mcp.git
cd sqlite-anet-mcp

Configure your environment in a .env file:

NATS_URL=nats://localhost:4222
MCP_SUBJECT=mcp.requests
SQLITE_DB_PATH=./data/sqlite.db
RUST_LOG=debug

Getting Started

Running the Server

# Start a NATS server in another terminal or ensure one is already running
# Example:
nats-server

# Run the SQLite MCP server
cargo run

Testing the Server

You can test the server using the included test client:

cargo run --example test_client

This will set up a basic customer database and demonstrate the server's capabilities.

Chinook Database Test

To run the Chinook database test example:

cargo run --example chinook_test

Note: Before running the Chinook test, you need to:

1. Download the Chinook SQLite database from: https://www.sqlitetutorial.net/sqlite-sample-database/
2. Place the chinook.db file in the ./data/ directory
3. Set SQLITE_DB_PATH=./data/chinook.db in your .env file or when running the example

Available Tools

1. list_tables

List all tables in the SQLite database.

Example:

{
  "name": "list_tables",
  "arguments": {}
}

2. describe_table

Get the schema information for a specific table.

Parameters:

• table_name (required): Name of the table to describe

Example:

{
  "name": "describe_table",
  "arguments": {
    "table_name": "customers"
  }
}

3. create_table

Create a new table in the SQLite database.

Parameters:

• query (required): CREATE TABLE SQL statement

Example:

{
  "name": "create_table",
  "arguments": {
    "query": "CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT, email TEXT, join_date TEXT)"
  }
}

4. read_query

Execute a SELECT query on the SQLite database.

Parameters:

• query (required): SELECT SQL query to execute

Example:

{
  "name": "read_query",
  "arguments": {
    "query": "SELECT * FROM customers WHERE join_date > '2023-01-01'"
  }
}

5. write_query

Execute an INSERT, UPDATE, or DELETE query on the SQLite database.

Parameters:

• query (required): SQL query to execute (must be INSERT, UPDATE, or DELETE)

Example:

{
  "name": "write_query",
  "arguments": {
    "query": "INSERT INTO customers (name, email, join_date) VALUES ('John Doe', 'john@example.com', '2023-01-15')"
  }
}

6. append_insight

Add a business insight to the memo.

Parameters:

• insight (required): Business insight discovered from data analysis

Example:

{
  "name": "append_insight",
  "arguments": {
    "insight": "Customer acquisition is stable and growing over time."
  }
}

Available Resources

Business Insights Memo

A living document of discovered business insights.

URI: memo://insights

Example:

{
  "method": "readResource",
  "params": {
    "uri": "memo://insights"
  }
}

Available Prompts

MCP Demo

A prompt to seed the database with initial data and demonstrate what you can do with an SQLite MCP Server + Claude.

Arguments:

• topic (required): Topic to seed the database with initial data

Example:

{
  "method": "getPrompt",
  "params": {
    "name": "mcp-demo",
    "arguments": {
      "topic": "coffee shop sales"
    }
  }
}

Architecture

The server follows a modular design:

• tools – SQLite database operations implementations
• models – SQLite query and response structures
• prompts – Interactive demo templates
• resources – Business insights memo generation
• sqlite – Core database functionality

Development

Adding New Features

To extend the server with additional SQLite capabilities:

1. Define response structures in src/models/sqlite.rs
2. Implement the tool in src/tools/ following the Tool trait
3. Register the tool in src/main.rs

Troubleshooting

• Ensure the NATS server is running and accessible
• Check that the SQLite database path is correctly set
• Verify the request format matches the expected input schema for each tool

License

MIT License

Acknowledgements

This project is built on top of the Anet MCP Server framework and is based on the Model Context Protocol SQLite Server reference implementation.