by niledatabase
Provides a Model Context Protocol interface that lets LLM applications create, list, query, and manage Nile databases, credentials, tenants, and SQL execution through a type‑safe TypeScript server.
The server implements a standardized protocol for interacting with the Nile database platform. It exposes operations such as database lifecycle management, credential handling, region discovery, tenant administration, and direct SQL execution, all callable from LLM environments like Claude Desktop or Cursor.
npm install @niledatabase/nile-mcp-server
.env file at the project root with your Nile credentials:
NILE_API_KEY=your_api_key
NILE_WORKSPACE_SLUG=your_workspace_slug
npm run build
node dist/index.js
npm run dev.MCP_SERVER_MODE=sse in .env; the server will listen on port 3000.Q: Which environment variables are required?
A: NILE_API_KEY and NILE_WORKSPACE_SLUG. Optionally MCP_SERVER_MODE (stdio or sse).
Q: How do I choose the communication mode?
A: STDIO is the default and works with Claude Desktop and Cursor. Set MCP_SERVER_MODE=sse to run an HTTP SSE endpoint on port 3000.
Q: Can I use an existing connection string?
A: Yes, the execute-sql tool accepts an optional connectionString parameter to bypass automatic credential creation.
Q: What regions are available for database creation?
A: Currently AWS_US_WEST_2 (Oregon) and AWS_EU_CENTRAL_1 (Frankfurt). Use the list-regions tool to retrieve the list.
Q: How are errors presented? A: Errors include HTTP‑style status codes, descriptive messages, and actionable hints (e.g., missing parameters, invalid credentials, SQL syntax issues).
Q: Is there a CLI shortcut to launch the server?
A: You can run the package directly with npx (see serverConfig below).
A Model Context Protocol (MCP) server implementation for Nile database platform. This server allows LLM applications to interact with Nile platform through a standardized interface.
Install the stable version:
npm install @niledatabase/nile-mcp-server
For the latest alpha/preview version:
npm install @niledatabase/nile-mcp-server@alpha
This will install @niledatabase/nile-mcp-server in your node_modules folder. For example: node_modules/@niledatabase/nile-mcp-server/dist/
# Clone the repository
git clone https://github.com/yourusername/nile-mcp-server.git
cd nile-mcp-server
# Install dependencies
npm install
# Build the project
npm run build
There are several ways to start the server:
node dist/index.js
npm run dev
The server will start and listen for MCP protocol messages. You should see startup logs indicating:
To stop the server, press Ctrl+C.
When the server starts successfully, you should see logs similar to:
[info] Starting Nile MCP Server...
[info] Loading environment variables...
[info] Environment variables loaded successfully
[info] Creating server instance...
[info] Tools initialized successfully
[info] Setting up stdio transport...
[info] Server started successfully
If you see these logs, the server is ready to accept commands from Claude Desktop.
Create a .env file in the root directory with your Nile credentials:
NILE_API_KEY=your_api_key_here
NILE_WORKSPACE_SLUG=your_workspace_slug
To create a Nile API key, log in to your Nile account, click Workspaces in the top-left, select your workspace, and navigate to the Security section in the left menu.
npm run build
{
"mcpServers": {
"nile-database": {
"command": "node",
"args": [
"/path/to/your/nile-mcp-server/dist/index.js"
],
"env": {
"NILE_API_KEY": "your_api_key_here",
"NILE_WORKSPACE_SLUG": "your_workspace_slug"
}
}
}
}
Replace:
/path/to/your/nile-mcp-server with the absolute path to your project directoryyour_api_key_here with your Nile API keyyour_workspace_slug with your Nile workspace slugnpm run build
nile-database (or any name you prefer)env NILE_API_KEY=your_key NILE_WORKSPACE_SLUG=your_workspace node /absolute/path/to/nile-mcp-server/dist/index.js
Replace:
your_key with your Nile API keyyour_workspace with your Nile workspace slug/absolute/path/to with the actual path to your projectThe server supports two operational modes:
The default mode uses standard input/output for communication, making it compatible with Claude Desktop and Cursor integrations.
Server-Sent Events (SSE) mode enables real-time, event-driven communication over HTTP.
To enable SSE mode:
MCP_SERVER_MODE=sse in your .env filehttp://localhost:3000/ssehttp://localhost:3000/messagesExample SSE usage with curl:
# In terminal 1 - Listen for events
curl -N http://localhost:3000/sse
# In terminal 2 - Send commands
curl -X POST http://localhost:3000/messages \
-H "Content-Type: application/json" \
-d '{
"type": "function",
"name": "list-databases",
"parameters": {}
}'
After setting up the MCP server in Cursor, you can use natural language to interact with Nile databases. Here are some example prompts:
Create a new database named "my_app" in AWS_US_WEST_2 region
List all my databases
Get details for database "my_app"
Delete database "test_db"
Create a users table in my_app database with columns:
- tenant_id (UUID, references tenants)
- id (INTEGER)
- email (VARCHAR, unique per tenant)
- name (VARCHAR)
- created_at (TIMESTAMP)
Create a products table in my_app database with columns:
- tenant_id (UUID, references tenants)
- id (INTEGER)
- name (VARCHAR)
- price (DECIMAL)
- description (TEXT)
- created_at (TIMESTAMP)
Execute this query on my_app database:
SELECT * FROM users WHERE tenant_id = 'your-tenant-id' LIMIT 5
Run this query on my_app:
INSERT INTO users (tenant_id, id, email, name)
VALUES ('tenant-id', 1, 'user@example.com', 'John Doe')
Show me all products in my_app database with price > 100
Show me the schema for the users table in my_app database
Add a new column 'status' to the users table in my_app database
Create an index on the email column of the users table in my_app
The server provides the following tools for interacting with Nile databases:
create-database
name (string): Name of the databaseregion (string): Either AWS_US_WEST_2 (Oregon) or AWS_EU_CENTRAL_1 (Frankfurt)list-databases
get-database
name (string): Name of the databasedelete-database
name (string): Name of the database to deletelist-credentials
databaseName (string): Name of the databasecreate-credential
databaseName (string): Name of the databasedatabaseName (string): Name of the database to queryquery (string): SQL query to executeconnectionString (string, optional): Pre-existing connection string to use for the queryread-resource
databaseName (string): Name of the databaseresourceName (string): Name of the resource (table/view)list-resources
databaseName (string): Name of the databaselist-tenants
databaseName (string): Name of the databasecreate-tenant
databaseName (string): Name of the databasetenantName (string): Name for the new tenantdelete-tenant
databaseName (string): Name of the databasetenantName (string): Name for the tenantHere are some example commands you can use in Claude Desktop:
# Database Management
Please create a new database named "my-app" in the AWS_US_WEST_2 region.
Can you list all my databases?
Get the details for database "my-app".
Delete the database named "test-db".
# Connection String Management
Get a connection string for database "my-app".
# Connection string format: postgres://<user>:<password>@<region>.db.thenile.dev:5432/<database>
# Example: postgres://cred-123:password@us-west-2.db.thenile.dev:5432/my-app
# SQL Queries
Execute SELECT * FROM users LIMIT 5 on database "my-app"
Run this query on my-app database: SELECT COUNT(*) FROM orders WHERE status = 'completed'
Using connection string "postgres://user:pass@host:5432/db", execute this query on my-app: SELECT * FROM products WHERE price > 100
All tools return responses in a standardized format:
The server handles various error scenarios:
If Claude says it can't access the tools:
npm run build)If database creation fails:
If credential operations fail:
nile-mcp-server/
├── src/
│ ├── server.ts # MCP server implementation
│ ├── tools.ts # Tool implementations
│ ├── types.ts # Type definitions
│ ├── logger.ts # Logging utilities
│ ├── index.ts # Entry point
│ └── __tests__/ # Test files
│ └── server.test.ts
├── dist/ # Compiled JavaScript
├── logs/ # Log files directory
├── .env # Environment configuration
├── .gitignore # Git ignore file
├── package.json # Project dependencies
└── tsconfig.json # TypeScript configuration
server.ts: Main server implementation with tool registration and transport handlingtools.ts: Implementation of all database operations and SQL query executiontypes.ts: TypeScript interfaces for database operations and responseslogger.ts: Structured logging with daily rotation and debug supportindex.ts: Server startup and environment configurationserver.test.ts: Comprehensive test suite for all functionality# Install dependencies
npm install
# Build the project
npm run build
# Start the server in production mode
node dist/index.js
# Start the server using npm script
npm start
# Start in development mode with auto-rebuild
npm run dev
# Run tests
npm test
The following npm scripts are available:
npm run build: Compiles TypeScript to JavaScriptnpm start: Starts the server in production modenpm run dev: Starts the server in development mode with auto-rebuildnpm test: Runs the test suitenpm run lint: Runs ESLint for code quality checkingnpm run clean: Removes build artifactsThe project includes a comprehensive test suite that covers:
Run the tests with:
npm test
The server uses structured logging with the following features:
MIT License - See LICENSE for details.
Please log in to share your review and rating for this MCP.
{
"mcpServers": {
"nile-mcp-server": {
"command": "npx",
"args": [
"-y",
"@niledatabase/nile-mcp-server"
],
"env": {
"NILE_API_KEY": "<YOUR_API_KEY>",
"NILE_WORKSPACE_SLUG": "<YOUR_WORKSPACE_SLUG>"
}
}
}
}claude mcp add nile-mcp-server npx -y @niledatabase/nile-mcp-serverExplore related MCPs that share similar capabilities and solve comparable challenges
by googleapis
An MCP server that streamlines database tool development by handling connection pooling, authentication, observability, and secure access, allowing agents to interact with databases via natural language.
by bytebase
Provides a universal gateway that lets MCP‑compatible clients explore and query MySQL, PostgreSQL, SQL Server, MariaDB, and SQLite databases through a single standardized interface.
by designcomputer
Enables secure interaction with MySQL databases via the Model Context Protocol, allowing AI applications to list tables, read contents, and execute queries safely.
by benborla
Provides read‑only access to MySQL databases for large language models, allowing schema inspection and safe execution of SQL queries.
by neo4j-contrib
Enables natural‑language interaction with Neo4j databases, allowing large language models to query, modify, and manage graph data through multiple transport modes.
by mongodb-js
Provides a Model Context Protocol server that enables interaction with MongoDB databases and MongoDB Atlas clusters through a unified API.
by ClickHouse
Enables AI assistants to run read‑only ClickHouse queries, list databases and tables, and execute embedded chDB queries through an MCP interface.
by neondatabase
Interact with Neon Postgres databases using natural language commands through the Model Context Protocol, enabling conversational database creation, migration, and query execution.
by motherduckdb
Enables SQL analytics on DuckDB and MotherDuck databases via a Model Context Protocol server, allowing AI assistants and IDEs to query data directly.