⚡ Azure Functions for Microsoft Dataverse CRUD

In the previous article of this series, we covered how to set up authentication and a secure connection between SitecoreAI (Sitecore XM Cloud) and Microsoft Dataverse. If you haven’t read that yet, start with SitecoreAI Dataverse Authentication and Connection .

This session moves from connection setup to actual implementation. We’ll build a production-ready Azure Functions backend that exposes clean CRUD operations against Microsoft Dataverse.

The goal is straightforward:

HTTP-triggered Azure Functions are a natural fit here - Microsoft’s documentation describes the HTTP trigger as a way to invoke a function with an HTTP request, which is exactly what’s needed to build a lightweight serverless API. For the Dataverse side, we’ll use the modern Microsoft.PowerPlatform.Dataverse.Client package and its ServiceClient class, which Microsoft positions as the primary implementation for Dataverse operations and which authenticates through MSAL rather than the older ADAL-based clients.

Once you have a working Dataverse connection, the next question is usually: how should a website, a SitecoreAI workflow, or an AI agent safely create, update, and delete Dataverse records?

Calling Dataverse directly from a frontend is rarely the right production pattern - it exposes too much implementation detail, complicates validation, and makes security harder to reason about. A better approach keeps Dataverse behind a controlled backend layer, where each function represents one business operation rather than a generic table endpoint.

This pattern is a good fit when:

• SitecoreAI (Sitecore XM Cloud) needs to submit structured data into Dataverse.
• A Next.js frontend needs a secure backend endpoint.
• An internal workflow needs lightweight automation.
• A future MCP tool needs predictable, auditable server-side operations.
• You want Dataverse credentials and business rules kept away from the browser.

That makes the isolated worker model the right choice for a production-grade Dataverse integration today.

This article is part of a practical Dataverse integration series:

• Architecture and integration concept.
• Authentication and secure connection between SitecoreAI (Sitecore XM Cloud) and Dataverse.
• Azure Functions for CRUD operations against Dataverse (this article).
• Calling the Azure Functions from SitecoreAI, Next.js, or MCP workflows.

In the previous article we focused on getting the connection model right. This article builds the operational layer on top of it.

The production pattern has four layers:

Azure Functions integrate directly with Application Insights, which collects the logs, performance data, and errors generated by the function app - this becomes important once you have several CRUD endpoints running in production.

For secrets, Azure Functions can reference values stored in Azure Key Vault as application settings, so the running code reads them like any other configuration value while the actual secret material stays in the vault.

For this article, assume we’re storing a simple business enquiry in Dataverse.

Example Dataverse table:

Example table logical name: crf51_sitecoreenquiry

In a real implementation, confirm the table logical name, column logical names, required fields, choice values, and security roles directly against your own Dataverse environment before wiring up code.

Dataverse’s Web API basic-operations documentation walks through the same create, retrieve, update, and delete pattern we’re implementing here, just via HTTP rather than the SDK. We’re using the .NET ServiceClient instead because Microsoft explicitly positions the Dataverse.Client package as the client applications should transition to, replacing the older CrmServiceClient.

Step 1: Create the Azure Functions Project

Create a .NET isolated worker Functions project:

func init SitecoreAI-Dataverse-Azure-Functions --worker-runtime dotnet-isolated --target-framework net9.0
cd SitecoreAI-Dataverse-Azure-Functions

Add HTTP trigger functions inside Functions folder:

• CreateDataverseRecord

  Azure Function for creating new enquiry records in Microsoft Dataverse.

• UpdateDataverseRecord

  Azure Function for updating existing enquiry records in Microsoft Dataverse.

• DeleteDataverseRecord

  Azure Function for deleting enquiry records from Microsoft Dataverse.

• GetEnquiriesFunction

  Azure Function for retrieving multiple enquiry records from Microsoft Dataverse.

• GetEnquiryFunction

  Azure Function for retrieving a single enquiry record by ID from Microsoft Dataverse.

• GetEnquiriesByEmailFunction

  Azure Function for retrieving enquiry records filtered by email address from Microsoft Dataverse.

dotnet add package Microsoft.Azure.Functions.Worker
dotnet add package Microsoft.Azure.Functions.Worker.OpenTelemetry
dotnet add package Microsoft.Data.SqlClient
dotnet add package Microsoft.PowerPlatform.Dataverse.Client
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package Azure.Monitor.OpenTelemetry.Exporte
dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Http.AspNetCore
dotnet add package Microsoft.Azure.Functions.Worker.Sdk

