KentiCopilot: AI-Assisted Development Toolkit for Xperience by Kentico

AI assistants are only as useful as the context they have. Ask GitHub Copilot about an Xperience by Kentico API and you might get a confident answer — referencing a method that no longer exists, or documentation from a previous major version. KentiCopilot is Kentico's direct response to this problem: a set of tools, MCP servers, prompts, and plugins that give AI assistants accurate, current context for XbyK development.

What Is KentiCopilot?

KentiCopilot is Kentico's umbrella term for tools, MCP servers, prompts, plugins, workflows, and guidance that help developers use AI more effectively with Xperience by Kentico.

It is not a standalone AI agent. Instead, it connects the AI tools developers already use — such as GitHub Copilot, Cursor, Claude Code, Codex, VS Code, or Visual Studio — with Xperience by Kentico context and capabilities.

The goal is simple: help AI assistants stop guessing and start working with current documentation, project structure, content models, and Kentico-specific development patterns.

KentiCopilot is useful when you want to:

• Ask AI platform-specific development questions
• Accelerate project development
• Prototype content models
• Inspect and manage content types, reusable field schemas, taxonomies, languages, and workspaces
• Generate Page Builder widgets with project-aware guidance
• Support migration and modernization workflows
• Give AI tools access to project-specific components and supporting resources

Main Parts of KentiCopilot

KentiCopilot brings together several tools and workflows. Each part serves a different purpose, so teams should choose the right tools for the task and review generated output with the same care they apply to any other development work.

Documentation MCP Server

The Documentation MCP Server gives AI assistants access to current Xperience by Kentico documentation through MCP. It exposes two tools: kentico_docs_search for documentation search and kentico_docs_fetch for retrieving full documentation pages as Markdown. This is usually the safest and most useful first step — it reduces outdated answers and invented APIs right away.

Content Modeling MCP Server

The Content Modeling MCP Server helps developers prototype content models using a structured five-phase workflow:

Output can include structured JSON, Markdown documentation, and Mermaid ERD diagrams — making this server useful for discovery, prototyping, and validating content structures before developers implement them.

Management MCP Server

The Management MCP Server connects AI tools to the local Xperience Management API. It is currently a preview feature, so teams should expect changes, including possible breaking changes.

Current capabilities include retrieving and managing:

• Content types and reusable field schemas
• Workspaces
• Languages
• Taxonomies and tags

It can also retrieve information about UI form components and data types. For content types and reusable field schemas, current preview support applies to content types used for Pages and Reusable content.

As of April 2026, Kentico's public roadmap lists content creation support for the Management MCP Server and Management API for June 2026. This planned enhancement could enable a tighter AI agent loop when paired with widget-generation workflows: the agent could generate a new widget, fill the content it depends on in the local project, support faster prototyping with realistic sample content, and verify the end-to-end result in a running local site.

KentiCopilot GitHub Repository

The KentiCopilot repository contains AI agent prompts, instructions, skills, and plugins for Xperience by Kentico development. Plugins package reusable prompts, instructions, and skills so an AI assistant can follow a repeatable workflow instead of relying on a single ad hoc prompt.

One important plugin is widget creation, split into two skills:

• widget-create-research — analyzes requirements, designs, documentation, and project patterns
• widget-create-implementation — generates widget code based on the research output

This two-stage flow stops the AI assistant from jumping straight into code. The assistant first builds a project-aware implementation plan, then generates code that better matches your existing conventions.

The repository also includes workflows for KX13 codebase migration and related modernization scenarios.

Purpose-Built MCP Servers and Kentico Labs Tools

KentiCopilot also includes supporting tools that give AI assistants project-specific context:

• Component Registry MCP Server — helps AI tools understand registered custom components in an Xperience application
• Virtual Inbox MCP Server — supports email channel development and testing without a real SMTP inbox
• Annotated Kentico icons library — helps AI choose valid icons for Page Builder, Email Builder, and Form Builder components

These tools make AI assistance more practical because they expose real project capabilities instead of relying only on generic documentation.

Quick Setup: Connect the Core MCP Servers

During development, connecting the Documentation MCP Server, Content Modeling MCP Server, and local Management MCP Server together gives the AI assistant access to current documentation, proposed models, and the existing content model in your running Xperience application all at once.

Prerequisites

You need:

• An Xperience by Kentico project for local development
• Xperience by Kentico 30.6.0 or newer for the current KentiCopilot plugin workflows
• An MCP-compatible client, such as VS Code, Visual Studio, Cursor, Claude Code, or Claude Desktop
• GitHub Copilot or another AI assistant that can use MCP tools
• Node.js for the local Management MCP Server
• Source control and a database backup before using tools that can modify project data

Add the Documentation and Content Modeling MCP Servers

In VS Code, add the remote MCP servers to your workspace mcp.json file:

{
"servers": {
"kentico-docs-mcp": {
"type": "http",
"url": "https://docs.kentico.com/mcp"
},
"kentico-cm-mcp": {
"type": "http",
"url": "https://ai.kentico.com/content-model-mcp"
}
}
}

