Power Platform12 min read

Create Dataverse Tables with GitHub Copilot in VS Code: A Practical Setup Guide

Create Dataverse Tables with GitHub Copilot in VS Code: A Practical Setup Guide
A practical setup guide to installing Microsoft's Dataverse skills in a local VS Code workspace, connecting GitHub Copilot via .mcp.json, and creating and verifying Dataverse tables.

Describing a business requirement is easier than translating it into tables, columns, choices, and relationships. With Microsoft’s Dataverse tooling connected to GitHub Copilot in Visual Studio Code, an AI agent can help design that model and apply approved changes to a real Dataverse environment.

This guide follows one path: install Microsoft’s Dataverse skills into a local VS Code workspace, connect that workspace to a specific environment, and use Copilot to create and verify a table. Additional tools are explained only where they support that workflow.

ℹ️

Scope: This is a development and data-model authoring setup, not a promise that one MCP connection exposes every Dataverse administration feature. The native MCP server supports table creation and metadata updates. Microsoft’s skills extend the workflow through the Dataverse CLI, Python SDK, and Power Platform CLI when appropriate. Actual capabilities depend on the connected tools, environment, and signed-in user’s permissions. [1][2]

What the Finished Setup Looks Like

You will have:

  • A local VS Code workspace with GitHub Copilot enabled.
  • Microsoft’s Dataverse skills available to the agent.
  • A local MCP configuration pointing to your chosen Dataverse environment.
  • Authentication for the tools used by the skills.
  • Instructions requiring environment confirmation, schema review, and verification before reporting success.

The MCP server runs in Dataverse. VS Code is the client. A local configuration file does not mean you need to build or host a local MCP server. Microsoft’s documented VS Code connection uses the environment’s HTTP endpoint directly. [3]

There are two complementary layers:

LayerResponsibility
Dataverse skillsTeach Copilot how to connect, design metadata, work with solutions, and select suitable tools.
Dataverse MCP and supporting Microsoft toolsExecute operations against the environment.

Installing skills alone does not grant access to Dataverse. Adding an MCP URL alone does not authenticate the user or grant customization permissions. [2][4]

Architecture and layers diagram showing the local VS Code workspace (Copilot Agent Mode, .github/skills/, .mcp.json, and copilot-instructions.md), the direct remote HTTP MCP and local supporting tool paths, and the Dataverse environment with security roles and unmanaged solutions

1. Prepare the Prerequisites

Use an existing development or sandbox environment with a Dataverse database for the first test. Microsoft’s repository also points to the Power Apps Developer Plan as an option for obtaining a development environment. [2]

Before proceeding, have:

  1. A current installation of Visual Studio Code.
  2. GitHub Copilot access, with your organization’s policies permitting the required agent and MCP features.
  3. A Microsoft account with access to the target Dataverse environment and permission to customize its schema.
  4. A Power Platform administrator who can enable the GitHub Copilot MCP client for that environment.
  5. The environment’s actual instance URL.
  6. An existing unmanaged solution and its publisher prefix, or an agreed name and prefix for a new development solution.

Dataverse MCP respects Dataverse security roles and row-level security. A successful connection does not mean the account can create tables. Use an appropriately authorized development account, rather than assuming that enabling MCP grants additional privileges. [5]

Get the Correct Environment URL

  1. Open Power Apps.
  2. Select the intended environment.
  3. Select Settings, the gear icon.
  4. Select Session details.
  5. Copy Instance URL. [3]

For the examples below, the instance URL is:

Code
https://contoso.crm.dynamics.com

Replace this example with your actual URL. Preserve its regional hostname; do not change it to match the example.

2. Install VS Code and Enable GitHub Copilot

Install or update VS Code using the official Visual Studio Code download page. Choose the installer for your operating system.

Then:

  1. Open Extensions in VS Code.
  2. Find and install the GitHub Copilot extension.
  3. Complete GitHub sign-in.
  4. Open the Chat view.
  5. Select Copilot as the session target or harness where that selector is available, and use agent mode for the tasks in this guide. [3][4]
⚠️

Current configuration matters: Microsoft’s November 2026 VS Code documentation recommends native Copilot MCP configuration for new setups. This guide uses workspace-root .mcp.json with a top-level mcpServers object, not the older .vscode/mcp.json format with servers. These formats should not be mixed. [6]

