SingleStore MCP Server

Overview

The Model Context Protocol (MCP) is an open protocol that standardizes how external tools and interfaces communicate context to large language models (LLMs). With MCP, you can describe an environment in which a model operates, including available tools, user intent, system state, and related contextual information.

Why Use MCP?

MCP enables you to:

  • Define context programmatically which enables the model to accurately interpret your goals and available tools.

  • Eliminate the need for writing custom prompts for each integration scenario.

  • Expose your system’s capabilities and usage conditions for scalable and collaborative AI agent design.

Capabilities and Benefits

The SingleStore MCP server implements Model Context Protocol (MCP) to enable seamless integration between large language models (LLMs) and SingleStore database services. The server provides a set of tools, resources and prompts templates that allows MCP compatible clients, such as Claude Desktop, VS Code, and Cursor, to interact with SingleStore using natural language prompts. These tools expose essential functionality for database management, notebook workflows, job scheduling, and usage tracking.

The SingleStore MCP server has the following key capabilities:

  • Authentication and Configuration

    • Authenticates with SingleStore’s management API using secure API keys.

    • Maintains user-specific session state, including preferences and input history, to support contextual interactions.

  • Workspace and Database Management

    • Retrieves metadata about accessible workspace groups, including workspace group IDs and names.

    • Lists workspaces within a selected workspace group and provides endpoint and status details.

    • Returns details about the user’s current organization, including metadata and settings.

    • Lists all supported deployment regions with relevant identifiers and region-specific metadata.

    • Runs SQL queries on connected workspaces and returns structured results with rows, columns, and error handling.

    • Manages starter workspaces within SingleStore:

      • Lists available starter workspaces.

      • Creates new shared workspaces with specific configurations.

      • Organizes user access controls and permissions.

      • Runs SQL on virtual workspaces.

  • Notebook and File Management

    • Manages notebooks:

      • Lists available notebook samples.

      • Creates new notebooks in the user’s personal workspace.

      • Supports custom notebook content and configurations.

    • Manages files:

      • Lists files in both personal and shared spaces.

      • Creates and manages files.

      • Organizes file access controls and permissions.

  • Scheduling Jobs

    • Creates scheduled jobs:

      • Creates jobs that run notebooks on a defined schedule (one-time or recurring).

      • Configures runtime environments and notebook parameters.

      • Manages notebook snapshots.

    • Monitors jobs:

      • Retrieves detailed information about scheduled jobs.

      • Lists historical executions.

      • Monitors job status and execution results.

Set Up SingleStore MCP Server

Note

To use the SingleStore MCP Server, you need a SingleStore Helios account and API access credentials.

Prerequisites

Ensure the following tools are installed:

  • Python 3.11+

  • uvx

  • uv

  • Preferred MCP client

Supported MCP Clients

The SingleStore MCP server supports the following clients:

  • Claude Desktop

  • Claude Code

  • Cursor

  • Visual Studio Code

  • Windsurf

  • Gemini CLI

  • LM Studio

  • Goose

  • Qodo Gen

Following MCP clients are available through Docker Desktop:

  • Continue.dev

  • Gordon

MCP Client Setup

You can set up a supported MCP client using any of the following approaches:

  1. Using the initialization command: The initialization command automatically locates the appropriate configuration file for your client platform and adds or updates it to include the SingleStore MCP server. Additionally, it sets up browser-based OAuth authentication and displays instructions for starting the server.

    Use the following command to initiate the server:

    uvx singlestore-mcp-server init 

    Use the following command to specify a client:

    uvx singlestore-mcp-server init --client=<client>

    Replace <client> with a supported MCP client. Following are the example syntax for the supported MCP client.

    • Claude Desktop

      uvx singlestore-mcp-server init --client=claude-desktop
    • Claude Code

      uvx singlestore-mcp-server init --client=claude-code
    • Cursor

      uvx singlestore-mcp-server init --client=cursor
    • Visual Studio Code

      uvx singlestore-mcp-server init --client=vscode
    • Windsurf

      uvx singlestore-mcp-server init --client=windsurf
    • Gemini CLI

      uvx singlestore-mcp-server init --client=gemini
    • LM Studio

      uvx singlestore-mcp-server init --client=lm-studio
  2. Installing via Smithery: Use the following command to install singlestore-mcp-server via Smithery:

    npx -y @smithery/cli install @singlestore-labs/mcp-server-singlestore --client=<client>

    Replace <client> with a supported MCP client.

  3. Manual Configuration: You can configure the following supported MCP clients manually. Add the following standard configuration to your MCP client’s configuration file:

    {
    "mcpServers": {
    "singlestore-mcp-server": {
    "command": "uvx",
    "args": [
    "singlestore-mcp-server",
    "start"
    ]
    }
    }
    }

    Use the configuration file of the MCP client as mentioned in the following client's documentation:

    1. Claude Desktop: Refer to the MCP install guide for the related information.

    2. Claude Code: Run the following command to manually setup the MCP client:

      claude mcp add singlestore-mcp-server uvx singlestore-mcp-server start
    3. Cursor: Navigate to Cursor Settings > MCP > Add new MCP Server. Enter the name of the MCP server. Select command type, and enter the command uvx singlestore-mcp-server start. Select Edit to verify configuration or add command line arguments.

    4. Visual Studio Code: Refer to the MCP install guide for the related information. You can also install using the VS Code CLI:

      code --add-mcp '{"name":"singlestore-mcp-server","command":"uvx","args":["singlestore-mcp-server","start"]}'

      After installation, the SingleStore MCP server is available for use with your GitHub Copilot agent in VS Code.

    5. Windsurf: Refer to the Windsurf documentation for the related information.

    6. Gemini CLI: Refer to the MCP install guide for the related information.

    7. LM Studio: Navigate to Program in the right sidebar, then select Install > Edit mcp.json.

    8. Goose: Navigate to Advanced settings > Extensions > Add custom extension. Enter the name of your custom extension. Select type STDIO, and enter the command uvx singlestore-mcp-server start. Select Add Extension to add your custom extension.

    9. Qodo Gen: Open Qodo Gen chat panel in VSCode or IntelliJ. Select Connect more tools > + Add new MCP, and paste the standard configuration.

    Note

    This approach does not require any API keys, tokens, or environment variables. When the server starts, authentication is automatically handled via browser-based OAuth.

  4. Using Docker:

    1. Run the following command to build the docker image of the SingleStore MCP server:

      docker build -t singlestore/mcp-server-singlestore .
    2. Use the following configuration:

      {
      "mcpServers": {
      "singlestore-mcp-server": {
      "command": "docker",
      "args": [
      "run", "-i", "--rm", "--init", "--pull=always",
      "-e", "MCP_API_KEY=your_api_key_here",
      "singlestore/mcp-server-singlestore"
      ]
      }
      }
      }
    3. Update the configuration of your MCP configuration file, and then restart your MCP client.

      Note

      When running the server in a Docker container, an API key is required. Browser-based OAuth is not supported for locally hosted containers. For improved security, SingleStore recommends using Docker Desktop to configure the SingleStore MCP server. Refer to The Docker MCP Catalog: the Secure way to Discover and Run MCP Servers for more information.