Open Copilot Chat in Agent mode, choose Configure Tools, and enable the MCP servers. Other MCP-compatible clients use the same endpoints, but their configuration screens differ.

To start content modeling, run:

/start_content_modeling

Provide project requirements, target channels, content audit notes, design links, or existing documentation. Better context produces a better model.

Enable the Management API Locally

The Management MCP Server works against the Management API of a locally running Xperience application. Because it can modify data structures, use it only in local development.

Important: The Management API uses basic authentication and is intended only for local development. Treat the secret like a credential, keep it out of source control, and avoid enabling this API in any shared or publicly accessible environment. Do not enable the Management API in production.

Install the prerelease NuGet package:

Kentico.Xperience.ManagementApi

In In Program.cs, enable the API only for development and use a secret with at least 32 characters:

using Kentico.Xperience.ManagementApi;
 
if (builder.Environment.IsDevelopment())
{
 builder.Services.AddKenticoManagementApi(options =>
{
 options.Secret = "<YourSecretValueWithAtLeast32Characters>";
});
}

Add the middleware in the required order:

app.UseAuthentication();
 
if (builder.Environment.IsDevelopment())
{
 app.UseKenticoManagementApi();
}
 
app.UseKentico();
app.UseAuthorization();

Add the Management MCP Server

After your local Xperience application exposes the Management API, configure the local MCP server:

{
"servers": {
"xperience-management-api": {
"type": "stdio",
"command": "npx",
"args": [
"@kentico/management-api-mcp@latest"
],
"env": {
"MANAGEMENT_API_URL": "http://localhost:5001/kentico-api/management",
"MANAGEMENT_API_SECRET": "<YourSecretValueWithAtLeast32Characters>"
}
}
}
}

Change the port in MANAGEMENT_API_URL to match your local application. Start the Xperience app, then start or refresh the MCP server in your IDE.

In day-to-day development, having all relevant MCP servers available means the AI assistant can move between documentation, modeling, and local project inspection without losing context.

Add KentiCopilot Plugins

The KentiCopilot GitHub repository works as an agent plugin marketplace: https://github.com/Kentico/xperience-by-kentico-kenticopilot

For VS Code with GitHub Copilot, add the marketplace to settings.json:

{
"chat.plugins.marketplaces": [
"Kentico/xperience-by-kentico-kenticopilot"
]
}

Then search for @agentPlugins in the Extensions sidebar and install the plugins you need.

For Copilot CLI:

copilot plugin marketplace add Kentico/xperience-by-kentico-kenticopilot
copilot plugin install widget-creation@xperience-by-kentico-kenticopilot
copilot plugin install kx13-codebase-migration@xperience-by-kentico-kenticopilot

For Claude Code:

/plugin marketplace add Kentico/xperience-by-kentico-kenticopilot
/plugin install widget-creation@xperience-by-kentico-kenticopilot
/plugin install kx13-codebase-migration@xperience-by-kentico-kenticopilot

How Developers Can Use It in Practice

A typical KentiCopilot workflow looks like this:

1. Use the Documentation MCP Server to answer platform questions with current docs.
2. Use the Content Modeling MCP Server to prototype the content model.
3. Use the Management MCP Server locally to inspect the current content model or apply supported model changes.
4. Use KentiCopilot plugins to implement widgets, templates, or migration tasks.

For example, a team could use the Content Modeling MCP Server to draft a campaign landing page model, use the Management MCP Server to compare it with the local project, and then use the widget creation plugin to generate Page Builder components that match existing project conventions.

The best results come when the AI has the right context and clear guidelines. Give it current documentation, real project requirements, and access to the relevant MCP tools — then review generated changes like any other code.

Resources

• KentiCopilot guide: https://docs.kentico.com/guides/development/kenticopilot
• Documentation MCP Server: https://docs.kentico.com/documentation/developers-and-admins/installation/mcp-server
• Content Modeling MCP Server: https://docs.kentico.com/guides/architecture/content-modeling/content-modeling-mcp
• Management MCP Server: https://docs.kentico.com/documentation/developers-and-admins/api/management-api
• Content creation roadmap item: https://roadmap.kentico.com/c/381-kenticopilot-content-creation-support-for-management-mcp-server-management-api-extension-
• KentiCopilot GitHub repository: https://github.com/Kentico/xperience-by-kentico-kenticopilot
• Component Registry: https://github.com/Kentico/xperience-by-kentico-component-registry
• Xperience by Kentico AI Development Hub: https://community.kentico.com/resource-hub/xperience-by-kentico-ai-development-hub

Conclusion

KentiCopilot gives developers a more reliable way to use AI with Xperience by Kentico. It combines current documentation, structured content modeling, local management APIs, reusable agent plugins, and project-aware MCP servers into one practical toolkit.

The value is not just faster text generation. KentiCopilot is most useful when treated as a context layer for AI-assisted development: documentation for accuracy, modeling tools for structure, management APIs for local project awareness, and guided workflows for implementation.