3. Download Microsoft’s Dataverse Skills

For this walkthrough, install the skills directly from the official Microsoft repository. This keeps the source visible and avoids depending on a separate skills installer or marketplace experience.

Download the Repository

  1. Open Microsoft Dataverse Skills on GitHub.
  2. Select Code.
  3. Select Download ZIP.
  4. Extract the archive locally.
  5. Create a separate working folder named dataverse-copilot.
  6. In VS Code, select File > Open Folder and open dataverse-copilot.

The repository’s canonical plugin directory is .github/plugins/dataverse. It contains skills, scripts, and templates, among other plugin resources. [2][7]

Copy the Skills and Supporting Resources

From the extracted repository, copy:

Source in the extracted repositoryDestination in your workspace
.github/plugins/dataverse/skills.github/skills
.github/plugins/dataverse/scriptsscripts
.github/plugins/dataverse/templatestemplates

This is a workspace installation adapted from VS Code’s documented support for copying existing skills. Copy the complete skill directories, including their references and supporting files, not just the SKILL.md files. The shared scripts and templates are retained because the Dataverse workflows can reference them. [7][8][9]

The important result is that files such as these exist:

Code
.github/skills/dv-connect/SKILL.md
.github/skills/dv-metadata/SKILL.md
.github/skills/dv-solution/SKILL.md
.github/skills/dv-overview/SKILL.md
scripts/auth.py

VS Code documents .github/skills/ as a supported project location for the Copilot harness. Simply leaving the skills nested inside the downloaded plugin directory is not the same as installing them into that location. [8]

Verify Skill Discovery

  1. Start a fresh Copilot chat in the workspace.
  2. Open the Command Palette.
  3. Run Chat: Open Customizations.
  4. Select Skills.
  5. Confirm that the Dataverse skills appear.
  6. Type / in chat to inspect the available skill commands, where exposed. [8]

For this guide, the key skills are:

  • dv-connect: setup, authentication, connection diagnostics, and MCP registration.
  • dv-metadata: tables, columns, relationships, forms, and views.
  • dv-solution: solution creation, export, import, and deployment.
  • dv-overview: shared rules and routing to the appropriate specialist. [2]

Review the downloaded instructions and scripts before approving their execution. Skills can run commands and interact with external systems. [8]

Workspace installation diagram and VS Code UI mockup illustrating how skills, scripts, and templates map from the extracted microsoft/Dataverse-skills repository into dataverse-copilot, alongside the root .mcp.json config and Chat: Open Customizations skill discovery check

4. Enable GitHub Copilot Access in the Environment

A Power Platform administrator performs this step:

  1. Open the Power Platform admin center.
  2. Select Manage > Environments.
  3. Open the target environment.
  4. Select Settings > Product > Features.
  5. Locate Dataverse Model Context Protocol.
  6. Turn on Allow MCP clients to interact with Dataverse MCP server if necessary.
  7. Select Advanced Settings.
  8. Open the Microsoft GitHub Copilot client record.
  9. Set Is Enabled to Yes.
  10. Select Save & Close. [10]

Microsoft specifies the Power Platform administrator role for managing these settings. A Managed Environment is required when managing MCP through Advanced connector policies; that is not the same as saying every direct MCP connection requires a Managed Environment. [10]

5. Configure the Local Workspace’s MCP Connection

Create a file named .mcp.json at the root of dataverse-copilot:

Code
{
  "mcpServers": {
    "dataverseDev": {
      "type": "http",
      "url": "https://contoso.crm.dynamics.com/api/mcp",
      "tools": ["*"]
    }
  }
}

Replace the example URL with your instance URL followed by /api/mcp.

This uses the native Copilot workspace format documented by VS Code. The tools setting makes the server’s tools available; it does not bypass individual tool approvals or Dataverse permissions. [6]

Use /api/mcp, the generally available endpoint, for this walkthrough. The separate /api/mcp_preview endpoint exposes preview capabilities that can change or be removed. [5]

Start and Authenticate the Connection

  1. Save .mcp.json.
  2. Start a new Copilot session in the same workspace.
  3. Run Chat: Open Customizations and select MCP Servers.
  4. Confirm that dataverseDev appears.
  5. Review any server trust request.
  6. Complete the sign-in or Authenticate action when prompted, using the account authorized for the target environment. [4][6]