For local development, use local.settings.json:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
    "DataverseEnvironment": "YOUR-DATAVERSE-ENVIRONMENT",
    "ClientId": "YOUR-CLIENT-ID",
    "ClientSecret": "YOUR-CLIENT-SECRET"
  }
}

Step 4: Configure Dependency Injection

Program.cs:

using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using SitecoreAI.Dataverse.AzureFunctions.Services;

// Create and configure the Azure Functions application builder
var builder = FunctionsApplication.CreateBuilder(args);

// Configure the Functions Web Application middleware
builder.ConfigureFunctionsWebApplication();

// Register application services for dependency injection
// IDataverseService: Service for interacting with Microsoft Dataverse
builder.Services.AddSingleton<IDataverseService, DataverseService>();

// Build and run the application
builder.Build().Run();

Standard .NET dependency injection is one of the concrete advantages the isolated worker model gives you over in-process-you get full control of the startup pipeline instead of relying on the Functions host’s binding infrastructure.

Request Models

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SitecoreAI.Dataverse.AzureFunctions.Models;

/// <summary>
/// Response model representing an enquiry retrieved from Dataverse.
/// </summary>
public sealed class EnquiryResponse
{
    /// <summary>Gets or sets the unique identifier of the enquiry.</summary>
    public Guid Id { get; set; }
    
    /// <summary>Gets or sets the name of the person submitting the enquiry.</summary>
    public string? Name { get; set; }
    
    /// <summary>Gets or sets the email address of the person submitting the enquiry.</summary>
    public string? Email { get; set; }
    
    /// <summary>Gets or sets the message content of the enquiry.</summary>
    public string? Message { get; set; }
    
    /// <summary>Gets or sets the source system from which the enquiry originated.</summary>
    public string? Source { get; set; }
    
    /// <summary>Gets or sets the date and time when the enquiry was created.</summary>
    public DateTime? CreatedOn { get; set; }
    
    /// <summary>Gets or sets the date and time when the enquiry was last modified.</summary>
    public DateTime? ModifiedOn { get; set; }
}
// Scan the QR code below to view and access the complete code repository.

namespace SitecoreAI.Dataverse.AzureFunctions.Services;

/// <summary>
/// Service interface for managing enquiry records in Microsoft Dataverse.
/// Provides CRUD operations and query capabilities for enquiry data.
/// </summary>
public interface IDataverseService
{
    /// <summary>
    /// Creates a new enquiry record in Dataverse.
    /// </summary>
    /// <param name="request">The request containing enquiry details to create.</param>
    /// <param name="cancellationToken">Token to cancel the operation.</param>
    /// <returns>The unique identifier (GUID) of the newly created enquiry.</returns>
    /// <exception cref="ArgumentException">Thrown when validation fails or field lengths exceed maximum allowed values.</exception>
    Task<Guid> CreateEnquiryAsync(CreateEnquiryRequest request, CancellationToken cancellationToken);
}
// Scan the QR code below to view and access the complete code repository.

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Microsoft.PowerPlatform.Dataverse.Client;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Query;
using SitecoreAI.Dataverse.AzureFunctions.Models;

namespace SitecoreAI.Dataverse.AzureFunctions.Services;
 
/// <summary>
/// Service implementation for managing enquiry records in Microsoft Dataverse.
/// Provides CRUD operations, validation, and data mapping for enquiry entities.
/// </summary>
public sealed class DataverseService : IDataverseService
{
    private readonly IConfiguration _configuration;
    private readonly ILogger<DataverseService> _logger;
}
// Scan the QR code below to view and access the complete code repository.

using SitecoreAI.Dataverse.AzureFunctions.Services;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using System.Net;
using System.Text.Json;
using SitecoreAI.Dataverse.AzureFunctions.Models;

namespace SitecoreAI.Dataverse.AzureFunctions.Functions;

/// <summary>
/// Azure Function for creating new enquiry records in Microsoft Dataverse.
/// </summary>
 
public sealed class CreateDataverseRecord
{
    private readonly IDataverseService _dataverseService;
    private readonly ILogger<CreateDataverseRecord> _logger;
 
    /// <summary>
    /// Initializes a new instance of the <see cref="CreateDataverseRecord"/> class.
    /// </summary>
    /// <param name="dataverseService">Service for interacting with Dataverse.</param>
    /// <param name="logger">Logger for tracking function execution.</param>
    public CreateDataverseRecord(
        IDataverseService dataverseService,
        ILogger<CreateDataverseRecord> logger)
    {
        _dataverseService = dataverseService;
        _logger = logger;
    }
 
