Turn your Xperience by Kentico application into an MCP Server

One of the most interesting recent AI technologies is MCP - Model Context Protocol - which gives AI agents access to custom tools, prompts, and resources. Learn how you can easily turn your Xperience by Kentico application into an MCP server and use AI agents to help you understand and enhance your Xperience application.

Current solution challenges

In a recent blog post - Explore Xperience by Kentico with a SQL Server MCP - I showed how developers can use an MCP server with access to their Xperience SQL database. AI agents can use the tools of this MCP server to gain context about an application beyond just code files or Git history.

That MCP server was easy to set up but it had some drawbacks.

1. Its tools only give access to a SQL database and although Xperience's SQL implementation details are public, they are not the same as the public, supported .NET API of the product. This means we can query the SQL database for insights but we shouldn't invest too heavily in manipulating data directly through SQL.
2. It is a Node.js package that is magically added to a project through VS Code's UI, making it difficult to identify and manage as a dependency.
3. It doesn't have any hook points to let developers step in and customize the tools exposed by the server. Additionally, because it's written for Node.js, it's not easily customized by Xperience developers who tend to write more C# than server executed JavaScript.
4. It requires managing a connection string in the mcp.json file, which needs to be kept in sync with the connection string for the Xperience application.

Wouldn't it be nice if we could resolve all these issues with one simple solution?

Xperience Community MCP Server

I felt I could address all these gaps with a new open-source community integration for Xperience by Kentico - Xperience Community MCP Server.

This project is an MCP Server built with the .NET MCP Server SDK tailored for Xperience by Kentico projects and installed as a NuGet package.

Why use this library instead of something like mssql-mcp-node?

1. It's written in C#, so Xperience developers can view the source code, customize and hack on it, and even author their own custom MCP tools C#, hosted in their own libraries and automatically exposed over this server.
2. It's added to an Xperience project as a NuGet package so it's easy to identify as a dependency and manage which version you're using.
3. Because it's hosted by and exposed through an Xperience by Kentico ASP.NET Core application, it has access to Xperience dependencies and the application context and configuration (like the connection string). This means we can expose parts of Xperience's .NET API as tools for an AI agent, guaranteeing correctness and consistency when modifying data.

How can I use it?

Here's what we'll need to get started.

• The latest April 2025 release of VS Code (v1.100) or newer, which supports MCP Servers using HTTP streaming.
• Xperience by Kentico - v30.4.1 or newer. This means the Xperience project you try this with needs to be updated to at least that version.

To get started, follow the Quick Start instructions in the repository's README.md.

1. Install the NuGet package into your ASP.NET Core application.

   dotnet add package XperienceCommunity.MCPServer
   

2. Once the package is installed, update your Xperience by Kentico application Program.cs. You can ensure the MCP Server is only available locally by adding some conditional checks around it.

   If you are concerned about security, the MCP SDK is being updated to leverage ASP.NET Core Identity's native authentication and authorization.

   // Program.cs
   
   // ...
   
   // Adds the MCP dependencies
   if (builder.Environment.IsDevelopment())
   {
       builder.Services.AddXperienceMCPServer();
   }
   
   // ...
   
   // Adds the MCP endpoint
   if (builder.Environment.IsDevelopment())
   {
       app.UseXperienceMCPServer();
   }
   
   app.Kentico().MapRoutes();
   
   // ...
   

3. Start your Xperience application.

4. Set up your MCP Server configuration VS Code

   {
     "servers": {
       "xperience-mcp-server": {
         "type": "http",
         "url": "http://localhost:<your-port-here>/xperience-mcp"
       }
     }
   }
   

   The scheme, domain, and port come from the launchSettings.json file in your ASP.NET Core application because it also runs the MCP Server. The default MCP Server path prefix is /xperience-mcp.

   You can use the VS Code command palette to manage and start your MCP Server or you can click the "Start" action above your server configuration in mcp.json.

5. Use the tools exposed by the Xperience Community MCP Server in agent mode in VS Code with a prompt in GitHub Copilot chat.

   Tell me about some of the web page content types in this project
   and a summary of their structure and relationships. 
   For example, let me know if some of these web page content types
   have references to content items of other types
   as part of their field definition.
   

That's all you need to do to get started!

What can I do with it?

This integration is still in its infancy, which means it has a smaller set of capabilities today, but expect that to grow in the future.

SQL tools

To start, it has the standard "execute SQL" tools to let it explore your Xperience database and help you understand data connections. In my previous MCP blog post you can see how an AI agent can expose a lot of information to you about an application with the right prompts and SQL querying tools.

• GetSQLTables - gets all the tables of the current Xperience database.
• GetSQLTableColumns - gets the full table column details of a given table.
• ExecuteSQLQuery - executes arbitrary SQL.

Xperience tools

But this new integration is special - it also has access to Xperience's API - and exposes Xperience-specific tools.

• GetAllWebpageUrlsByChannel - enables an AI agent to browse various web pages of your Xperience application to help find issues or improvement opportunities with the running application.

• GetContentTypes - gives a refined list of all reusable, email, web page, and headless content types in your application.

• GetContentTypeDetails - exposes the full details (DataClassInfo) of a given content type.

• GetAllContentTypeIcons - returns all icon names in Xperience's new (non-Page Builder) icon set, which is useful when creating new content types.

• CreateNewContentType - lets an agent generate a completely new content type. You can see an example of this in the repository's docs.

In this clip I have the MCP Server running the Kentico Community Portal project and I prompted the AI agent to tell me about the KenticoCommunity.BlogPostPage content type and its relationships to other content types.

In just a few seconds it was able to give me a detailed relationship hierarchy between multiple content types and even identify (an intentional) circular reference.

If I wanted to take this example further I could prompt the agent to describe the relationships of every content type in the application using a syntax like mermaid.

This is pretty cool 😉 and a really powerful tool that will help developers familiarize themselves with a content model when beginning to work on an existing Xperience application for the first time (or returning to one after several months working on something else 😵).

Custom tools

But what's the fun if you're just limited to the tools the library has? Well, you can tell it which assemblies to scan to look for additional tools built with the MCP SDK.

using ModelContextProtocol.Server;
using System.ComponentModel;

namespace YourApp.MCP.Tools;

[McpServerToolType]
public sealed class EchoTool
{
    [McpServerTool, Description("Echoes the input back to the client.")]
    public static string Echo(string message)
    {
        return "hello " + message;
    }
}

After adding a new custom tool, rebuild and restart your app and then restart the MCP client in VS Code to give the agent access to what you authored.

Looking into the future

My plan is to continue to improve the library and expose more operations and data in Xperience through the MCP Server. Basically anything you can do through Xperience's .NET API is fair game.

Imagine a tool that lets us create 30 new members or newsletter subscribers. We can rely on LLM's genAI capabilities to quickly generate names and email addresses and the tool can ensure all the correct APIs are used to ensure data is in a correct and consistent state in the database after the operations complete 👏.

A moonshot goal could be to give the agent a bunch of example content and letting it try to create a content model (using some guidance from us) without having to click through the Xperience administration UI. Then the agent can use the example content to create example content items. This could be really powerful for idea exploration and prototyping 🤩.

There are so many exciting possibilities!

It's worth noting that VS Code doesn't yet support resources and prompts, two additional types of items that are part of the MCP spec, but there's already an open issue requesting this feature.

The .NET MCP SDK already supports resources and prompts, so we could use them with other MCP clients, but I'll probably move things around in the Xperience Community MCP Server library once VS Code support arrives.