If the connection is not immediately visible, inspect the server configuration and output through the MCP controls. A read-only tool request can help establish whether the connection is actually usable. [4]

🔐

Do not add passwords, access tokens, or populated authorization headers to .mcp.json. OAuth sign-in, server trust, and approval of an individual operation are separate steps. [6]

No custom local proxy is required for this direct HTTP route. The local file tells Copilot how to reach Microsoft’s remote Dataverse MCP server. [3]

Four-gate connection flow and UI mockup covering Power Platform Admin Center enablement for Microsoft GitHub Copilot, root .mcp.json configuration, VS Code server trust and OAuth authentication, and live read-only verification against the Account table

6. Run the Dataverse Connection Skill

The HTTP connection enables native MCP tools. For the broader skills-based authoring workflow, also initialize the supporting tooling.

In Copilot chat, enter:

Code
Use the dv-connect skill to connect this workspace to the existing
Dataverse environment at https://contoso.crm.dynamics.com.

Reuse the existing dataverseDev HTTP MCP entry in .mcp.json.
Do not create a duplicate MCP entry or switch environments.

Check the installed tools and explain any required installations before
running them. Set up authentication for the supporting Dataverse tools
using the same account and environment.

Do not create tables, change security roles, or modify environment settings.
Finish by reporting the connected environment and any incomplete setup steps.

Replace the URL before submitting.

The current dv-connect skill checks tooling including Python, Node.js, the Dataverse CLI, and PAC CLI, and initializes authentication and helper resources. Its normal setup is broader than a minimal HTTP MCP connection. Review the commands and installation approvals it requests. [9]

The official Dataverse CLI package used by the skill is:

Code
@microsoft/dataverse

The Python SDK package used by the skill is:

Code
PowerPlatform-Dataverse-Client

PAC has a separate authentication surface. Signing into the Dataverse CLI does not automatically establish PAC authentication; the connection skill accounts for both. [9]

If the skill proposes a different MCP configuration, ask it to explain why. Keep one clearly identified connection to the intended environment rather than accumulating duplicate entries.

7. Set the Solution and Working Rules

Before creating metadata, decide which unmanaged solution will contain the components and which publisher prefix will be used.

Microsoft’s metadata skill requires confirmation of the target environment, solution, and publisher prefix before the first metadata change. It also recommends making changes in the environment and exporting the resulting solution, rather than hand-authoring solution XML to create new components. [11]

Create .github/copilot-instructions.md with the following project guidance:

Code
# Dataverse development rules

- Use the installed Microsoft Dataverse skills for Dataverse tasks.
- Confirm the target environment before the first write in each session.
- Confirm the solution unique name and publisher prefix before creating metadata.
- Inspect existing tables, columns, choices, and relationships before creating them.
- Present the proposed schema and wait for approval before applying changes.
- Keep custom components in the agreed unmanaged solution.
- Use actual discovered tool capabilities; do not invent tool names or parameters.
- Use MCP where it supports the task. Follow the installed skill's documented
  SDK or CLI workflow where that is more appropriate.
- Explain when an operation requires a supporting tool instead of MCP.
- Never delete components, change security, or switch environments without approval.
- Never commit credentials, tokens, or populated .env files.
- After a write, retrieve the resulting metadata and verify the requested settings.
- Report successful changes, failed steps, and anything not verified separately.

VS Code distinguishes project instructions, which provide ongoing guidance, from skills, which provide task-specific workflows. Both have a role in this setup. [8]

These instructions are workflow safeguards, not a security boundary. Dataverse permissions and organizational policies remain the actual access controls.

If setup creates a .env file, exclude it from source control. A minimal .gitignore entry is:

Code
.env
.venv/

8. Verify the Connection Without Making Changes

Before asking the agent to create a table, submit a read-only test:

Code
Use the connected Dataverse tools to inspect the Account table.
Show its actual logical name, primary name column, and a few existing columns.

Use a real tool call, not general knowledge.
Do not create or update anything.

Expand the tool activity in chat. Confirm that it used the expected environment and returned live metadata.

A plausible answer is not proof of a working connection. VS Code explicitly recommends verifying the first tool call and inspecting its result. [4]

