Sitecore MCP: Your New AI Development Partner

Transform your Sitecore development workflow with the Model Context Protocol - the next frontier in AI-assisted CMS development.

The Model Context Protocol (MCP) is opening new frontiers in content management system development — and Sitecore is no exception. With the Sitecore MCP server, developers can use AI assistants. They can interact directly with Sitecore instances using natural language commands. This makes tasks like template creation and configuration much easier.

In this guide, we’ll walk you through:

• The full MCP server configuration process
• How to connect your development tools to Sitecore using:
  • Sitecore Item Service API
  • GraphQL
  • Sitecore PowerShell Extensions

• How to:
  • Establish an AI-powered Sitecore development workflow
  • Automate content creation
  • Streamline template setup

We will also do a hands-on demo. We will build a Recipe template using Sitecore Helix principles. Then, we will fill it with rich content through natural language interaction.

What is the Model Context Protocol (MCP)?

The Model Context Protocol is an open-source standard that enables AI assistants to securely connect with external systems and data sources. When applied to Sitecore development, MCP creates a powerful bridge that allows your AI assistant to perform complex operations that would typically require manual navigation through the Sitecore admin interface or PowerShell scripting.

Introducing the Sitecore MCP Server

The Sitecore MCP server provides a comprehensive toolkit for interacting with Sitecore instances through multiple APIs and protocols. Created by Anton Tishchenko and available on GitHub, this implementation enables seamless integration between AI assistants and Sitecore environments.

Key Capabilities

The Sitecore MCP server provides extensive tools for interacting with a Sitecore instance:

Setting Up Your Sitecore MCP Environment

Prerequisites

Before setting up the Sitecore MCP server, ensure you have:

1. A running Sitecore instance (local or remote) - For this guide, we used a clean installation of Sitecore 10.4
2. Node.js installed on your development machine
3. Access to Sitecore admin credentials
4. An MCP-compatible AI code editor (VS Code with GitHub Copilot, Cursor, etc.)

Note: While the examples here use Sitecore 10.4, the MCP server works with other versions as well — just be aware that some API endpoints and authentication flows may differ slightly.

Step 1: Installing the Sitecore MCP Server

Clone and build the Sitecore MCP server from the repository:

git clone https://github.com/Antonytm/mcp-sitecore-server.git
cd mcp-sitecore-server
npm install
npm run build

The build process will create a dist/bundle.js file that serves as the entry point for the MCP server.

Step 2: Configuring Your Sitecore Environment

The MCP server requires several authentication mechanisms to be configured on your Sitecore instance:

Item Service API Setup

Ensure the Sitecore Item Service API is enabled and accessible. This typically requires:

• Sitecore Services Client (SSC) to be installed and configured
• Proper authentication credentials (username/password)

Required Sitecore Configuration: To enable HTTP authentication for the Item Service API, we created a patch file with the following settings:

<setting name="Sitecore.Services.AllowToLoginWithHttp" value="true" />
<setting name="Sitecore.Services.SecurityPolicy" value="Sitecore.Services.Infrastructure.Web.Http.Security.ServicesOnPolicy, Sitecore.Services.Infrastructure" />

These settings allow the MCP server to authenticate with the Item Service API over HTTP connections.

HTTP Binding Configuration: For this demonstration, we created an HTTP binding in IIS alongside the existing HTTPS binding. This allows the MCP server to use the HTTP endpoint instead of HTTPS, avoiding issues with the self-signed certificates that Sitecore installations typically create. In production environments, ensure proper SSL certificate configuration for secure connections.

GraphQL API Configuration

For GraphQL operations, verify that:

• Sitecore GraphQL endpoints are enabled
• API keys are properly configured
• The necessary schemas (master, core, edge) are accessible

PowerShell Extensions

If using PowerShell integration:

• Sitecore PowerShell Extensions (SPE) should be installed
• PowerShell remoting should be enabled and configured

Step 3: MCP Server Configuration in Visual Studio Code

Configure the MCP server by adding it to your Visual Studio Code MCP settings. In VS Code with GitHub Copilot, you can add MCP servers through the command palette or by directly editing the configuration file.

