Skip to main content
Glama
DX MCP Server

DX MCP Server

by get-dx

DX MCP Server

AI Query Interface with DX MCP Server

About

The DX MCP Server is a Python-based tool that empowers AI applications, such as Claude for Desktop and Cursor, to interact with your DX Data Cloud database. The server includes tools to:

  • establish a connection to your Postgres database, allowing the AI to actively formulate and execute queries on the database

  • find/utilize context about your software entities and their relationships and scorecards via DX catalog tools

Learn more about the Model Context Protocol (MCP).

Note: DX intends for the CLI to become the primary interface for AI agents and is investing in it as the long-term direction beyond the MCP server. Both interfaces remain supported.

Related MCP server: PostgreSQL MCP Server

Demo

https://github.com/user-attachments/assets/c6ce12a5-4562-4b44-b235-2d04871c3142

Getting Started

There are two ways to use the DX MCP Server:

  1. Remote hosting (recommended): Connect to our hosted server at https://ai.getdx.com/mcp

  2. Local hosting: Run the server on your machine

Prerequisites

  • A DX account with access to Data Cloud

  • For remote hosting:

    • A DX API token, generated in your DX Account Settings

      • Admin users can create an organization API token with read scopes granted, and non-admin users can generate personal access tokens to authenticate with the MCP server.

  • For local hosting:

    • Python 3.10 or higher

    • Your database connection URL (configured on DX's DB Users settings page)

    • A DX API token, generated in your DX Account Settings

      • Admin users can create an organization API token with read scopes granted, and non-admin users can generate personal access tokens to authenticate with the MCP server.


The hosted MCP server uses streamable HTTP transport and is available at https://ai.getdx.com/mcp. This option requires no local installation; just configure your AI client with the mcp using http transport and provided with a valid DX API Token.

Claude Code

Run this command in your terminal:

claude mcp add --transport http dx-mcp https://ai.getdx.com/mcp --header "Authorization: Bearer [YOUR_DX_API_TOKEN]"

Cursor

Add this configuration to your MCP settings (Cursor > Settings > Cursor Settings > MCP):

{
  "mcpServers": {
    "dx-mcp": {
      "url": "https://ai.getdx.com/mcp",
      "headers": {
        "Authorization": "Bearer [YOUR_DX_API_TOKEN]"
      }
    }
  }
}

Option 2: Local Installation

If you prefer to run the DX MCP Server locally, you can install it via PyPI or run it from source.

Installation Method 1: Install from PyPI

Install the package using pip:

pip install dx-mcp-server

Note for macOS users: If you encounter an "externally-managed-environment" error, use pipx instead:

pipx install dx-mcp-server

Installation Method 2: Clone from Source

Clone this repository to run from source:

git clone https://github.com/get-dx/dx-mcp-server
cd dx-mcp-server

Configuration

Once installed, configure your AI client with the appropriate settings:

Claude Code

Run this command in your terminal (adjust based on your installation method):

# If installed via pip/pipx
claude mcp add dx-mcp-server --env DB_URL=YOUR_DB_URL --env WEB_API_TOKEN=YOUR_DX_API_TOKEN -- $(which dx-mcp-server)

Claude for Desktop

Click Claude > Settings > Developer > Edit Config and add:

If you installed via pip:

{
  "mcpServers": {
    "dx-mcp": {
      "command": "dx-mcp-server", 
      "args": ["run"],
      "env": {
        "DB_URL": "YOUR-DATABASE-URL",
        "WEB_API_TOKEN": "YOUR_DX_API_TOKEN"
      }
    }
  }
}

If you're running from source:

{
  "mcpServers": {
    "dx-mcp": {
      "command": "uv",
      "args": ["--directory", "/path/to/dx-mcp-server", "run", "-m", "dx_mcp_server", "run"],
      "env": {
        "DB_URL": "YOUR-DATABASE-URL",
        "WEB_API_TOKEN": "YOUR-DX-API-TOKEN"
      }
    }
  }
}

Cursor

Click Cursor > Settings > Cursor Settings > MCP > Add new global MCP Server and add:

If you installed via pip:

{
  "mcpServers": {
    "dx-mcp": {
      "command": "dx-mcp-server", 
      "args": ["run"],
      "env": {
        "DB_URL": "YOUR-DATABASE-URL",
        "WEB_API_TOKEN": "YOUR-DX-API-TOKEN"
      }
    }
  }
}

If you're running from source:

{
  "mcpServers": {
    "dx-mcp": {
      "command": "uv",
      "args": ["--directory", "/path/to/dx-mcp-server", "run", "-m", "dx_mcp_server", "run"],
      "env": {
        "DB_URL": "YOUR-DATABASE-URL",
        "WEB_API_TOKEN": "YOUR-DX-API-TOKEN"
      }
    }
  }
}

Configuration Parameters

  • DB_URL (required): Your DX Data Cloud Postgres connection string. Get this from DX DB Users settings.

    • Format: postgresql://username:password@host:port/database

  • WEB_API_TOKEN: Your DX API Token (either an organization token or a personal access token). This enables additional catalog and entity tools. Find this in your DX account settings.

Usage

After saving the configuration, restart your AI client. You should see "dx-mcp" in the available MCP servers. When you ask questions about your data or catalog, the AI will use these tools to query your database or hit the relevant web apis.


Troubleshooting

Path Resolution Issues

The most common issue involves the MCP client not finding the dx-mcp-server/uv command, as GUI applications don't inherit the same PATH environment variables as the terminal. The solution is to use the full path to the executable in the json config.

For pip/pipx installations:

Find the full path to dx-mcp-server:

# Find the path on macOS/Linux
which dx-mcp-server

# Find the path on Windows (in Command Prompt)
where dx-mcp-server

Then use the full path in your configuration:

{
  "mcpServers": {
    "dx-mcp": {
      "command": "/full/path/to/dx-mcp-server",
      "args": ["run"],
      "env": {
        "DB_URL": "YOUR-DATABASE-URL",
        "WEB_API_TOKEN": "YOUR-DX-API-TOKEN"
      }
    }
  }
}

For source installations:

Find the full path to uv:

# Find the path on macOS/Linux
which uv

# Find the path on Windows (in Command Prompt)
where uv

Then use the full path in your configuration:

{
  "mcpServers": {
    "dx-mcp": {
      "command": "/full/path/to/uv",
      "args": ["--directory", "/absolute/path/to/dx-mcp-server", "run", "-m", "dx_mcp_server", "run"],
      "env": {
        "DB_URL": "YOUR-DATABASE-URL",
        "WEB_API_TOKEN": "YOUR-DX-API-TOKEN"
      }
    }
  }
}

Checking Logs

If you're still experiencing issues:

  • Claude Desktop: Check logs at:

    • macOS: ~/Library/Logs/Claude/

    • Windows: %APPDATA%\Claude\logs\

  • Cursor: Check logs at:

    • macOS: ~/Library/Application Support/Cursor/logs/[SESSION_ID]

    • Windows: %APPDATA%\Cursor\logs\[SESSION_ID]

The logs will show warning and error messages when starting or running the MCP server.

Available Tools

10 tools
getEntityDetailsB

Get comprehensive details about a specific entity including its information, tasks, and scorecards - we can use this to check operational readiness/health of an entity.

Args: identifier (str): The unique identifier for the entity (e.g., 'payment-processing').

Inputs: identifier (required). Returns: object

getInitiativeDetailsA

Get initiative details including both the initiative info and its progress report.

Note: This calls two endpoints:

  • initiatives.info

  • initiatives.progressReport

Args: id (str): Initiative public ID. entity_type_identifiers (str, optional): Passed through to initiatives.progressReport. limit (int, optional): Passed through to initiatives.progressReport. Maximum 100, defaults to 50. cursor (str, optional): Passed through to initiatives.progressReport.

Inputs: id (required), entity_type_identifiers, limit, cursor. Returns: object

getScorecardInfoA

Retrieve details about a specific scorecard, including its defined levels and checks. Args: id (str): The unique ID of the scorecard.

Inputs: id (required). Returns: object

getTeamDetailsA

Retrieve details for an individual team. Note that searching by team_emails will return things like the team name and members, where the search by team_id/reference_id will return more detailed information about the team structure.

Args: team_id (str, optional): The DX team ID. reference_id (str, optional): The team's internal reference ID in your organization. team_emails (str, optional): Comma separated list of team members' email addresses.

Inputs: team_id, reference_id, team_emails. Returns: object

listEntitiesB

List entities from the DX software catalog.

Args: search_term (str, optional): Search term to filter by. type (str, optional): Filter entities by type (e.g., 'service', 'team', etc.). cursor (str, optional): Cursor for pagination. Get from response_metadata.next_cursor in prior requests. limit (int, optional): Number of entities per page - if present, must be between 1 and 50.

Inputs: search_term, type, cursor, limit. Returns: object

listInitiativesB

Lists all initiatives with summary information.

Args: cursor (str, optional): Cursor for pagination. Get from response_metadata.next_cursor in prior requests. limit (int, optional): Limit the number of initiatives per page. Maximum 100, defaults to 50. published (bool, optional): Filter by published status. priority (int, optional): Filter by priority (0-2, lower numbers are more urgent). tags (str, optional): Comma-separated tags to filter by.

Inputs: cursor, limit, published, priority, +1 more. Returns: object

listScorecardsB

List all active scorecards. Args: cursor (str, optional): Cursor for pagination. Get from response_metadata.next_cursor in prior requests. limit (int, optional): Limit the number of scorecards per page. Must be between 1 and 50.

Inputs: cursor, limit. Returns: object

listTeamsB

List all teams in DX.

Inputs: no named parameters. Returns: object

queryDataA

Execute a SQL query against the DX Data Cloud PostgreSQL database. Always query from information_schema if you are uncertain about which tables and columns to look at. Args: sql (str): SQL query to execute

Returns: str: Formatted query results or error message

Inputs: sql (required). Returns: result

reviewTasksC

Review/resolve/complete outstanding DX tasks (failing checks).

Args: entity_identifier (str): Entity identifier. check_ids (str): Comma-separated list of check IDs to focus on.

Inputs: entity_identifier (required), check_ids (required). Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 10 tools

    Disambiguation4/5

    Most tools have distinct purposes targeting different resources (entities, initiatives, scorecards, teams, tasks, and data queries), but getEntityDetails and getScorecardInfo could potentially overlap if scorecards are part of entity details. The descriptions clarify their focus, but there's minor ambiguity in the entity/scorecard relationship.

    Naming Consistency4/5

    Tools follow a consistent verb_noun pattern (getEntityDetails, listEntities, etc.) with clear prefixes (get, list, query, review). The only deviation is queryData which uses 'query' instead of 'get' or 'list', but this is semantically appropriate for SQL execution, maintaining overall readability.

    Tool Count5/5

    With 10 tools, the count is well-scoped for a DX software catalog and operational readiness server. Each tool serves a clear purpose in managing entities, initiatives, scorecards, teams, tasks, and data queries, avoiding bloat while covering essential operations.

    Completeness3/5

    The toolset provides good read/list coverage for entities, initiatives, scorecards, and teams, plus task review and data querying. However, there are notable gaps in write operations (e.g., no create/update/delete tools for these resources) and limited task management beyond review, which may hinder full lifecycle management in the domain.

    Maintenance

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI to query and manage PostgreSQL and MongoDB databases through natural language. Supports automatic schema discovery, safe data operations, and network-wide database access with zero-configuration deployment.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to query and manage local PostgreSQL databases through SQL execution and schema exploration tools. It supports both read-only queries and write operations including table creation and data modification via natural language.
      33 npm
      1
      ISC