    /// <summary>
    /// HTTP-triggered function that creates a new enquiry record in Dataverse.
    /// </summary>
    /// <param name="req">The HTTP request containing the enquiry data in the body.</param>
    /// <param name="executionContext">The function execution context.</param>
    /// <returns>An HTTP response with the created record ID or an error message.</returns>
    [Function("CreateDataverseRecord")]
    public async Task<HttpResponseData> Run(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "dataverse/enquiries")]
        HttpRequestData req,
        FunctionContext executionContext)
    {
        var cancellationToken = executionContext.CancellationToken;
 
        
    }
}

The update and delete functions follow the same shape - an HTTP trigger, a thin validation step, a call into IDataverseService, and a structured JSON response. Update binds the route parameter to {id:guid} and issues a PATCH; delete binds the same route and issues a DELETE.

Explore More & Share Your Feedback

📱 Scan to access the complete SitecoreAI Dataverse Azure Functions repository
💻 Azure Functions integration, .NET 8 code, authentication setup & CRUD examples

Share your feedback or contribute to support the Sitecore developer community!

AmitKumar-AK/sitecoreai-dataverse-connector

Azure Functions-based integration connecting SitecoreAI (XM Cloud) forms to Microsoft Dataverse. Includes certificate-based authentication, CRUD operations, and console app demos.

C#

0

0

• Keep functions business-focused. Avoid a single generic POST /api/dataverse/{tableName} endpoint - it exposes too much Dataverse implementation detail. Prefer purpose-built routes like /api/dataverse/enquiries.

• Validate before calling Dataverse. Check required fields, email format, field lengths, and choice values before the SDK call, not after.

• Keep secrets in Key Vault. Give the Function App’s managed identity read access to the secret rather than pasting connection strings into plain app settings.

• Log with Application Insights. Capture operation name, correlation ID, Dataverse record ID, and execution duration so failed submissions are traceable.

• Return structured responses. MCP tools and AI agents work far better against predictable JSON shapes than raw exception text.

• Update only changed fields. Sending every retrieved property back on update can unnecessarily trigger Dataverse business logic, plugins, and audit history even when values haven’t changed.

• Reuse ServiceClient connection pooling where possible rather than reconnecting per call.
• Prefer async patterns throughout, and log dependency latency via Application Insights.
• Add retry handling only where it’s safe - the current ServiceClient already respects server-specified Retry-After values for throttling, so avoid layering an additional blind retry loop on top.
• Use idempotency keys for operations where a duplicate write would matter.

A production-ready setup should include:

• Function-level authentication, or API Management in front of the Functions app.
• Managed identity for Key Vault access instead of static secrets where feasible.
• Least-privilege Dataverse application user permissions.
• Input validation and request size limits.
• Environment-specific app registrations for dev, test, and production.
• Logging that never includes sensitive payload data.

• Imagine a SitecoreAI (Sitecore XM Cloud) landing page capturing interest in a product demo. The form collects a name, email, company, message, and campaign source.

• Instead of calling Dataverse directly, the page calls POST /api/dataverse/enquiries. The Azure Function validates the payload, maps fields to Dataverse columns, creates the row, logs the operation, and returns a structured response.

• Later, a support workflow - or an MCP tool - can update the same record with PATCH /api/dataverse/enquiries/{id}, and an authorised cleanup process can remove test data with DELETE /api/dataverse/enquiries/{id}. One backend now safely serves SitecoreAI, Next.js, automation scripts, and future AI agents.

In the next article, we’ll explore how to connect these Azure Functions with SitecoreAI and store the processed records in Microsoft Dataverse.

Stay tuned! 👀

📊 Introduction

What if your AI assistant could securely tap into your company’s database, browse your SitecoreAI (FKA XM Cloud) content, query your CRM, or talk directly to your internal business systems - all without you lifting a finger?

That’s exactly what Model Context Protocol (MCP) makes possible. And if you’re a .NET developer, building custom MCP tools in C# is the most practical way to get there.

In my previous articles, I explained:

• How MCP works with Sitecore Marketer MCP
• Why MCP is needed compared to Copilot, GenAI, and Agentic AI

Now the next step is understanding how to create your own MCP tool in .NET C# using the official MCP SDK .

Out-of-the-box MCP servers are useful, but enterprise projects often require custom tools.

Examples:

• Internal APIs
• Sitecore CMS operation / automation
• DevOps utilities
• Data services
• Marketing workflows
• Reporting tools