The documented native MCP metadata tools include search and describe; table writes include create_table and update_table. Check the tools actually exposed in your session before relying on them. [1]

9. Describe and Create a Table

Use a specific request that includes both the business model and the deployment context. The following is an example, not a required naming convention:

Code
Use the dv-metadata skill to design an Automation Request table.

Target environment: https://contoso.crm.dynamics.com
Solution unique name: AutomationDevelopment
Publisher prefix: aut

Use the existing solution and publisher. If either is missing, stop and ask.

Table requirements:
- Display name: Automation Request
- Plural display name: Automation Requests
- Schema name: aut_AutomationRequest
- Ownership: User or team owned
- Primary name column: Request Name, text, maximum 200 characters

Additional columns:
- Request Description: multiline text, maximum 4000 characters
- Request Type: local choice with Distribution Group Management,
  Outside UAE Access, and Other
- Requested By: lookup to the existing system user table
- Processing Status: local choice with New, In Progress, Completed, and Failed
- Submitted On: date and time, user-local behavior
- Completed On: date and time, user-local behavior, optional
- Estimated Cost: currency, precision 2
- Retry Count: whole number, minimum 0, maximum 10
- Requires Approval: yes/no, default No

First inspect existing metadata and check for naming conflicts.
Show the proposed schema, choice values, relationship names, and any
unsupported requirements. Do not create anything until I approve.

Replace the environment, solution, and prefix with your own values.

Review the Proposal

Check:

  • The environment and solution are correct.
  • Schema names use the intended publisher prefix.
  • The primary name column is correct.
  • Ownership matches the access model.
  • Text lengths, number ranges, defaults, and date/time behavior are explicit.
  • Choice labels and underlying values are sensible.
  • The lookup targets the intended existing table.
  • Requiredness is defined at the intended level.

Do not accept a generic type label as proof of the exact Dataverse type. For example, a currency requirement should be verified as currency metadata, not assumed correct because a helper accepts a money type string. Likewise, a lookup requires the appropriate relationship, not a text column containing an identifier.

The current metadata skill prefers the Python SDK for table creation and documents Web API fallback for advanced properties the SDK does not expose. Installing the skills does not force every metadata operation through MCP. That tool selection is part of the skill’s workflow. [11]

Approve the Write

After reviewing the proposal, submit:

Code
Approved. Create the proposed table, columns, choices, and relationship
in the confirmed development environment and solution.

Do not modify unrelated components. If a requested setting cannot be
implemented with the available tools, report it rather than substituting
another type or silently skipping it.

After creation, retrieve the actual metadata and compare it with the
approved proposal. Verify solution membership and report any differences.

Review the requested tool and terminal approvals. Keep write approvals explicit for the first deployment.

Five-stage human-gated table authoring and verification workflow from confirming environment, solution, and prefix through metadata inspection, aut_AutomationRequest schema review, explicit approval gate, skill-driven execution, and dual verification in Power Apps

10. Verify the Result in Dataverse

Do not stop at the agent’s success message.

  1. Open Power Apps.
  2. Select the same environment.
  3. Open Solutions and the agreed solution.
  4. Confirm the table is included.
  5. Inspect its columns and relationships.
  6. Compare the actual settings with the approved proposal.

Ask Copilot for a final verification report covering:

  • Table schema and logical names.
  • Ownership and primary name column.
  • Column types and relevant settings.
  • Choice labels and values.
  • Lookup target and relationship.
  • Solution membership.
  • Failed, incomplete, or unverified requirements.

This separates a proposed design from a verified implementation. Keep that distinction when moving beyond a single table to a larger data model.

Do You Need PAC CLI or the Web API?

PAC CLI: Not Required for Direct HTTP MCP, Useful for the Complete Workflow

Microsoft’s direct VS Code MCP setup does not list PAC as a prerequisite. For connecting Copilot to /api/mcp and using the exposed MCP tools, it is not inherently required. [3]

However, Microsoft’s full connection skill prepares PAC for solution and administration workflows. For a workspace intended to support ongoing Dataverse development, keep it available. [9]

Its main additional benefit is solution lifecycle management: exporting the environment-created components, unpacking them into source control, and importing or promoting solutions to another environment. [2][11]

The Power Platform Tools VS Code extension is Microsoft’s recommended way to install Power Platform CLI. [12]

