Vertica MCP Server
Transform your Vertica Analytics Database into an AI-powered intelligence layer
Power your agent
Instal dari penerbit. Bukan endpoint PlugMCP.
URL remote atau perintah di mesin Anda? Perbedaan kedua cara instal
Jalankan di PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
BukaDari penerbit
Vertica MCP is a production-ready server that connects AI assistants to Vertica through the Model Context Protocol (MCP). It enables secure, high-performance query execution, schema exploration, and performance insights with support for STDIO, HTTP, and Docker.
The Vertica MCP Server is a production-ready implementation of the Model Context Protocol that transforms your Vertica Analytics Database into an intelligent, AI-accessible data platform. Built with enterprise security and performance in mind, it enables AI assistants like Claude, ChatGPT, and Cursor to directly query, analyze, and optimize your Vertica databases through natural language.
The Model Context Protocol (MCP) is an open standard developed by Anthropic that provides a universal way for AI assistants to connect with external tools and data sources. Think of it as "USB-C for AI" - a standardized interface that allows any MCP-compatible AI to interact with your systems without custom integrations.
If you want to configure Claude Desktop or Cursor to connect to your Vertica Database instantly, we've provided an automated setup script. This works whether you installed from source or via PyPI (pip).
Option A: If you cloned the repository (Source/uv)
cd vertica-mcp
python setup_clients.py
Option B: If you installed via PyPI (pip)
# 1. Download the setup script
curl -O https://raw.githubusercontent.com/zaboura/vertica-mcp/master/setup_clients.py
# 2. Run the interactive setup script
python setup_clients.py
The script will ask how you installed the server, prompt you for your Vertica credentials, generate your .env file, and automatically configure Claude Desktop and Cursor. Simply restart your AI assistant and you're good to go!
# 1. Clone the repository
git clone https://github.com/zaboura/vertica-mcp.git
cd vertica-mcp
# 2. Install uv (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh
# 3. Setup environment and install dependencies
uv sync
source .venv/bin/activate
# 4. Install in development mode
uv pip install -e .
# 5. Configure database connection
cp .env.example .env
# Edit .env with your Vertica credentials
# 6. Run the server
vertica-mcp --transport http --port 8000 --bind-host 0.0.0.0 # HTTP for remote access
This method is recommended for production deployments and when you want to use the stable release.
# 1. Install from PyPI
pip install vertica-mcp
# 2. Initialize configuration
vertica-mcp --init
# 3. Edit configuration with your credentials
nano .env # or use your preferred editor
# Update VERTICA_HOST, VERTICA_USER, VERTICA_PASSWORD, etc.
# 4. Test the installation
vertica-mcp --transport http --port 8000 # For HTTP access
After running vertica-mcp --init, edit the generated .env file with your specific settings:
# Required Database Connection
VERTICA_HOST=your_vertica_host
VERTICA_PORT=5433
VERTICA_DATABASE=your_database
VERTICA_USER=your_username
VERTICA_PASSWORD=your_password
# Connection Pool Configuration
VERTICA_CONNECTION_LIMIT=10
VERTICA_LAZY_INIT=1
# SSL Configuration (optional but recommended for production)
VERTICA_SSL=false
VERTICA_SSL_REJECT_UNAUTHORIZED=true
# Performance and Resource Management
VERTICA_QUERY_TIMEOUT=600 # Query timeout in seconds
VERTICA_MAX_RETRIES=3 # Max retry attempts
VERTICA_RETRY_DELAY=0.1 # Base delay for retries
VERTICA_CACHE_TTL=300 # Cache TTL in seconds
VERTICA_MAX_RESULT_MB=100 # Max result size in MB
VERTICA_RATE_LIMIT=60 # Requests per minute
VERTICA_HEALTH_CHECK_INTERVAL=60 # Health check interval
# Security Permissions (defaults to read-only for safety)
ALLOW_INSERT_OPERATION=false
ALLOW_UPDATE_OPERATION=false
ALLOW_DELETE_OPERATION=false
ALLOW_DDL_OPERATION=false
# Schema-specific Permissions (optional for granular control)
SCHEMA_INSERT_PERMISSIONS=staging:true,production:false
SCHEMA_UPDATE_PERMISSIONS=staging:true,production:false
SCHEMA_DELETE_PERMISSIONS=staging:false,production:false
SCHEMA_DDL_PERMISSIONS=staging:false,production:false
The MCP Inspector is a valuable tool for testing and debugging your server configuration:
# 1. Install MCP Inspector
npm install -g @modelcontextprotocol/inspector
# 2. Start your server in one terminal
vertica-mcp --transport http --port 8000
# 3. Test with inspector in another terminal
mcp-inspector http://localhost:8000/mcp
The inspector will open at http://localhost:6274 where you can:
For STDIO testing (not recommended due to command complexity), use HTTP transport which provides identical functionality validation with better debugging capabilities.
Docker deployment is ideal for containerized environments and consistent deployments across different systems.
# Build directly from Dockerfile
docker build -t vertica-mcp:latest .
# Or build via Compose (recommended)
docker compose build
Compose automatically reads a .env file if present.
Vertica credentials and configuration are loaded from .env, while network binding and transport options
have Docker-safe defaults (HTTP_BIND=0.0.0.0, SSE_BIND=0.0.0.0).
# STDIO transport (for direct MCP client connection)
docker compose up mcp-stdio
# HTTP transport (for web-based access)
docker compose up mcp-http
# SSE transport (for real-time streaming)
docker compose up mcp-sse
By default, .env sets BIND=127.0.0.1 (localhost) for safety.
The Compose file defines service-specific bind variables:
HTTP_BIND=${HTTP_BIND:-0.0.0.0}
SSE_BIND=${SSE_BIND:-0.0.0.0}
You can override the bind or port at runtime:
# Linux/macOS
HTTP_BIND=127.0.0.1 docker compose up mcp-http
# Windows PowerShell
$env:HTTP_BIND="127.0.0.1"; docker compose up mcp-http
To skip Vertica credential checks (for demo or offline runs):
SKIP_DB_CHECK=1 docker compose up mcp-http
# HTTP transport with port mapping
docker run -d \
--name vertica-mcp-http \
-p 8000:8000 \
--env-file .env \
-e TRANSPORT=http \
-e BIND=0.0.0.0 \
-e PORT=8000 \
-e HTTP_PATH=/mcp \
vertica-mcp:latest
# STDIO transport (direct MCP client connection)
docker run -i --rm \
--name vertica-mcp-stdio \
--env-file .env \
vertica-mcp:latest
run_query_safely - Smart query execution with large result detection and automatic warningsexecute_query_paginated - Efficient pagination for large datasets with configurable page sizesexecute_query_stream - Real-time streaming for massive results with memory-efficient processingget_database_schemas - Explore database organization and available schemasget_schema_tables - List tables with metadata including row counts and storage informationget_table_structure - Detailed column information, data types, constraints, and indexesget_table_projections - Vertica-specific projection analysis and optimization recommendationsget_schema_views - List all views in a schema with their definitionsprofile_query - Query execution plans, performance metrics, and optimization suggestionsanalyze_system_performance - Real-time resource monitoring and system health metricsdatabase_status - Comprehensive health metrics including storage usage and connection statistics# Database Connection (Required)
VERTICA_HOST=your_vertica_host
VERTICA_PORT=5433
VERTICA_DATABASE=your_database
VERTICA_USER=your_username
VERTICA_PASSWORD=your_password
# Connection Pool Configuration (Optional)
VERTICA_CONNECTION_LIMIT=10
VERTICA_LAZY_INIT=1 # Delay connection until first use
# SSL Configuration (Optional but recommended for production)
VERTICA_SSL=false
VERTICA_SSL_REJECT_UNAUTHORIZED=true
# Security Permissions (Optional - defaults to read-only for safety)
ALLOW_INSERT_OPERATION=false
ALLOW_UPDATE_OPERATION=false
ALLOW_DELETE_OPERATION=false
ALLOW_DDL_OPERATION=false
# Schema-specific Permissions (Optional for granular control)
SCHEMA_INSERT_PERMISSIONS=staging:true,production:false
SCHEMA_UPDATE_PERMISSIONS=staging:true,production:false
SCHEMA_DELETE_PERMISSIONS=staging:false,production:false
SCHEMA_DDL_PERMISSIONS=staging:false,production:false
This is the best practice approach using a dedicated Python virtual environment and the installed package for maximum stability and isolation.
To install the package and create/configure your .env, follow Method 2: PyPI Installation above.
Locate the Claude configuration file
%APPDATA%/Claude/claude_desktop_config.json~/Library/Application Support/Claude/claude_desktop_config.jsonConfigure Claude to use your virtual environment executable and configuration
command path with your virtual environment path--transport stdio and --env-file with absolute path for reliabilityWindows Configuration Example
{
"mcpServers": {
"vertica-mcp-stdio": {
"command": "C:\\path-to-venv\\Scripts\\vertica-mcp.exe",
"args": ["--transport", "stdio", "--env-file", "C:\\path\\to\\.env"]
}
}
}
macOS/Linux Configuration Example
{
"mcpServers": {
"vertica-mcp-stdio": {
"command": "/Users/you/.venvs/vertica-mcp/bin/vertica-mcp",
"args": ["--transport", "stdio", "--env-file", "/absolute/path/to/.env"]
}
}
}
Verification Test (outside Claude)
Test your configuration before integrating with Claude:
# Windows
C:\venv\vertica-mcp\Scripts\vertica-mcp.exe --transport stdio --env-file C:\path\to\.env -vvv
# macOS/Linux
~/.venv/vertica-mcp/bin/vertica-mcp --transport stdio --env-file /absolute/path/to/.env -vvv
Important Configuration Notes
--transport stdio runs the server over STDIO (no network ports required)--env-file ensures your credentials load correctly even if Claude's working directory differsYou can also run the server using Python's -m flag (now supported with __main__.py):
{
"mcpServers": {
"vertica-mcp-stdio": {
"command": "python",
"args": ["-m", "vertica_mcp", "--transport", "stdio"],
"cwd": "/path/to/vertica-mcp",
"env": {
"VERTICA_HOST": "your_host",
"VERTICA_PORT": "5433",
"VERTICA_DATABASE": "your_database",
"VERTICA_USER": "your_username",
"VERTICA_PASSWORD": "your_password"
}
}
}
}
Or using .env file:
{
"mcpServers": {
"vertica-mcp-stdio": {
"command": "python",
"args": ["-m", "vertica_mcp", "--transport", "stdio", "--env-file", "/absolute/path/to/.env"]
}
}
}
This option is suitable for development when you want to work with the source code directly:
{
"mcpServers": {
"vertica-mcp-stdio": {
"command": "uv",
"args": ["run", "vertica-mcp"],
"cwd": "/path/to/vertica-mcp",
"env": {
"VERTICA_HOST": "your_host",
"VERTICA_PORT": "5433",
"VERTICA_DATABASE": "your_database",
"VERTICA_USER": "your_username",
"VERTICA_PASSWORD": "your_password"
}
}
}
}
Option A — Docker Compose (recommended for containerized environments)
{
"mcpServers": {
"vertica-mcp-stdio": {
"command": "docker",
"args": ["compose",
"-f",
"/path/to/vertica-mcp/docker-compose.yml",
"run",
"--rm",
"-T",
"mcp-stdio"]
}
}
}
Option B — Direct docker run command
{
"mcpServers": {
"vertica-mcp-stdio": {
"command": "docker",
"args": ["run",
"-i",
"--rm",
"--env-file",
"/path/to/vertica-mcp/.env",
"vertica-mcp:latest"]
}
}
}
mcp-remoteFor remote deployments or when you prefer HTTP-based communication:
{
"mcpServers": {
"vertica-mcp-http": {
"command": "npx",
"args": ["-y", "mcp-remote", "http://localhost:8000/mcp"]
}
}
}
{
"mcpServers": {
"vertica-mcp-sse": {
"command": "npx",
"args": ["-y", "mcp-remote", "http://localhost:8000/sse"]
}
}
}
6. **Final Step: Restart Claude Desktop**
After configuring, completely restart Claude Desktop and look for the (+) indicator which shows that the MCP server is connected and ready to use.
</details>
<details>
<summary><b>VS Code Integration</b></summary>
1. **Install GitHub Copilot Chat Extension**
Ensure you have the latest version of the GitHub Copilot Chat extension installed in VS Code.
2. **Create MCP Configuration File**
Create `.vscode/mcp.json` in your workspace root:
```json
{
"servers": {
"vertica-mcp": {
"type": "http",
"url": "http://localhost:8000/mcp"
}
}
}
{
"chat.mcp.enabled": true,
"chat.mcp.discovery.enabled": true
}
mcp.json in your Cursor configuration directory:
~/.cursor/mcp.json (macOS/Linux) or %UserProfile%\.cursor\mcp.json (Windows)<project>/.cursor/mcp.json{
"mcpServers": {
"vertica-mcp": {
"command": "npx",
"args": ["-y", "mcp-remote", "http://localhost:8000/mcp"]
}
}
}
vertica-mcp [OPTIONS]
Basic Database Operations
"Show me all tables in the public schema"
"What's the structure of the customers table?"
"Get the last 100 orders from today"
"List all projections for the orders table"
"Get database status and health metrics"
Performance Analysis and Monitoring
"Profile this query and suggest optimizations"
"Show system performance for the last hour"
"Find tables with high ROS container counts"
"Analyze the performance of this query: SELECT * FROM sales.orders WHERE order_date > '2024-01-01'"
"Monitor system performance for the last 30 minutes"
Complex Analytics Queries
"Analyze sales trends by region and product"
"Find anomalies in transaction patterns"
"Generate a monthly revenue report"
"Execute this query safely: SELECT COUNT(*) FROM large_table"
Database Management Tasks
"Check database health and storage usage"
"Monitor resource pool utilization"
"Identify and fix slow queries"
"Show me the current resource pool utilization"
Verify your database connection and server configuration with this simple test:
# Test database connection
python -c "
import os
from dotenv import load_dotenv
load_dotenv()
from vertica_mcp.connection import VerticaConfig, VerticaConnectionManager
config = VerticaConfig.from_env()
manager = VerticaConnectionManager()
manager.initialize_default(config)
conn = manager.get_connection()
cursor = conn.cursor()
cursor.execute('SELECT version()')
print('Connected successfully to:', cursor.fetchone()[0])
manager.release_connection(conn)
"
The MCP Inspector provides comprehensive testing and validation capabilities:
# Install MCP Inspector
npm install -g @modelcontextprotocol/inspector
# Test local STDIO server
npx @modelcontextprotocol/inspector vertica_mcp/server.py
# Test HTTP server
npx @modelcontextprotocol/inspector http://localhost:8000/mcp
MCP Inspector Configuration:
Set the Transport Type to match your server configuration:
STDIO Transport Testing
uvrun --with mcp --with starlette --with uvicorn --with pydantic --with vertica-python mcp run vertica_mcp/server.pySSE Transport Testing
http://localhost:8000/sseHTTP Transport Testing
http://localhost:8000/mcpTest your HTTP server endpoints directly with curl commands:
# Test tools list endpoint
curl -s http://localhost:8000/mcp \
-H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
# Test server initialization
curl -s http://localhost:8000/mcp \
-H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"0.1.0","capabilities":{},"clientInfo":{"name":"test","version":"1.0.0"}}}'
The server automatically profiles queries and provides comprehensive optimization recommendations:
Automatic Query Analysis:
Example Usage:
# Automatic query optimization with detailed feedback
"Profile and optimize: SELECT * FROM large_table JOIN dimension_table"
# Returns: Execution plan, identified bottlenecks, and CREATE PROJECTION statements
Key Features:
Ensure your production deployment meets enterprise standards:
Security Configuration:
Monitoring and Maintenance:
Performance Optimization:
The Vertica MCP Server implements a comprehensive three-tier permission system:
Database Access Security:
Network and Infrastructure Security:
Operational Security:
Test Basic Connectivity:
# Test network connectivity to Vertica server
telnet your_vertica_host 5433
# Test database credentials and permissions
vsql -h your_host -U your_user -d your_database
Common Connection Issues:
Troubleshooting Steps:
-vvv verbose flagCommon Configuration Problems:
Container Troubleshooting:
# Check container logs for errors
docker logs vertica-mcp
# Test container internal connectivity
docker exec -it vertica-mcp curl http://localhost:8000/mcp
# Verify environment variable loading
docker exec -it vertica-mcp env | grep VERTICA
Common Docker Issues:
Enable Maximum Verbosity:
# Maximum verbosity for troubleshooting
vertica-mcp --transport http -vvv
# Log output to file for analysis
vertica-mcp --transport http -vv 2> debug.log
Log Analysis Tips:
vertica-mcp/
├── vertica_mcp/ # Python package source code
│ ├── __init__.py # Package initialization
│ ├── cli.py # Command-line interface implementation
│ ├── server.py # Main MCP server implementation
│ ├── connection.py # Database connection management
│ └── utils.py # Utility functions and helpers
│
├── pyproject.toml # Build configuration and metadata (PEP 621)
├── README.md # Project documentation
├── CHANGELOG.md # Release notes and version history
├── LICENSE # MIT license with attribution
├── .gitignore # Git ignore rules
├── .dockerignore # Docker ignore rules
├── .env.example # Sample environment file (do NOT commit .env)
│
├── docker-compose.yml # Docker Compose configuration
├── docker-entrypoint.sh # Docker container entry script
└── dockerfile # Docker image definition
We welcome and encourage contributions from the community! Please see our Contributing Guide for detailed information on how to get involved.
Set up your local development environment with these steps:
# Clone and setup development environment
git clone https://github.com/zaboura/vertica-mcp.git
cd vertica-mcp
uv sync
# Install development dependencies including testing and linting tools
uv pip install -e ".[dev]"
# Run comprehensive test suite
pytest tests/
# Code formatting and style checks
black vertica_mcp/
isort vertica_mcp/
# Type checking and static analysis
mypy vertica_mcp/
When implementing new tools, follow these guidelines:
server.py with proper @mcp.tool() decorator and comprehensive docstringsGetting Started with Contributions:
maingit checkout -b feature/AmazingFeaturegit commit -m 'Add some AmazingFeature'git push origin feature/AmazingFeatureCode Quality Standards:
When seeking help or contributing:
Understanding MCP:
Vertica Integration:
AI and Database Integration:
Bug Fixes:
_extract_client_id_from_auth() helper to extract client ID from API keyrun_query_safely() now works correctly with HTTP transportpython -m vertica_mcp)
vertica_mcp/__main__.py for proper module invocationpython -m syntaxImprovements:
.gitignore to prevent test file regenerationTechnical Changes:
hashlib import for client ID hashingCore Features Implemented:
Key Capabilities:
Technical Achievements:
For complete version history and detailed changes, see CHANGELOG.md
This project is licensed under the MIT License - see the LICENSE file for complete terms and conditions.
License Summary:
This project builds upon mcp-vertica
by @nolleh.
While the original implementation provided a foundation for Vertica MCP support,
this fork introduces significant enhancements, including:
Core Technologies:
Vertica MCP is a production-ready server that connects AI assistants to Vertica through the Model Context Protocol (MCP). It enables secure, high-performance query execution, schema exploration, and p
Ringkasan umum
Vertica MCP is a production-ready server that connects AI assistants to Vertica through the Model Context Protocol (MCP). It enables secure, high-performance query execution, schema exploration, and performance insights with support for STDIO, HTTP, and Docker.
Tool
Belum ada daftar tool. Server remote mendapatkannya setelah pemeriksaan kesehatan pertama.
FAQ
Salin konfigurasi stdio untuk Cursor, Claude Desktop, Claude Code, atau VS Code di halaman ini. Konfigurasi ini memakai instalasi dari penerbit, bukan proxy PlugMCP.
Tidak ada variabel lingkungan wajib yang tercantum di catatan ini.
Vertica berjalan secara lokal melalui stdio.
Terakhir diperiksa 2026-10-28. Vertica MCP is a production-ready server that connects AI assistants to Vertica through the Model Context Protocol (MCP). It enables secure, high-performance query execution, schema exploration, and performance insights with support for STDIO, HTTP, and Docker.