Creating a custom MCP tool allows AI agents to interact with your system safely.

This becomes important when using:

• Copilot
• AI Agents
• Agentic AI
• Claude / ChatGPT with MCP
• VS Code MCP integration

Microsoft and Anthropic jointly maintain the official MCP C# SDK , making .NET a first‑class platform for MCP development.

With the C# SDK, you can:

• Build MCP servers as simple console apps or ASP.NET services
• Expose tools using familiar .NET patterns
• Integrate cleanly with dependency injection and hosting
• Run locally (stdio) or remotely (HTTP/SSE)

The ModelContextProtocol SDK provides:

• Core MCP protocol implementation (transport layer, message handling)
• Attribute-based tool registration ([McpServerTool], [McpServerToolType])
• Built-in dependency injection support
• Async/await patterns for I/O operations
• Type-safe parameter handling with validation

The best place to start is the official QuickstartWeatherServer sample from the MCP C# SDK repository - a minimal, well-structured example that shows exactly how to build your first MCP server in .NET.

This sample demonstrates:

• Creating a minimal MCP server
• Registering tools using attributes
• Exposing those tools to MCP clients
• Returning structured responses

Simple by design - but it demonstrates the exact pattern you'll repeat for every custom MCP tool you build.

Basic flow:

1. Create MCP server project
2. Define tools using SDK attributes
3. Register tools in server
4. Run MCP server
5. Connect from client (VS Code / Copilot / AI Agent)

Example concept:

Below is a high-level overview of how to build a custom MCP server in .NET. For the complete implementation, full source code, and a real-world SitecoreAI (FKA XM Cloud) example, check out the GitHub repository: MCP C# SDK Tutorial with SitecoreAI Example

1. Create a new .NET project Start with a minimal ASP.NET Core or console host:

Target .NET 8 or later, as most MCP examples assume current LTS or preview runtimes.

Add the following package references :

• Microsoft.Data.Sqlite
• Microsoft.Extensions.Hosting
• ModelContextProtocol

2. Register the MCP server and transport Using an approach similar to the examples, you configure MCP in Program.cs:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using McpSitecoreAiExample;

var builder = Host.CreateApplicationBuilder(args);

builder.Services.AddSingleton<MonkeyService>();
builder.Services.AddSingleton<SellingService>();
builder.Services.AddSingleton<SitecoreAIService>();

builder.Logging.AddConsole(consoleLogOptions =>
{
    // Configure all logs to go to stderr
    consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
});

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithToolsFromAssembly();

await builder.Build().RunAsync();

📦 Service Registration

• MonkeyService, SellingService, SitecoreAIService registered as Singletons - one shared instance per app lifetime
• SitecoreAIService is the key bridge connecting your MCP server to SitecoreAI

📋 Logging Configuration

• All logs redirected to stderr from Trace level upward
• Critical for Stdio transport - keeps stdout clean exclusively for MCP protocol messages

⚙️ MCP Server Wiring

• AddMcpServer() - registers MCP into the .NET DI pipeline; server name & version auto-resolved via assembly reflection
• WithStdioServerTransport() - sets Stdio as the communication channel; swap with WithHttpTransport() for web-hosted scenarios
• WithToolsFromAssembly() - auto-discovers all MCP tools via reflection; no manual registration needed

🔐 Optional Authentication

• Plug in API-key authentication via standard ASP.NET Core middleware for production-grade security

🚀 Host Execution

• RunAsync() keeps the process alive, listening for MCP messages from AI hosts like Claude Desktop or GitHub Copilot

3. Create the tool class:

This is where your MCP server comes to life. In C#, MCP tools are simply well-designed methods that your AI model can discover and call - think of them as structured entry points into your business logic.

A typical MCP tool class in .NET looks like this:

[McpServerToolType]
public static class SitecoreAITool
{

    [McpServerTool, Description("Retrieves child item details from Sitecore by specifying an item path or ID and language.")]
    public static async Task<string> GetChildDetails(SitecoreAIService sitecoreAIService,
            [Description("The item path (e.g., /sitecore/content/site-name/home) or item GUID (e.g., '{110D559F-DEA5-42EA-9C1C-8A5DF7E70EF9}')")] string path,
            [Description("Language code for the item (e.g., 'en' for English, 'de' for German). Default is 'en'.")] string language = "en",
            CancellationToken cancellationToken = default)
    {
        var childDetails = await sitecoreAIService.GetChildDetails(path, language);
        return JsonSerializer.Serialize(childDetails);
    }
}