Recommendation: Let the connection skill check and prepare PAC, but do not confuse PAC with the native MCP table-creation tool.

Web API: No Separate Installation, an Advanced Metadata Fallback

The Dataverse Web API is part of the service, not another VS Code extension or local server.

You do not need to hand-write REST requests to start using the native MCP connection. The metadata skill can nevertheless use the Web API when a requested property needs lower-level control. [11]

Microsoft documents table creation through:

Code
POST [Organization URI]/api/data/v9.2/EntityDefinitions

For solution-aware metadata creation, the documented optional header is:

Code
MSCRM.SolutionUniqueName: YourSolutionUniqueName

The Web API also supports column definitions and relationship metadata. It is the fallback when exact metadata requirements exceed the selected higher-level tool’s capabilities. [13][14]

Recommendation: Keep Web API use inside a reviewed skill-driven workflow. There is no need to make manual REST programming the main tutorial path.

Four-column comparison of Dataverse execution layers contrasting Native Dataverse MCP (/api/mcp), Python SDK and Dataverse CLI, Power Platform CLI (PAC) for solution ALM, and the Dataverse Web API EntityDefinitions fallback

Troubleshooting

SymptomWhat to check
Skills do not appearConfirm complete skill directories are under .github/skills/, then start a fresh session and inspect Skills in Agent Customizations.
MCP entry does not appearConfirm .mcp.json is at the open workspace root and uses mcpServers; inspect the session’s MCP controls.
Sign-in failsCheck the exact instance URL, enabled GitHub Copilot client, account, and organizational access restrictions.
Reading works but table creation failsCheck customization permissions and the actual error; successful read access does not grant write privileges.
Copilot gives advice but performs no actionInspect tool activity and explicitly request the installed skill and a real tool call.
A supporting script cannot runInspect the connection skill’s dependency checks and authentication results; MCP authentication and supporting-tool authentication are separate.
The agent cannot implement a requested settingAsk it to identify the unsupported property and the documented SDK or Web API route, without silently changing the requirement.

These checks follow Microsoft’s guidance on skill discovery, MCP configuration, authentication, permissions, and supporting-tool setup. [4][5][8][9]

Layered troubleshooting diagnostic map isolating symptoms and checks across skill discovery, workspace .mcp.json configuration, OAuth and admin enablement, RBAC permissions vs tool calls, and supporting script authentication or Web API fallbacks

Licensing and Consumption

A GitHub Copilot subscription should not be treated as covering every Dataverse operation.

Microsoft states that Dataverse MCP tools used by agents outside Copilot Studio are charged, subject to documented qualifying-license exceptions for access to Dynamics 365 data. Its current tool documentation also distinguishes search_data consumption from other MCP tools. Confirm the applicable licensing and billing arrangement for the environment before broad use. [1][5]

Final Checklist

Before using the workspace for real development, confirm:

  • GitHub Copilot works in the intended VS Code session.
  • Microsoft’s Dataverse skills are discovered.
  • The environment allows the GitHub Copilot MCP client.
  • .mcp.json points to the intended environment’s /api/mcp endpoint.
  • A real read-only tool call succeeds.
  • Supporting-tool setup and authentication are complete for the chosen workflows.
  • The solution and publisher prefix are confirmed.
  • The agent requests approval before writes.
  • Created metadata is checked against the approved design.
  • Credentials are excluded from source control.

The result is a practical Dataverse authoring workspace: describe the model, review the proposal, approve the changes, and verify the actual environment. Native MCP supplies a direct connection, while Microsoft’s skills and supporting tools provide the broader workflow needed for reliable development.

Official Sources

  1. Dataverse MCP server and current tools
  2. Microsoft Dataverse Skills repository
  3. Connect Dataverse MCP with GitHub Copilot in VS Code
  4. Add and use MCP servers in VS Code
  5. Dataverse MCP FAQ
  6. VS Code MCP configuration reference
  7. Canonical Dataverse plugin directory
  8. Use Agent Skills in VS Code
  9. Microsoft dv-connect skill
  10. Configure the Dataverse MCP server for an environment
  11. Microsoft dv-metadata skill
  12. Install the Power Platform Tools VS Code extension
  13. Create and update table definitions with the Web API
  14. Create and update column definitions with the Web API

Discussion

Loading...