Local MCP Connectors

Installation guides for Model Context Protocol (MCP) connectors that run locally on your machine.

Prerequisites

Python 3.13 or higher
Box API credentials (Client ID, Client Secret, etc.)
UV package manager

Clone the Repository

git clone https://github.com/box-community/mcp-server-box.git
cd mcp-server-box

Install UV

MacOS+Linux

curl -Ls https://astral.sh/uv/install.sh | sh

Windows

   powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Create and Setup Your Project

macOS / Linux

# Create and activate the virtual environment
uv venv
source .venv/bin/activate

# Lock the dependencies
uv lock

Windows

# Create and activate the virtual environment
uv venv
.venv\Scripts\activate

# Lock the dependencies
uv lock

PowerShell Execution Policy Error: If you encounter an error about scripts being disabled when trying to activate the virtual environment, you need to change the PowerShell execution policy. Run PowerShell as Administrator and execute:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

This allows local scripts to run while maintaining security for remote scripts.

Set Up Environment Variables

Create a Custom Box App

Before setting up environment variables, you need to create a custom Box application to obtain your API credentials:

Access Box Developer Console
- Go to app.box.com/developers/console
- Login to your Box account
Create Custom App
- Select “Custom App” or “Create New App” then “Custom App”
- Fill in the popup for creating a custom app:
  - Name: Write in “Delve”
  - Description: Write in “AI data analysis”
  - Purpose: Choose “Integration”
  - Category: Choose “AI”
Configure Authentication
- On the next screen, select “User Authentication (OAuth 2.0)”
- Click “Create App”
Set Redirect URI
- In the Configuration Window, scroll down to “OAuth 2.0 redirect URIs”
- Add http://localhost:8000/callback
- Click “Save” in the top right corner
Get Your Credentials
- Find the “OAuth 2.0 credentials” section
- These are the BOX_CLIENT_ID and BOX_CLIENT_SECRET that you will use in the .env file

Create Environment File

Create a .env file in the root directory and add your Box API credentials:

BOX_CLIENT_ID=your_client_id
BOX_CLIENT_SECRET=your_client_secret

Security Note: Never commit your .env file to version control. Add it to your .gitignore file to prevent accidental exposure of your credentials.

Box Auth Test Instructions

Important: Test your Box authentication before proceeding with the MCP server setup. This will verify your credentials and complete the OAuth flow.