• A class decorated with [McpServerToolType] - this tells the SDK it’s a tool container
• Individual methods marked with [McpServerTool], each with a clear Description so the AI understands what the tool does and when to use it

A few design principles worth following:

• Be goal-oriented, not CRUD-driven - instead of exposing a raw GetSales() method, name and describe it as “Summarise daily sales by channel” so the model can use it intelligently
• Separate reads from writes - mark read-only tools clearly and keep write operations minimal and auditable
• Fail gracefully - validate inputs early and return descriptive error messages, this helps the AI model self-correct rather than stall

AmitKumar-AK/mcp-dotnet-tutorial

Complete tutorial and guide for building Model Context Protocol (MCP) tools using C# .NET SDK. Includes step-by-step instructions, code examples, and a practical SitecoreAI MCP tool implementation to integrate AI capabilities with Sitecore content management.

C#

0

0

4. Run and connect from an AI host:

Once the server is running locally or in a container:

• Configure an MCP‑aware host like Claude Desktop, Gemini CLI or VS Code Copilot to connect to your server via stdio or HTTP.
• Point it at your executable or remote endpoint and provide any required API keys or environment variables.
• Ask natural language queries like Use the .NET MCP server to list the latest orders and highlight any anomalies and watch the host call your tools.

// .vscode/mcp.json
{
    "servers": {
        "mcp-sitecoreai": {
			"type": "stdio",
            "command": "dotnet",
            "args": [
                "run",
                "--project",
				"McpSitecoreAiExample.csproj",
            ]
        }
    },
	"inputs": []
}

Every MCP tool in .NET consists of three essential parts:

1. Tool Class with [McpServerToolType] Attribute
   This decorator tells the MCP server that this class contains tool definitions.

[McpServerToolType] public class CustomerTools { 
// Tool methods go here 
}

2. Tool Methods with [McpServerTool] Attribute
   Each public method decorated with [McpServerTool] becomes an AI-accessible tool.

[McpServerTool]
[Description("Retrieves customer information by customer ID")]
public async Task<CustomerData> GetCustomerById(
    [Description("The unique customer identifier")] int customerId,
    CancellationToken cancellationToken = default)
{
    // Implementation here
}

3. Method Descriptions Using [Description] Attribute
   Descriptions are critical - they tell the AI when and how to use your tool. Write them as if you’re instructing a human colleague.

❌ Bad Description:

[Description("Gets customer")]

✅ Good Description:

[Description("Retrieves complete customer profile including contact info, purchase history, and support tickets by customer ID. Use this when the user asks about a specific customer or needs detailed customer information.")]

In earlier articles, we explored how Model Context Protocol (MCP) enables AI assistants to perform real, meaningful actions - not just generate text. The Sitecore Marketer MCP server puts that theory into practice with a working, real-world implementation.

With custom MCP tools we can:

• Extend Sitecore automation
• Integrate internal services
• Build developer tools
• Enable AI-driven operations

This makes MCP a key part of modern architecture.

Enjoyed this guide? Give it a ⭐ and show your support!

Building custom MCP tools in .NET C# transforms AI assistants from generic chatbots into powerful, context-aware agents that understand your business. With the official C# SDK, dependency injection support, and .NET’s robust ecosystem, you can create production-ready MCP servers that securely bridge AI and enterprise systems.

Key Takeaways:

1. MCP tools are simple - Just C# classes with attributes
2. Descriptions matter - They guide AI decision-making
3. Follow .NET patterns - Async/await, DI, separation of concerns
4. Start small, iterate - Begin with 2-3 tools, expand based on usage
5. Security first - Never expose credentials, validate inputs, audit access

📘 MCP Server: Turning AI Thinking into Real Action

Modern enterprises no longer want AI that only writes or suggests - they want AI that can act.

The Model Context Protocol (MCP) Server is the missing infrastructure that makes this possible. It acts as a secure, standardized bridge that allows Copilot, Generative AI, and AI agents to interact with real enterprise systems, tools, and data - safely, audibly, and at scale.

By connecting AI models to real tools, MCP Servers enable Agentic AI and autonomous AI agents to perform real tasks such as creating content, validating changes, orchestrating workflows, and publishing results - all while enforcing permissions, audit trails, and enterprise governance.

This is why MCP Server is quickly becoming foundational infrastructure for modern AI architectures.

In this article, we'll clarify:

• What MCP Server actually does
• How it differs from related AI concepts
• Why it matters for enterprises
• How it works in practice using Sitecore Marketer MCP examples