Tools in SingleStore MCP Server

The SingleStore MCP server implements the following tools:

Tool

Description

Arguments

Returns

get_user_info

Retrieves details about the user.

None

User details

organization_info

Retrieves details about the current organization.

None

Organization details

choose_organization

Retrieves list of organizations.

None

List of organizations

set_organization

Sets the selected organization.

  • organization_id

Sets the organization

workspace_groups_info

Retrieves details about accessible workspace groups.

None

Workspace group details

workspaces_info

Retrieves workspaces in a specific workspace group.

  • workspaceGroupID

Workspace details

resume_workspace

Resumes a paused workspace within the workspace group.

  • workspace_id

Resumes workspace

list_starter_workspaces

Lists all starter workspaces accessible to the user.

None

Starter workspace details

create_starter_workspace

Creates a starter workspace and user.

  • name

  • database_name

  • username

  • password

  • workspace_group (optional)

Details of the created workspace and user

terminate_starter_workspace

Terminates starter workspace. This action cannot be undone.

  • workspace_id

Terminates starter workspace

list_regions

Lists all regions that support workspaces.

None

List of regions

list_sharedtier_regions

Lists the available regions before creating a starter workspace.

None

Lists region name and cloud provider.

run_sql

Runs SQL on a connected workspace.

  • workspace_group_identifier

  • workspace_identifier

  • username

  • password

  • database

  • sql_query

SQL results in structured format

create_notebook_file

Creates a new notebook in the specified space (personal or shared).

  • notebook_name

  • content (optional)

Created notebook details

upload_notebook_file

Uploads created notebook file in the Cloud Portal.

  • local_path

  • upload_name (optional)

  • upload_location (optional)

Uploads created notebook

create_job_from_notebook

Creates a scheduled job to run a notebook.

  • name

  • notebook_path

  • schedule_mode

  • execution_interval_minutes (optional)

  • start_at (optional)

  • description (optional)

  • create_snapshot (optional)

  • runtime_name

  • parameters (optional)

  • target_config (optional)

Created job details

get_job

Retrieves details of an existing job

  • job_id

Existing job details

delete_job

Permanently deletes a scheduled job.

  • job_id

Deletes the scheduled job permanently

In this section

Last modified: September 22, 2025

Was this article helpful?

Verification instructions

Note: You must install cosign to verify the authenticity of the SingleStore file.

Use the following steps to verify the authenticity of singlestoredb-server, singlestoredb-toolbox, singlestoredb-studio, and singlestore-client SingleStore files that have been downloaded.

You may perform the following steps on any computer that can run cosign, such as the main deployment host of the cluster.

  1. (Optional) Run the following command to view the associated signature files.

    curl undefined
  2. Download the signature file from the SingleStore release server.

    • Option 1: Click the Download Signature button next to the SingleStore file.

    • Option 2: Copy and paste the following URL into the address bar of your browser and save the signature file.

    • Option 3: Run the following command to download the signature file.

      curl -O undefined
  3. After the signature file has been downloaded, run the following command to verify the authenticity of the SingleStore file.

    echo -n undefined |
    cosign verify-blob --certificate-oidc-issuer https://oidc.eks.us-east-1.amazonaws.com/id/CCDCDBA1379A5596AB5B2E46DCA385BC \
    --certificate-identity https://kubernetes.io/namespaces/freya-production/serviceaccounts/job-worker \
    --bundle undefined \
    --new-bundle-format -
    Verified OK