Open tests/test_box_auth.py
Comment out the @pytest.mark.skip lines (add # before them)
Save the file
Run: pytest tests/test_box_auth.py -v

When you run the test:

A browser window will automatically open asking you to log in to your Box account
Sign in with your Box credentials
Grant access to the application when prompted
The browser will redirect to http://localhost:8000/callback
The test will complete successfully if authentication works

Note: If the browser doesn’t open automatically, check your browser settings or manually navigate to the URL shown in the terminal output.

Adding the MCP Server to Delve

To integrate the Box MCP Server with Delve, follow these steps:

Open Delve Settings
- Launch Delve
- Navigate to Settings (gear icon)
Add MCP Connector
- Click the ”+” icon to the right of “MCP Connectors”
- This will open the connector configuration dialog
Configure the Connector
- Connector Name: Enter Box
- Connection Type: Select Command
- Command: Enter uv
- Arguments: Enter the following (one per line):
```
--directory
/path/to/mcp-server-box
run
src/mcp_server_box.py
```
Note: Replace /path/to/mcp-server-box with the actual path to your cloned mcp-server-box repository.

Troubleshooting: If you get a “uv not in path” error, you may need to use the absolute path to UV instead of just uv.
Save Configuration
- Click “Save” to store the connector settings

Troubleshooting

If you receive Error: spawn uv ENOENT on macOS, try reinstalling UV with Homebrew: brew install uv or provide the full path to the UV executable in your configuration.
Ensure your Box API credentials in .env are correct.
For PowerShell execution policy issues, see the note above in the Delve configuration section.

For more details, see the official Box MCP Server documentation.

Adding the MCP Server to Delve

To integrate the ClickHouse MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter ClickHouse
- Connection Type: Select Command
- Command: Enter uv
- Arguments: Enter the following (one per line):
```
run
--with
mcp-clickhouse
--python
3.13
mcp-clickhouse
```
Environment Variables
- Add the following environment variables:
  - CLICKHOUSE_HOST: Your ClickHouse server hostname or IP address
  - CLICKHOUSE_PORT: ClickHouse server port (default: 8123)
  - CLICKHOUSE_USER: Your ClickHouse username
  - CLICKHOUSE_PASSWORD: Your ClickHouse password
  - CLICKHOUSE_SECURE: Set to true for HTTPS connections, false for HTTP
  - CLICKHOUSE_VERIFY: Set to true to verify SSL certificates, false to skip verification
  - CLICKHOUSE_CONNECT_TIMEOUT: 30
  - CLICKHOUSE_SEND_RECEIVE_TIMEOUT: 30
Save Configuration
- Click “Save” to store the connector settings

Connection Configuration

The ClickHouse MCP Server supports various connection configurations:

ClickHouse Cloud Instance Environment Variables

CLICKHOUSE_HOST: your-instance.clickhouse.cloud
CLICKHOUSE_USER: default
CLICKHOUSE_PASSWORD: your-password

ClickHouse SQL Playground Environment Variables

CLICKHOUSE_HOST: sql-clickhouse.clickhouse.com
CLICKHOUSE_PORT: 8443
CLICKHOUSE_USER: demo
CLICKHOUSE_PASSWORD: ""
CLICKHOUSE_SECURE: true
CLICKHOUSE_VERIFY: true
CLICKHOUSE_CONNECT_TIMEOUT: 30
CLICKHOUSE_SEND_RECEIVE_TIMEOUT: 30

Note: Replace the connection environment variables with your actual ClickHouse server details. For ClickHouse Cloud, you can find the connection details in your cloud dashboard.

For more details, see the official ClickHouse MCP Server documentation.

Creating a Dart Access Token

Before configuring the MCP Server, you need to create an access token in your Dart account.

Follow these steps to create an access token:

Log in to your Dart account
Navigate to Settings > Account > Authorization
Create a new access token
Copy the generated token (it will start with dsa_)

Important Notes:

Store your access token securely. It provides access to your Dart data and should never be shared or committed to version control
The token will start with dsa_ followed by a string of characters

Adding the MCP Server to Delve

To integrate the Dart MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter dart
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
dart-mcp-server
```
Environment Variables
- Add the following environment variable:
  - DART_TOKEN: Your Dart access token (e.g., dsa_your_token_here)
Save Configuration
- Click “Save” to store the connector settings

For more details, see the official Dart MCP Server documentation.

Installing DuckDB (Optional)

Before configuring the MCP Server, you may want to install DuckDB locally. However, the MCP server can also create an in-memory database on the fly.

Follow the official DuckDB installation guide: DuckDB Installation Instructions

Important Notes:

DuckDB installation is optional - the MCP server can create in-memory databases automatically
For production use, we recommend the stable release
Binaries are available for major programming languages and platforms

Adding the MCP Server to Delve

To integrate the DuckDB MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter mcp-server-motherduck
- Connection Type: Select Command
- Command: Enter uvx
- Arguments: Choose one of the following configurations (one argument per line):

Option 1: In-Memory Database (Recommended for testing)

mcp-server-motherduck
--db-path
:memory:

Option 2: Local DuckDB File

mcp-server-motherduck
--db-path
/path/to/your/local.db

Option 3: Local DuckDB File (Read-Only Mode)

mcp-server-motherduck
--db-path
/path/to/your/local.db
--read-only

Save Configuration
- Click “Save” to store the connector settings

For more details, see the official DuckDB MCP Server documentation.

Prerequisites

Before configuring the MCP Server, ensure you have:

A Dynatrace account
NPM installed

Creating OAuth Credentials

Access Dynatrace Settings
- Log in to your Dynatrace environment
- Navigate to Dynatrace OAuth Clients Dashboard
- Click “Create client” to create a new OAuth client

For detailed step-by-step instructions on creating OAuth clients, see the Dynatrace OAuth Clients documentation.

Get Environment Information
- Note your Dynatrace environment URL
- This is typically in the format: https://your-environment-id.apps.dynatrace.com

Adding the MCP Server to Delve

To integrate the Dynatrace MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter Dynatrace
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
@dynatrace-oss/dynatrace-mcp-server@latest
```
Environment Variables
- Add the following environment variables:
  - OAUTH_CLIENT_ID: Your OAuth client ID
  - OAUTH_CLIENT_SECRET: Your OAuth client secret
  - DT_ENVIRONMENT: Your Dynatrace environment URL
Save Configuration
- Click “Save” to store the connector settings

Note: Replace the environment variables with your actual OAuth credentials and Dynatrace environment URL. Keep your credentials secure and don’t share them publicly.

For more details, see the Dynatrace MCP Server documentation.

Prerequisites

Before configuring the MCP Server, ensure you have access to an Elasticsearch cluster:

An Elasticsearch instance
Elasticsearch authentication credentials (API key or username/password)
NPM installed

Adding the MCP Server to Delve

To integrate the Elasticsearch MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter Elasticsearch
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
@elastic/mcp-server-elasticsearch
```
Environment Variables
- Add the following environment variables:
  - ES_URL: Your Elasticsearch cluster URL
  - ES_API_KEY: Your Elasticsearch API key
  - OTEL_LOG_LEVEL: Set to none to disable OpenTelemetry logging
Save Configuration
- Click “Save” to store the connector settings

Note: Replace your-elasticsearch-url and your-api-key with your actual Elasticsearch cluster URL and API key. Keep your API key secure and don’t share it publicly.

For more details, see the official Elasticsearch MCP Server documentation.

Creating an eSignatures Account

Before configuring the MCP Server, you need to create an account and obtain a secret token from eSignatures.

Follow these steps to create an account and get your secret token:

Visit eSignatures.com and create a free account
Once your account is created, navigate to your account settings
Copy your secret token from the API section
Store the token securely for use with Delve

Important Notes:

Store your secret token securely. It provides access to your eSignatures data and should never be shared or committed to version control
The free account allows you to test the Agent AI by creating templates and sending test contracts
Keep your token safe as it grants access to your eSignatures account and documents

Adding the MCP Server to Delve

To integrate the eSignatures MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter mcp-server-esignatures
- Connection Type: Select Command
- Command: Enter uvx
- Arguments: Enter the following:
```
mcp-server-esignatures
```
Environment Variables
- Add the following environment variable:
  - ESIGNATURES_SECRET_TOKEN: Your eSignatures API secret token
Save Configuration
- Click “Save” to store the connector settings

For more details, see the official eSignatures MCP Server documentation.

Creating a HubSpot Private App

Before configuring the MCP Server, you need to create a private app in HubSpot:

Access HubSpot Settings
- Log in to your HubSpot account
- Navigate to Settings > Integrations > Private Apps
Create Private App
- Click “Create private app”
- Name your app (e.g., “Delve Integration”)
- Set required scopes for your use case
- Click “Create app”
Copy Access Token
- After creation, copy the generated access token

Note: Consider starting with read-only scopes for security

Adding the MCP Server to Delve

To integrate the HubSpot MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter hubSpot
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
@hubspot/mcp-server
```
Environment Variables
- Add the following environment variable:
  - PRIVATE_APP_ACCESS_TOKEN: Your HubSpot private app access token
Save Configuration
- Click “Save” to store the connector settings

For more details, see the official HubSpot MCP Server documentation.

Prerequisites

Before configuring the MCP Server, ensure you have:

A LaunchDarkly account
API access token with appropriate permissions
NPM installed

Creating an API Access Token

Access Organization Settings
- Click the gear icon in the left sidenav to view Organization settings
- Click Authorization
Create Access Token
- In the “Access tokens” section, click Create token
- Give your token a human-readable Name
- Assign a Role to the token by choosing one from the menu
- The LaunchDarkly MCP server provides tools for managing flags and AI Configs, so your token should have permission to create, read, update, and delete flags and AI Configs in the projects you want to work in. You could use a token with a Writer base role, a LaunchDarkly Developer preset role, or another role that provides this access
- Click Save token
Copy Token
- Copy and save the token somewhere secure
- After you leave this page, the token is obscured

For more details, see the LaunchDarkly API documentation.

Adding the MCP Server to Delve

To integrate the LaunchDarkly MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter LaunchDarkly
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
--package
@launchdarkly/mcp-server
--
mcp
start
--api-key
api-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```
Save Configuration
- Click “Save” to store the connector settings

Note: Replace api-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx with your actual API access token. Keep your token secure and don’t share it publicly.

Alternative: Local Build Setup

Optionally, you can run LaunchDarkly’s MCP server from a local build:

Install and Build

git clone git@github.com:launchdarkly/mcp-server.git
npm install
npm run build

Configure Local Build
- Connector Name: Enter LaunchDarkly
- Connection Type: Select Command
- Command: Enter node
- Arguments: Enter the following (one per line):
```
/path/to/mcp-server/bin/mcp-server.js
start
--api-key
api-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

For more details, see the LaunchDarkly MCP documentation

Adding the MCP Server to Delve

To integrate the MongoDB MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter MongoDB
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
mongodb-mcp-server
--connectionstring
mongodb://localhost:27017/Database
```
Save Configuration
- Click “Save” to store the connector settings

Connection String Configuration

The connection string can be configured to connect to any MongoDB cluster:

Local MongoDB

mongodb://localhost:27017/myDatabase

MongoDB Atlas Cluster

mongodb+srv://[username:password@]host[/[defaultauthdb][?options]]

Connection String Parameters

Host: Your MongoDB server address
Port: MongoDB port (default: 27017)
Database: The database name you want to connect to
Authentication: Include username and password if required

Note: Replace the connection string with your actual MongoDB connection details. For Atlas clusters, you can find the connection string in your Atlas dashboard under “Connect” → “Connect your application”.

For more details, see the official MongoDB MCP Server documentation.

Creating a Netlify Personal Access Token

Before configuring the MCP Server, you need to create a personal access token in your Netlify account.

Follow these steps to create a personal access token:

Log in to your Netlify account
Navigate to User Settings > OAuth
Create a new personal access token
Copy the generated token

Important Notes:

Store your personal access token securely. It provides access to your Netlify data and should never be shared or committed to version control
Keep your token safe as it grants access to your Netlify account and projects

Adding the MCP Server to Delve

To integrate the Netlify MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter netlify
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
@netlify/mcp
```
Environment Variables
- Add the following environment variable:
  - NETLIFY_PERSONAL_ACCESS_TOKEN: Your Netlify personal access token
Save Configuration
- Click “Save” to store the connector settings

For more details, see the official Netlify MCP Server documentation.

Creating a Pinecone API Key

Before configuring the MCP Server, you need to create an API key in your Pinecone account.

Follow these steps to create an API key:

Log in to your Pinecone account
Navigate to the API Keys section
Create a new API key
Copy the generated API key

Important Notes:

Store your API key securely. It provides access to your Pinecone data and should never be shared or committed to version control
The Pinecone MCP server supports only indexes with integrated embedding. Indexes for vectors you create with external embedding models are not supported

Adding the MCP Server to Delve

To integrate the Pinecone MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter pinecone
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
@pinecone-database/mcp
```
Environment Variables
- Add the following environment variable:
  - PINECONE_API_KEY: Your Pinecone API key
Save Configuration
- Click “Save” to store the connector settings

For more details, see the official Pinecone MCP Server documentation.

Creating a Shopify Custom App

Before configuring the MCP Server, you need to create a custom app in your Shopify store to obtain an Admin API access token.

Follow the official Shopify documentation to create a custom app: How to create a custom app

Important Notes:

When configuring Admin API scopes, select the following scopes:
- read_products, write_products
- read_customers, write_customers
- read_orders, write_orders
After installation, copy your Admin API access token
Store your access token securely. It provides access to your store data and should never be shared or committed to version control

Adding the MCP Server to Delve

To integrate the Shopify MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter shopify
- Connection Type: Select Command
- Command: Enter npx
- Arguments: Enter the following (one per line):
```
-y
shopify-mcp-server
```
Environment Variables
- Add the following environment variables:
  - SHOPIFY_ACCESS_TOKEN: Your Shopify Admin API access token
  - MYSHOPIFY_DOMAIN: Your shop domain (e.g., yourstore.myshopify.com)
Save Configuration
- Click “Save” to store the connector settings

For more details, see the official Shopify MCP Server documentation.

Prerequisites

Before configuring the MCP Server, ensure you have:

A Supabase account
A Supabase project
Personal access token (PAT)
NPM installed

Creating a Personal Access Token

Access Supabase Settings
- Go to your Supabase Personal Access Tokens settings
Create Personal Access Token
- Click “Create new token”
- Give it a name that describes its purpose, like “Delve MCP Server”
- This will be used to authenticate the MCP server with your Supabase account

Adding the MCP Server to Delve

To integrate the Supabase MCP Server with Delve, follow these steps:

Open Delve Settings
Add MCP Connector
Configure the Connector
- Connector Name: Enter supabase
- Connection Type: Select Command

For macOS:

Command: Enter npx

Arguments: Enter the following (one per line):

-y
@supabase/mcp-server-supabase@latest
--read-only
--project-ref=<project-ref>

Environment Variables
- SUPABASE_ACCESS_TOKEN: Your personal access token

For Windows:

Command: Enter cmd

Arguments: Enter the following (one per line):

/c
npx
-y
@supabase/mcp-server-supabase@latest
--read-only
--project-ref=<project-ref>

Environment Variables
- SUPABASE_ACCESS_TOKEN: Your personal access token

Save Configuration
- Click “Save” to store the connector settings

Note: Replace <project-ref> with your project ref, and <personal-access-token> with your personal access token. Keep your token secure and don’t share it publicly.

For more details, see the Supabase MCP Server documentation.