Configuring the DAZZM MCP in VS Code

Introduction

The DAZZM MCP (Model Context Protocol) server lets you connect the VS Code assistant directly to a DAZZM application. Once the connection is established, the assistant can act in two areas:

• Modify the application by manipulating its definitions (models, pages, workflows, scripts, etc.);
• Read and modify the data contained in the application.

This guide covers the connection in VS Code, with two possible scopes:

• Project scope — the server is only available in a single VS Code workspace, and the configuration lives in that project’s folder;
• User scope — the server is available in every VS Code project on the machine, and the configuration lives in the user profile.

The preparation steps — generating the API key, choosing the environment, usage tips — are identical for both; only the place where the configuration is stored differs.

N.B.: The MCP server was designed to be connected to a development environment, where modifying definitions is allowed. See the Choosing the right environment section before connecting to any other environment.

N.B.: Since DAZZM applications are low-code and their source code is never stored in a GitHub repository, there is no repository-level configuration for this connector — only the project (workspace) and user scopes apply.

N.B.: This guide covers VS Code only. For the standalone GitHub Copilot application (desktop/mobile), which uses a different configuration screen, see Configuring the DAZZM MCP in Copilot.

Prerequisites

• Access to your DAZZM organization’s Account application;
• A DAZZM application with a development environment;
• VS Code installed, with the GitHub Copilot extension enabled;
• Node.js and npm installed (the connection uses npx) — check with:

node -v
npm -v

If needed, install Node.js from nodejs.org.

Steps to follow

1. Generate an API key (Account)

1. Open the Account application;
2. Access the application you want to connect;
3. Access a development environment of that application;
4. Create an API key. You can name it, for example, “VS Code”;
5. Copy the key’s value.

2. Configure the project scope

Use the project scope when you want the MCP server enabled for a single project or workspace only — useful for testing, or when you want the configuration to travel with the project and be shared with the other developers who open it.

1. Open your project in VS Code;
2. At the root of the project, create a folder named .vscode if it does not already exist;
3. Inside .vscode, create a file named mcp.json;
4. Add the following content:

{
  "servers": {
    "dazzm-<app-name>": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://<app-name>-<env-name>.apps.dazzm.com/api/prod/mcp",
        "--header",
        "api-key:<YOUR_API_KEY>"
      ]
    }
  }
}

5. Replace <YOUR_API_KEY> with the key value copied in step 1;
6. Save the file;
7. Reload VS Code (or restart the assistant session);
8. Open the assistant’s chat and confirm that the server appears in the list of MCP tools/servers.

A few notes about this example:

• dazzm-<app-name> is the name of the MCP server as the assistant will see it. We recommend naming it dazzm- followed by your application’s name. This is particularly useful if you control several applications;
• The URL follows the format https://<app-name>-<env-name>.apps.dazzm.com/api/prod/mcp, where <app-name> is the name of your application and <env-name> is the name of the environment you are connecting to — the same URL segment you use to access your application;
• The prod segment in /api/prod/mcp is fixed: it refers to the version of the DAZZM platform, not to your application’s environment. Do not replace it;
• api-key: is followed directly by the key value, with no space.

3. Configure the user scope

Use the user scope when you want the MCP server available in every VS Code project on the current machine, without repeating the configuration in each one.

1. Open VS Code;
2. Press Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows);
3. Search for and select MCP: Open User Configuration;
4. This opens the user-level configuration file for your system:
   • Mac: ~/Library/Application Support/Code/User/mcp.json (or Code - Insiders for the Insiders build)
   • Windows: %APPDATA%\Code\User\mcp.json (or Code - Insiders for the Insiders build)
5. Add the same content as in step 2, then save the file and reload VS Code.

N.B.: The command palette also offers MCP: Add Server, which asks for a command interactively. In our tests, this method did not reliably produce a working configuration — use MCP: Open User Configuration instead and edit the JSON directly.

4. Keep the API key out of your configuration (optional but recommended)

If you do not want to hard-code the API key in a configuration file — especially for project-scope configurations shared with other developers — reference an environment variable instead:

{
  "servers": {
    "dazzm-<app-name>": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://<app-name>-<env-name>.apps.dazzm.com/api/prod/mcp",
        "--header",
        "api-key:${env:DAZZM_API_KEY}"
      ]
    }
  }
}

Set the variable before launching VS Code:

Mac / Linux

export DAZZM_API_KEY=<YOUR_API_KEY>

Windows (PowerShell)

$env:DAZZM_API_KEY="<YOUR_API_KEY>"

If you use the project scope in a shared repository, only commit the placeholder version of mcp.json, and give each developer instructions to set their own DAZZM_API_KEY variable locally. Never commit a real API key.

5. Verify the connection

On startup, the assistant connects to the configured MCP servers. If one of them fails, an error is displayed. If there is no error, the MCP server most likely loaded successfully.

To confirm, open the assistant’s chat and check the list of active MCP tools/servers — your DAZZM server should appear there.

You can also test access directly from a terminal before relying on the VS Code configuration:

npx -y mcp-remote https://<app-name>-<env-name>.apps.dazzm.com/api/prod/mcp --header "api-key:<YOUR_API_KEY>"

If the command starts successfully, the remote MCP server is reachable and the authentication header is valid.

Troubleshooting

If the MCP tool does not appear:

• Check that Node.js and npm are installed;
• Confirm that the URL is correct;
• Confirm that the API key is valid;
• Reload VS Code after changing the configuration;
• Make sure the configuration file is in the right location for the chosen scope;
• Check that the file is valid JSON;
• Test the npx command directly in a terminal.

Common issues: a JSON syntax error, a missing or invalid API key, the wrong path for the configuration file, an assistant not refreshed after a configuration change, or an environment that does not accept the request format used.

Tips

If you connect the assistant to a brand-new application, it has few examples to rely on to find the right solutions. These two tips help it find some:

Connect a reference application. Register a second MCP connection, this time to one of your complete, well-built applications. Choose any application you like, create an API key for it as well (step 1), then add it to the configuration and name that connector dazzm-examples. The name matters: it is what tells the assistant that this is a registry of examples, and it will intuitively use it to draw on good DAZZM practices.

Point the assistant to the documentation. At the start of a conversation, you can simply ask it to visit doc.dazzm.com to find more examples and guides about the platform.

Choosing the right environment

The MCP server can act on any environment, but not all uses are equal:

1. Nominal case — development environment. This is what the MCP server was designed for: the assistant can freely manipulate definitions and test data there.
2. Acceptable case — production environment, read-only. It is possible to connect the MCP server to a production environment if the goal is to use its data reading capabilities for analysis.
3. Strongly discouraged case — writing data outside a test environment.

Modifying data through the MCP server

The MCP server is capable of modifying data in a non-test environment, but this is strongly discouraged. Writing through the MCP server bypasses all of the application’s constraints and business rules: data is written directly to the database, which can lead to integrity errors that crash the application.