Power Automate

Power Automate Solution

DKN

Your AI Coding Agent Can Now Build and Manage Dataverse — Here’s How

The way enterprise software gets built is changing fast. Rather than manually piecing together APIs, command-line tools, and custom scripts, developers are increasingly turning to AI agents — describing what they need and letting the agent figure out the execution. But for that shift to work with platforms like Microsoft Dataverse, the platform itself needs to be something agents can actually understand and operate.

That’s exactly what Dataverse Skills delivers. Released as an open-source plugin for GitHub Copilot and Claude Code, Dataverse Skills gives AI coding agents deep, practical knowledge of Dataverse — from connecting and authenticating to building schemas, loading data, and running analytical queries. All of it driven by natural language.

What Are Dataverse Skills, Really?

At its core, Dataverse Skills is a plugin that teaches your coding agent how to work with Dataverse. It doesn’t expose a menu of commands for you to choose from. Instead, you describe your goal in plain English, and the agent decides which skills to apply, in what sequence, using which underlying tools.

Think of it as giving your AI agent a domain expert’s knowledge of Dataverse — without you needing to be that expert yourself.

The underlying engine uses the Power Platform CLI (PAC CLI) for authentication, solution management, and automation tasks, paired with the Dataverse Web API and Python SDK for data operations. But you never have to think about any of that. Natural language is the only interface you need.

Three Phases, One Unified Experience

The plugin’s capabilities are organized around three core phases of any Dataverse project:

1. Connect

The agent discovers your Dataverse environments, authenticates using PAC CLI or Azure CLI, registers the Dataverse MCP server, and sets up a consistent project structure. You don’t configure anything manually — the agent handles the entire discovery and initialization process.

2. Build

Once connected, the agent can scaffold full data models from scratch: tables, columns, choice fields, lookup relationships, many-to-many relationships, forms, and views. It picks the right tool for each task — MCP for quick reads, the Python SDK for bulk operations, and the Web API as needed — and registers every component into your solution automatically.

3. Operate

With the schema in place, the agent can load data, run cross-table analytical queries, and bulk-import records from CSV files. Need 50 realistic sample records with domain-specific content generated on the fly? One prompt is all it takes.

Seeing It in Action

Here’s a real example of what this looks like in practice. You open your terminal, install the plugin with a single command, and type:

“I’m building a logistics and inventory management system for Veloce Apparel. I need tables for Warehouses, Products, Suppliers, Shipments, and Incidents — with lookups, a many-to-many between Products and Suppliers, and a self-referential shipment routing chain (tracking a package’s journey through hub transfers). Create everything in a VeloceLogistics solution, load sample data, and show me which shipments are currently delayed or stuck in transit.”

From that single prompt, the agent autonomously:

  1. Discovers your Dataverse environment and configures MCP
  2. Creates the solution using PAC CLI
  3. Builds five tables with choice columns, lookups, and a many-to-many relationship
  4. Generates and runs a Python script to bulk-load realistic sample data
  5. Queries across tables to answer the business question

No toggling between documentation tabs. No manual CLI commands. No context switching. The agent orchestrates everything from end to end.

Works With Both GitHub Copilot and Claude Code

Development teams rarely standardize on a single AI coding tool. Some developers prefer GitHub Copilot; others work with Claude Code. Dataverse Skills was built with this reality in mind. Since the skills are written as plain Markdown files with YAML frontmatter — not compiled binaries or proprietary formats — the same plugin works identically in both environments.

Install it from the plugin marketplace for either agent and you get the same knowledge, the same safety checks, and the same results. One investment, both tools covered.

Open Source and Built to Extend

The project is MIT-licensed and openly available on GitHub. Each skill is a standalone Markdown file — readable, editable, and extensible without any compiled code. Teams can add new skills for their own Dataverse customizations, improve existing ones, or contribute bug fixes back via pull request. The architecture is deliberately approachable for anyone who wants to tailor it to their environment.

A Broader Shift in How Platforms Get Used

Dataverse Skills is more than a productivity tool — it signals a broader direction for enterprise platforms. As AI agents become a standard part of the developer workflow, the platforms they interact with need to be operable through intent, not just through traditional interfaces. Describing what you want and having it built, configured, and queryable in your environment is no longer a future concept. With Dataverse Skills, it’s available today.

Getting Started

Install the plugin with one command:

  • GitHub Copilot (VS Code): /plugin install dataverse@awesome-copilot
  • Claude Code: /plugin install dataverse@claude-plugins-official

Then describe your intent and let the agent do the rest.

Original article: Dataverse Skills: Your Coding Agent Now Speaks Dataverse by Suyash Kshirsagar, Microsoft.

DKN

Say Goodbye to Repetitive Admin Tasks: Dataverse Admin Skills Now in Public Preview

If you’ve ever spent an afternoon clicking through the Power Platform Admin Center to apply the same setting across a dozen Dataverse environments, you’ll understand the frustration. Microsoft has now addressed exactly that pain point with the public preview launch of Dataverse Admin Skills — a capability that brings natural language administration to your coding tool, whether that’s GitHub Copilot or Claude Code.

The Admin Bottleneck Problem

Picture this: your security team requests that auditing be enabled across all 20 of your Dataverse environments — today. Without automation, that means 20 separate logins, 20 sets of clicks, and 20 opportunities for human error. Alternatively, you put in a request to a developer to write a bulk script — and wait.

This is the exact gap Dataverse Admin Skills is designed to close. Instead of navigating admin consoles or waiting on scripts, you simply describe what you want in plain English, and the agent handles the rest.

How It Works