Adding the Server via Command Palette

1. Open the VS Code command palette (Ctrl+Shift+P)
2. Type and select "MCP: Add Server"
3. Follow the prompts to configure the Sitecore MCP server

Manual Configuration

Alternatively, you can directly edit your MCP configuration file. Here's the configuration used for a local Sitecore instance (note that while the full configuration includes GraphQL and PowerShell settings, we only used the Item Service tools for this demonstration):

"Sitecore": {
  "type": "stdio",
  "command": "node",
  "args": [
    "E:\\Projects\\SimpleA\\mcp-sitecore-server\\dist\\bundle.js"
  ],
  "env": {
    "TRANSPORT": "stdio",
    "GRAPHQL_ENDPOINT": "http://simpleasc.dev.local/sitecore/api/graph/",
    "GRAPHQL_SCHEMAS": "edge,master,core",
    "GRAPHQL_API_KEY": "{0E78653B-A0AA-4AF8-9646-3F2ED8B32861}",
    "GRAPHQL_HEADERS": "",
    "ITEM_SERVICE_DOMAIN": "sitecore",
    "ITEM_SERVICE_USERNAME": "admin",
    "ITEM_SERVICE_PASSWORD": "b",
    "ITEM_SERVICE_SERVER_URL": "http://simpleasc.dev.local/",
    "POWERSHELL_DOMAIN": "sitecore",
    "POWERSHELL_USERNAME": "admin",
    "POWERSHELL_PASSWORD": "b",
    "POWERSHELL_SERVER_URL": "http://simpleasc.dev.local/"
  }
}

Configuration Parameters Explained

• TRANSPORT: Communication method (stdio for standard input/output)
• GRAPHQL_ENDPOINT: URL to your Sitecore GraphQL endpoint
• GRAPHQL_SCHEMAS: Comma-separated list of available schemas
• GRAPHQL_API_KEY: API key for GraphQL authentication
• ITEM_SERVICE_DOMAIN: Sitecore domain for Item Service authentication
• ITEM_SERVICE_USERNAME/PASSWORD: Credentials for Item Service API
• ITEM_SERVICE_SERVER_URL: Base URL of your Sitecore instance
• POWERSHELL_DOMAIN: Domain for PowerShell operations
• POWERSHELL_USERNAME/PASSWORD: Credentials for PowerShell remoting
• POWERSHELL_SERVER_URL: URL for PowerShell endpoint access

Security Note: The credentials shown here are default development values. In production environments, use secure, unique credentials and consider implementing more robust authentication mechanisms.

Step 4: Verifying the Setup

Once configured, the Sitecore MCP server will automatically start and you should immediately see the tools become available in Visual Studio Code. The screenshot below shows both the MCP configuration in the VS Code settings.json file and the comprehensive list of available Sitecore MCP tools that become accessible once the server is running:

As shown in the image, the configuration includes all the environment variables we discussed, and VS Code displays an extensive list of available tools (110 selected) including:

• Item Management: Get, create, edit, and delete Sitecore items
• Search Operations: Query Sitecore indexes and content
• Security Tools: Manage users, roles, and permissions
• GraphQL Queries: Execute GraphQL operations against Sitecore
• PowerShell Commands: Run Sitecore PowerShell scripts
• Cache Operations: Monitor and manage Sitecore caches
• Database Tools: Interact with Sitecore databases

Practical Example

Creating a Recipe Template with Helix Architecture

With the Sitecore MCP server configured and running, let's demonstrate its power with a real-world example. We'll create a Recipe template following Sitecore Helix architecture principles through natural language interaction.

Using MCP to Prompt Template Creation

One effective approach is to first ask your AI assistant to help generate a comprehensive prompt. This ensures you get detailed, well-structured requirements that follow best practices. For our Recipe template, we started by asking the AI to create a good prompt for template creation, then refined it with our specific requirements:

Create a Recipe template following Helix architecture principles with these specifications:
First, create a feature-level base template called "_Recipe" in the Feature layer with the following fields:

Title: Single-Line Text field (mandatory, used for recipe name)
Description: Multi-Line Text field (for brief recipe description)
Ingredients: Rich Text field (mandatory, for list of ingredients)
Instructions: Rich Text field (mandatory, for step-by-step cooking instructions)
CookingTime: Integer field (for total time in minutes)
FeaturedImage: Image field (for main recipe image)

Then create a project-level page type template called "Recipe" in the Project layer under Page Types that inherits from:
The "_Recipe" feature template created above
Standard template (for basic Sitecore functionality)
Any other necessary base templates for page functionality

Template organization following Helix structure:
Feature template: Place "_Recipe" under /sitecore/templates/Feature/[FeatureName]/
Project template: Place "Recipe" under /sitecore/templates/Project/[ProjectName]/Page Types/

Configuration requirements:

Set Title, Ingredients, and Instructions fields as mandatory
Use an appropriate icon for both templates
Organize fields into logical sections (e.g., "Content", "Media", "Metadata")
Follow Helix naming conventions:
Feature template: "_Recipe" (underscore prefix for feature templates)
Project template: "Recipe" (clean name for page types)
Please create both templates with proper field configurations, validation rules, and organize them following Sitecore Helix best practices. Ensure all items are created in the master database.

Key Prompt Considerations

Database Specification: Notice the explicit mention of "master database" at the end of the prompt. This is crucial - without this specification, the MCP server defaults to the web database, which typically isn't where you want to create templates.

Helix Architecture: The prompt incorporates Sitecore Helix principles, demonstrating how AI can help implement industry best practices automatically.

Comprehensive Requirements: By providing detailed specifications, the AI can create properly configured templates without multiple back-and-forth iterations.

AI Agent Execution Process

Once the prompt is submitted, the AI agent immediately begins executing the request systematically. The following image shows the detailed step-by-step process the agent follows to create the Recipe template according to Helix architecture principles: 

As you can see in the image, the AI agent methodically works through each requirement:

1. Structure Creation: First creates the necessary folder structure for the Feature layer
2. Feature Template: Creates the "_Recipe" feature-level base template
3. Field Organization: Creates logical sections (Content, Media, Metadata) for proper field organization
4. Field Creation: Systematically creates each field with proper types and validation rules
5. Helix Compliance: Ensures all naming conventions and organizational patterns follow Helix architecture

Each step shows a successful execution (green checkmarks), demonstrating the reliability and systematic approach of the MCP-powered workflow.

Template Creation Result: Perfect Helix Architecture Implementation

Once the AI agent completes all the steps, you can see the results directly in the Sitecore Content Editor. The following image shows the properly organized template structure following Helix architecture principles:

The template structure demonstrates perfect adherence to Helix architecture:

Feature Layer Structure:

• /sitecore/templates/Feature/Recipe/ - Contains the feature-level "_Recipe" template
• Organized Field Sections: The "_Recipe" template includes properly organized sections:
  • Content: Contains Title, Description, Ingredients, and Instructions fields
  • Media: Houses the FeaturedImage field
  • Metadata: Contains the CookingTime field

Project Layer Structure:

• /sitecore/templates/Project/SimpleA/Page Types/Recipe - Contains the project-level page type template
• Proper Inheritance: The "Recipe" page type inherits from the "_Recipe" feature template

This organization follows Sitecore Helix best practices by:

• Separating concerns between Feature and Project layers
• Using proper naming conventions (underscore prefix for feature templates)
• Organizing fields into logical sections for better content editor experience
• Creating reusable feature-level components that can be inherited by multiple project templates

Note on Icon Assignment: During this execution, the AI attempted to assign an appropriate icon but referenced an icon that doesn't exist in the Sitecore installation. This is a minor issue that can be easily corrected by manually assigning a valid icon in the Sitecore Content Editor. Future enhancements to the MCP server could include a tool to check available icons before assignment, ensuring more accurate icon selection during template creation.

Going Beyond Templates: Content Creation

With the Recipe template successfully created, we can demonstrate another powerful capability of the Sitecore MCP server - content creation. Using a simple follow-up prompt, we can now populate our Sitecore instance with example content:

The prompt shown in the image demonstrates how natural the content creation process becomes:

"Okay, now, let's create some content with the Recipe template, please create three example items for the Recipe content under the Home item."

Notice how the AI assistant immediately understands the context and begins the systematic process:

1. Locates the Home item to establish the parent location
2. Retrieves the Recipe template ID from the templates we just created
3. Prepares to create multiple content items with realistic, populated data

This seamless transition from template creation to content generation showcases the comprehensive workflow capabilities that the Sitecore MCP server enables.

Content Creation Execution and Results

The AI agent methodically creates each recipe item with detailed, realistic content. The following image shows the complete execution process and the quality of content generated:

As shown in the execution summary, the AI created three diverse recipe items:

1. Classic Chocolate Chip Cookies (45 minutes) - A dessert/baking recipe with complete ingredients and 9-step instructions
2. Creamy Mushroom Risotto (35 minutes) - An Italian main dish with detailed risotto technique
3. Fresh Berry Smoothie Bowl (10 minutes) - A healthy breakfast/snack option

Each item includes:

• Realistic cooking times ranging from 10-45 minutes
• Detailed ingredient lists with proper HTML formatting
• Step-by-step instructions using numbered lists
• Appropriate categorization by meal type and cuisine

Final Result in Sitecore Content Editor

The created content items appear perfectly organized in the Sitecore Content Editor, demonstrating the end-to-end workflow from template creation to populated content:

The content tree shows the three recipe items properly created under the Home item, with the "Classic Chocolate Chip Cookies" item open in the content editor. Notice how all the fields are properly populated:

• Rich text formatting in the Ingredients and Instructions fields
• Structured content that's ready for content editors to review and publish
• Proper template inheritance showing the Recipe template in use
• Professional content quality that requires minimal editing

Important Context: Showcasing MCP Capabilities

This example demonstrates the powerful content creation capabilities of the Sitecore MCP server, but it's important to note that this represents just one part of a complete Sitecore implementation. To make this content available to end users, additional steps would typically be required:

• MVC Implementation: Creating views, controllers, and renderings to display the Recipe content
• JSS/Headless Setup: Configuring layout service and creating frontend components if using a headless approach
• Publishing: Publishing the content items to the web database for public access
• Presentation Details: Setting up layout details and component configurations

The value demonstrated here is how the MCP server dramatically accelerates the content structure and data creation process. What traditionally might take hours of manual template configuration and content entry can be accomplished in minutes through natural language interaction. This allows developers to focus their time on the presentation layer, business logic, and user experience rather than repetitive content management tasks.

What's Next?

With the Sitecore MCP server properly configured, you're now ready to explore the powerful AI-assisted development workflows it enables. In upcoming blog posts, we'll dive deeper into:

• Content Management Automation: Creating and managing Sitecore items through natural language
• Template Development: Leveraging AI to design and implement Sitecore templates
• Search and Analytics: Using AI to query and analyze Sitecore content
• Workflow Automation: Streamlining content approval and publishing processes
• Performance Monitoring: AI-powered insights into Sitecore system health

The Future of Sitecore Development

The Sitecore MCP server represents a significant leap forward in CMS development tooling. By bridging the gap between AI assistants and Sitecore instances, it opens up entirely new possibilities for development efficiency and automation.

The configuration process, while detailed, establishes a foundation for transformative development workflows. As you'll discover in subsequent guides, the investment in proper setup pays dividends in dramatically reduced development time and increased productivity.

Ready to Transform Your Sitecore Development?

The setup demonstrated in this guide is just the beginning of what's possible with AI-powered Sitecore development. Having implemented cutting-edge MCP workflows across multiple Sitecore projects, [A] can help you unlock the full potential of this technology.

Our team specializes in:

• MCP Implementation: Fast-track your Sitecore MCP setup with proven configurations
• Workflow Optimization: Design AI-powered development processes tailored to your team
• Training and Adoption: Ensure your developers can leverage AI assistance effectively
• Custom Solutions: Develop specialized MCP integrations for unique Sitecore requirements
• Enterprise Integration: Scale AI-powered workflows across large Sitecore implementations

We can help you improve productivity. Whether you are updating Sitecore processes or creating new AI workflows, we have the skills you need.