Most AI systems - whether GenAI, Copilot, or even Agentic AI - can generate content or propose plans, but they cannot safely act on enterprise systems like Sitecore CMS, CRM, or business platforms on their own.

Without additional infrastructure, AI cannot:

• Create or update CMS content
• Trigger enterprise workflows
• Access live business data
• Execute multi‑step operations
• Work with enterprise permissions and security

This is where MCP Server (Model Context Protocol) fills the gap.

MCP Server allows AI systems to discover, understand, and invoke tools in a controlled way. It provides:

• Permission‑scoped execution
• Typed schemas for predictable behavior
• Tool discovery
• Full auditability

Generative AI models (such as GPT-4 or Claude) are the core intelligence layer / underlying engine. They excel at producing new content - text, code, summaries, and ideas - based on prompts.

Strengths

• Content creation
• Summaries and ideation

Limitations

• No execution capability
• No direct access to tools or systems
• No planning beyond a single response

Example

• Using ChatGPT to draft a blog post

Copilots embed GenAI directly into tools like VS Code, Microsoft 365, or Cursor. They observe user context and provide suggestions in real time.

Strengths

• In‑context recommendations
• Code completion and productivity boosts
• Excellent user experience

Limitations

• Not autonomous
• Limited to the host application
• Cannot orchestrate workflows across systems

Example

• GitHub Copilot recommending code snippets

AI Agents wrap GenAI with a specific goal and a set of tools. They can execute predefined tasks such as fetching data, find all broken links, filtering results, or performing simple operations.

Strengths

• Task execution
• API-based automation
• Goal‑oriented behavior

Limitations

• Dependent on available integrations
• Often rely on custom or fragile API wrappers
• Limited planning unless combined with Agentic AI

Example

• An agent retrieving flight data from an API

Agentic AI introduces autonomy, reasoning, and planning. Instead of following a script, it breaks goals into steps, selects tools, retries failures, and evaluates outcomes.

Strengths

• Multi-step planning
• Tool selection
• Self-evaluation and retries

Limitations

• Still needs secure access to systems
• Requires guardrails and validation
• Cannot safely discover tools without MCP

Example

• Planning a trip by checking weather, comparing flights, and booking within constraints

MCP Server is the execution and integration layer that allows AI systems to act safely.

What MCP Server Provides

• Standardized interface for AI-to-tool communication
• Tool discovery and invocation
• Secure, scoped permissions
• Typed schemas for predictable behavior
• Full audit logs and governance

It tells the AI:

• What actions are allowed
• Which tools can be used
• How to call them
• What inputs and outputs are expected

Without MCP Server, Agentic AI cannot reliably interact with enterprise systems.

Enterprise Execution Comparison: GenAI, Copilot, Agentic AI, and MCP Server

Capability Comparison Across AI Models and MCP Server

What it shows (at a glance):

Agentic AI and MCP Server play very different but complementary roles.

Agentic AI is responsible for thinking: understanding goals, reasoning, planning steps, choosing actions, and learning from outcomes. It behaves like a manager, deciding what should happen next.

MCP Server, on the other hand, is responsible for doing things safely. It acts as the execution and governance layer, exposing enterprise tools (CMS, CRM, APIs, databases) in a standardized, permission‑controlled way.

When Agentic AI decides to take action, it does not call enterprise systems directly. Instead, it invokes tools through the MCP Server, which:

• Validates permissions
• Enforces schemas
• Executes actions securely
• Records audit logs

This separation ensures that AI can act autonomously without bypassing enterprise security or governance.

MCP Server turns GenAI and Copilots into secure, action-capable digital teammates.

For Sitecore, the Marketer MCP enables AI to:

• Create and update pages
• Add or modify components
• Search and manage assets
• Update Fields

Using natural language commands from tools like VS Code Copilot, the MCP Server:

• Authenticates securely
• Maps intent to Sitecore Agent APIs
• Executes actions with governance
• Returns auditable results

This removes fragile custom integrations and standardizes AI-to-CMS communication across teams.

With Sitecore Marketer MCP:

• Agentic AI plans the steps
• MCP Server exposes the correct tools
• Sitecore Agent API executes securely

Developers can configure MCP in .vscode/mcp.json, turning the IDE into a Sitecore command center.

• Use GenAI for writing, summaries, ideation
• Use Copilot for productivity inside tools
• Use AI Agents for predefined automation
• Use Agentic AI for reasoning and orchestration
• Use MCP Server when AI must securely interact with real enterprise systems

Enjoyed this guide? Give it a ⭐ and show your support!