Dataverse Admin Skills operates through two complementary paths:

  • Natural Language (Agentic) Path: Using the Dataverse Skills Plugin inside GitHub Copilot or Claude Code, you describe your intent in plain English. The plugin translates your request into the appropriate PAC CLI commands, executes them against the Dataverse Web API, and gives you a clear summary of what changed. It supports multi-environment parallel execution and enforces built-in safety guardrails — including confirmation prompts before any destructive actions.
  • Direct Scripting Path: The same PAC CLI commands powering the agentic experience are available for use in Bash, PowerShell, or SDK scripts. This makes it ideal for CI/CD pipelines, runbooks, and repeatable automation workflows.

Both paths rely on PAC CLI (v2.6+, .NET Framework) and the Dataverse Web API, ensuring a consistent and trusted execution layer.

A Real Example

Say you type: “Enable AllowMCP setting on all environments starting with Preprod.”

Here’s what happens behind the scenes:

  1. The agent lists your Dataverse environments.
  2. It filters for environments matching your criteria.
  3. It asks you to confirm the target list before making any changes.
  4. It updates each environment in parallel.
  5. It presents a summary table of every change made.

One sentence. No browser tabs opened. No scripts written.

What’s Available Right Now

  • Settings Management: Read and update 37 allowlisted PPAC toggles across environments — covering MCP, audit, retention, recycle bin, search, Microsoft Fabric integration, security, and more. Works on a single environment or in bulk with parallel execution.
  • Bulk Delete: Schedule, monitor, pause, resume, and cancel bulk delete jobs. Safety is built in — confirmation prompts, FetchXML validation, and warnings for system tables help prevent accidental data loss.
  • Long-Term Retention: Enable retention on entities, set archival criteria using FetchXML, and track retention jobs. Particularly valuable for compliance scenarios where data needs to be retained but not kept in active storage.
  • Capacity Management (Coming Soon): Storage breakdowns, growth trends, capacity alerts, and archival recommendations — all accessible from your coding tool.

Getting Started in Three Steps

Step 1: Install the Plugin

  • In GitHub Copilot (VS Code): /plugin install dataverse@awesome-copilot
  • In Claude Code: /plugin install dataverse@claude-plugins-official

Step 2: Connect Your Environments

Open your coding tool and ask: “List all my Dataverse environments.” The agent will install PAC CLI if needed, authenticate you, and return your environment list. If anything is missing, it walks you through setup.

Step 3: Try It Out

Here are some prompts to get started:

  • “Enable the Microsoft Fabric integration on all production environments.”
  • “What is the recycle bin retention period for my sandbox environment?”
  • “Disable Dataverse search across all environments in the Europe region.”
  • “Cancel all system jobs that have been stuck in a waiting state since yesterday.”
  • “Set the long-term retention criteria for the custom log table to archive records older than 2 years.”

Why This Matters

Dataverse Admin Skills represents a meaningful shift in how platform administrators interact with their environments. Rather than being constrained by what a UI exposes or waiting for a developer to write automation scripts, admins can now express intent directly — and act on it at scale. The safety guardrails (allowlists, confirmation prompts, parallel execution controls) mean this power comes without sacrificing governance.

This is currently a public preview release, with Microsoft actively refining and expanding the skill set. Now is a great time to explore what it can do.

Original article: Agentic Administration: Dataverse Admin Skills now available in Public Preview by Anirudha Bakore, Microsoft.

DKN

Connect to Dynamics 365 CRM Online using a client ID and secret in a C# console app

1. Prerequisites

  • Install the Dynamics 365 SDK assemblies. You can install the necessary NuGet packages, such as:
  • Microsoft.CrmSdk.CoreAssemblies
  • Microsoft.CrmSdk.XrmTooling.CoreAssembly
  • Register your app in Azure Active Directory (AAD) to retrieve the client ID, client secret, and tenant ID.

2. Code Implementation

The following code demonstrates how to authenticate and interact with Dynamics 365 CRM using the CRM SDK:

using System;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Tooling.Connector;

class Program
{
    static void Main(string[] args)
    {
        string clientId = "Your_Client_ID";
        string clientSecret = "Your_Client_Secret";
        string tenantId = "Your_Tenant_ID";
        string crmUrl = "https://Your_CRM_Organization.crm.dynamics.com/";

        // Create connection string
        string connectionString = $@"
            AuthType=ClientSecret;
            ClientId={clientId};
            ClientSecret={clientSecret};
            TenantId={tenantId};
            Url={crmUrl};";

        // Establish connection
        CrmServiceClient serviceClient = new CrmServiceClient(connectionString);

        if (serviceClient.IsReady)
        {
            Console.WriteLine("Connected to CRM successfully!");

            // Example: Retrieve accounts
            IOrganizationService service = serviceClient.OrganizationServiceProxy;
            QueryExpression query = new QueryExpression("account")
            {
                ColumnSet = new ColumnSet("name", "accountnumber")
            };

            EntityCollection results = service.RetrieveMultiple(query);

            foreach (var entity in results.Entities)
            {
                Console.WriteLine($"Account Name: {entity.GetAttributeValue<string>("name")}, Account Number: {entity.GetAttributeValue<string>("accountnumber")}");
            }
        }
        else
        {
            Console.WriteLine($"Failed to connect: {serviceClient.LastCrmError}");
        }
    }
}

3. Explanation

  • Authentication: The connection string uses AAD authentication with the client ID, client secret, and tenant ID.
  • Connection: CrmServiceClient establishes a connection to Dynamics 365.
  • Query: The QueryExpression retrieves data from the CRM, such as accounts in this example.

Note : This article was created with assistance from AI and there could be mistakes / error