The Model Context Protocol (MCP) is an open standard that changes how AI tools work by linking AI apps to outside systems like data sources, tools, and workflows. Instead of using fragile, custom connections, it offers a unified, neutral way for any AI that supports MCP to easily connect with MCP servers. With more than 17,000 servers, MCP works with many applications, from web browsing to managing enterprise content.

In enterprise projects like Sitecore implementations , it’s important to use curated, secure, and well-managed MCP servers. Created by Anthropic , MCP sets a standard for how AI models connect to outside systems, ensuring they work well with AI clients like Claude , ChatGPT , and VS Code Copilot . This protocol allows AI models to safely access data, tools, and business workflows, improving flexibility and integration.

What it shows (at a glance):

• An AI app (host) uses an MCP client to connect to an MCP server.
• Messages use JSON‑RPC over stdio (local) or Streamable HTTP (remote).
• The server exposes three core capabilities: Tools, Resources, and Prompts.
• Basic flow: discover → invoke tool → return results/context

📹 Learn More About MCP

Sitecore Marketer MCP is a powerful tool that changes content management by adding advanced AI features to the SitecoreAI platform. This server uses the SitecoreAI Agent API to allow smooth interactions between AI assistants and Sitecore's marketing tools . It lets users manage content, assets, and data with natural language commands , making workflows easier and boosting productivity. Unlike traditional APIs, it is user-friendly for both developers and marketers, providing a more flexible and secure content management experience.

Built on the open-standard Model Context Protocol (MCP) , Sitecore Marketer MCP lets AI agents safely work with Sitecore’s marketing tools. This integration allows AI to not only offer suggestions but also perform actions like creating or editing content and optimizing campaigns, without needing manual UI navigation or complex API calls. The protocol includes safeguards like scoped permissions and audit trails to ensure secure and efficient operations. By allowing faster experimentation with less risk, Sitecore Marketer MCP helps marketers innovate and adapt quickly, making it a key feature in Sitecore’s latest updates and discussions.

Why these components?:

• Marketer MCP exposes "tools" that directly map to business‑level actions (e.g., create page, add component, upload asset). Those tools proxy to Agent API endpoints, so AI assistants can perform actions from natural‑language prompts - no manual UI or raw API calls.
• Security & governance: operations run under your existing Sitecore roles with auditability and human‑in‑the‑loop approval rules where configured.
• Transport & protocol: Requests flow via MCP (JSON‑RPC) over Streamable HTTP (remote) or stdio (local), following the standard MCP architecture.

List of available tools from Sitecore Marketer MCP

By default, all the Marketer MCP tools are enabled. To fully use the Marketer MCP, it’s recommended to enable each tool. Each tool matches an endpoint of the Agent API used by the MCP to perform actions in Sitecore.

🗂️ Site Management

📄 Page Management

📃 Content Management

🛠️ Component Tools

🖼️ Asset Management

👤 Personalization

Integrating the Marketer MCP server with Visual Studio Code and GitHub Copilot:

• Transforms your development environment into a powerful Sitecore content assistant.

• This integration enhances the developer experience by turning VS Code into a comprehensive content-orchestration hub, allowing seamless interaction with Sitecore’s AI-driven features.

• With native support for MCP servers through GitHub Copilot and related extensions, users can query Sitecore content, generate code snippets aligned with Sitecore schemas, and automate marketing tasks using natural language prompts.

  What is SitecoreAI (FKA XM Cloud)?

  To learn more about SitecoreAI (FKA XM Cloud), watch the video below for detailed information.

  
  

Step-by-Step: VS Code Configuration

1. Prerequisites:

• Visual Studio Code with the GitHub Copilot extension enabled.

• Access to the Sitecore Marketer MCP server (typically provided via a specific URL https://edge-platform.sitecorecloud.io/mcp/marketer-mcp-prod from your Sitecore setup).

• Ensure your organization’s Copilot administrator has enabled the necessary permissions.

  Important

  A common hurdle: If the START MCP SERVER option doesn’t appear later, your admin may need to re-enable MCP access in the Copilot admin UI, as noted in related VS Code issues here

2. Configuration in VS Code:

Create or edit a file at .vscode/mcp.json in your project root (or workspace) or a user-level mcp.json (C:\Users\[UserName]\AppData\Roaming\Code\User). Add your MCP server entry. Example for a hosted/remote server (adapt URL to your Sitecore Marketer MCP endpoint):

// Sitecore Marketer MCP Server configuration for AI-driven content management in Visual Studio Code.
// Enables integration with SitecoreAI, and Copilot for advanced marketing automation, 
// content orchestration, and secure API access.
// For more details, visit: https://doc.sitecore.com/sai/en/users/sitecoreai/marketer-mcp.html

  {
    "servers": {
          "sitecore-marketer-mcp": {
        "url": "https://edge-platform.sitecorecloud.io/mcp/marketer-mcp-prod",
        "auth": {
          "type": "external"
        },
        "type": "http"
      }
      }
  }

3. Restart and Use:

i) Save the mcp.json file.

ii) Fully restart VS Code and ensure you are signed into Copilot.

iii) Once configured correctly, VS Code should detect it. Look for options like START MCP server or MCP-related commands in the Command Palette (Ctrl+Shift+P) or Copilot Chat.

iv) Visual Studio Code will expose the START MCP server option, allowing Copilot and other AI extensions to interact with the MCP server.

Getting Started with the Sitecore Marketer MCP Demo:

v) The AI in your editor (e.g., Copilot Chat) will now have access to the tools provided by the Sitecore Marketer MCP server.

4. Troubleshooting:

If the START MCP server option does not appear:

• Verify that GitHub Copilot is enabled for your account

• Ensure your organization has not disabled MCP access

• Contact your organization admin to re-enable MCP in the Copilot Admin UI

• For official Marketer MCP, confirm your Sitecore account has required permissions and the endpoint is correctly provisioned.

5. Utilization: Once connected:

• In GitHub Copilot Chat , use natural language prompts tied to Sitecore, e.g., Create a Sitecore content item for a new blog post or Generate JSS component code for a personalized banner from Sitecore data.

• Combine with VS Code’s AI features for code generation.

• Safely experiment with AI-driven Sitecore content changes and marketing tasks

• Extend to web chatbots or other tools by referencing the same MCP server.

• When you use a prompt like Create item with name [Item Name] based on template [template name], followed by Update field on Content Item, the update_fields_on_content_item tool is triggered. It will automatically use the newly created Item ID to update the content item with your specified values. The required JSON payload will look like this:

// Example: Update Sitecore content item fields using Marketer MCP tool in VS Code.
// Automate headless CMS workflows, AI-powered content updates, and marketing operations with SitecoreAI, 
// Copilot, and Experience Edge.
// Ideal for scalable, secure, and efficient Sitecore content management.
// More info: https://doc.sitecore.com/sai/en/users/sitecoreai/marketer-mcp.html

    {
      "fields": {
        "image": "<image mediaid=\"\" alt=\"Contoso Logo\" width=\"904\" height=\"460\" />",
        "paragraph1": "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
        "title": "Lorem ipsum dolor"
      },
      "itemId": "dd8c3d91-b57b-4f0b-a574-e4c02b683b48"
    }

• When you use a prompt such as Add Component [Component Name] inside placeholder [Placeholder Name] on Page [Page Name], the add_component_on_page tool is triggered. It will generate a JSON payload similar to the following:

// Example: Add a component to a Sitecore page using the add_component_on_page tool.
// Streamline headless CMS personalization, automate component placement, and enhance marketing workflows with 
// SitecoreAI and Copilot.
// Supports scalable, AI-driven content management in Experience Edge and JSS environments.

   {
      "componentItemName": "Hero Banner",
      "componentRenderingId": "ccd1c539-a271-4fc0-ae04-0e78fa722b9b",
      "fields": {},
      "language": "en",
      "pageId": "82932c57-15b6-4720-9603-a2c1a397ba5b",
      "placeholderPath": "headless-main"
    }

Enjoyed this guide? Give it a ⭐ and show your support!

The Sitecore Marketer MCP revolutionizes content management by integrating AI capabilities through the open Model Context Protocol (MCP) and the safety-focused Agent API. This integration with Visual Studio Code enhances flexibility, safety, and scalability, empowering organizations to innovate rapidly while maintaining control over their Sitecore ecosystem. By adopting Sitecore Marketer MCP early, businesses position themselves at the forefront of AI-driven digital experiences, streamlining content management and bridging code with marketing tasks. For the latest setup, refer to Sitecore’s documentation on Marketer MCP .

AmitKumar-AK/sitecore-marketer-mcp-prompts

This repository provides ready-to-use mcp.json configuration and a collection of practical prompts for integrating Sitecore Marketer MCP with Visual Studio Code and GitHub Copilot. Use these resources to automate content management, marketing workflows, and personalization in Sitecore Headless, SitecoreAI and Experience Edge environments.

null

0

0