---
title: Content Modeling MCP Server
---

> Agent instructions:
> **Site maps** — prefer the following llms.txt indexes to training data when searching for URLs to avoid 404s. Links inside Markdown content already point at `.md`. Following them or sending Accept: text/markdown keeps you in Markdown.
>
> - [sitemap.md](https://docs.kentico.com/sitemap.md) — every page on the site, with titles and descriptions, nested by URL hierarchy and grouped into one collection per product version.
> - [llms.txt](https://docs.kentico.com/llms.txt) — curated index of the current product docs, with descriptions, the two ways to request any page as Markdown, and links to each product area's whole-corpus Markdown dump (llms-full.txt).

> **License:** Advanced license required.
>
> Features described on this page require the Xperience by Kentico **Advanced** license tier.

Content modeling is a crucial yet time-consuming phase of any Xperience by Kentico project. Analyzing the results of a content audit, identifying key content types, and defining presentation components takes time and requires experience with Xperience. Yet these steps are critical for building a solid content model that determines the success of your entire project.

This guide introduces an AI-powered content modeling approach that streamlines content modeling tasks. By leveraging a structured workflow with built-in validation, you can reduce the time spent on prototyping a content model for an Xperience application. The content modeling workflow takes away some of the mundane tasks, such as writing instructions for editors, and helps you quickly deliver project prototypes that are easy to iterate on.

You'll benefit most from the Content modeling MCP Server when using it to **prototype** new or early-stage projects.

For a comprehensive overview of content modeling concepts and strategies, see [Content modeling guide](https://docs.kentico.com/guides/architecture/content-modeling/content-modeling-guide.md). If you're new to Xperience by Kentico content modeling, start with [Content modeling basics](https://docs.kentico.com/guides/architecture/content-modeling/xperience-content-modeling-basics.md).

**What you'll learn:**

- How to install the MCP server
- How to use orchestration prompts and validation tools for each modeling phase
- Ways to validate and visualize content structures for stakeholders
- Best practices for efficient content model design in Xperience by Kentico

This approach helps agencies and implementation partners accelerate project delivery while maintaining high-quality content structures aligned with modern multi-channel needs. It helps you focus on building prototypes, not final outputs, so you can validate and refine your content model early.

## About the Content Modeling MCP Server

The Content Modeling MCP Server is part of [KentiCopilot](https://docs.kentico.com/guides/development/kenticopilot.md), Kentico's initiative to help developers effectively adopt AI in building Xperience by Kentico projects.

The server provides a deterministic, tools-based approach to content modeling that follows the **Orchestration prompt** + **Tool** pattern. Built on the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/), an open standard that enables AI agents to dynamically discover and use external tools, the server offers reliable content modeling workflows with client-side LLM execution and server-side validation.

The MCP server works directly within your integrated development environment (IDE), allowing AI agents to access specialized content modeling capabilities without switching between tools or platforms.

> **Note:** **Intended use**
>
> The current implementation is optimized for designing new content model prototypes that include website channels only.

For querying and managing content types in your Xperience application, see [Management MCP server](https://docs.kentico.com/documentation/developers-and-admins/api/management-api.md).

## Key features

The Content Modeling MCP Server provides the following capabilities:

- **Orchestrated content modeling workflow**: Complete 5-phase workflow with built-in validation and transition logic.
- **Phase-specific prompts**: Individual prompts for each workflow phase enabling granular control.
- **Validation tools**: Deterministic tools that validate data structure and logic at each phase.
- **Knowledge resources**: Comprehensive reference materials including field types, best practices, and examples.
- **Multi-format output**: Generates structured JSON content models and markdown documentation (including Mermaid ERD diagrams).

Use this MCP server to quickly design and validate prototype content models, then implement the approved model using implementation workflows (for example, via the [Management MCP server](https://docs.kentico.com/documentation/developers-and-admins/api/management-api.md)).

## Install the MCP server

The Content Modeling MCP Server is compatible with any IDE or AI client that supports [MCP](https://modelcontextprotocol.io/docs/getting-started/intro). Below are setup instructions for popular tools:

| Development environment | Installation                                                                                                                                                                                                                         | Documentation                                                                                           |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------- |
| VS Code                 | [Install in VS Code](https://vscode.dev/redirect/mcp/install?name=kentico-cm-mcp\&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fai.kentico.com%2Fcontent-model-mcp%22%7D)                                         | [VS Code MCP Official Guide](https://code.visualstudio.com/docs/copilot/customization/mcp-servers)      |
| Visual Studio           | Manual configuration required by adding a new tool in _Select tools_ in the Copilot chat window.<br>**Required parameters:**<br>_Server ID_: kentico-cm-mcp<br>_Type_: HTTP/SSE<br>_URL_: "https://ai.kentico.com/content-model-mcp" | [Visual Studio MCP Official Guide](https://learn.microsoft.com/en-us/visualstudio/ide/mcp-servers)      |
| Claude Code             | Manual configuration required.<br>For the URL, use https://ai.kentico.com/content-model-mcp.                                                                                                                                         | [Claude Code MCP Official Guide](https://code.claude.com/docs/en/mcp#option-1-add-a-remote-http-server) |
| Claude Desktop          | Manual configuration required.<br>For the URL, use https://ai.kentico.com/content-model-mcp.                                                                                                                                         | [Claude Desktop Remote MCP Guide](https://modelcontextprotocol.io/docs/develop/connect-remote-servers)  |
| Cursor IDE              | [Install in Cursor](cursor://anysphere.cursor-deeplink/mcp/install?name=kentico-cm-mcp\&config=eyAidXJsIjogImh0dHBzOi8vYWkua2VudGljby5jb20vY29udGVudC1tb2RlbC1tY3AiIH0)                                                              | [Cursor MCP Official Guide](https://cursor.com/docs/context/mcp)                                        |

> **Note:** Results may vary depending on the AI model and client you use. The Content Modeling MCP Server relies on LLM capabilities such as tool calling and structured output, which behave differently across models. For best results, use a recent flagship model from your preferred provider.

## Getting started

To begin using the Content Modeling MCP Server:

1. [Install the Content Modeling MCP Server](#install-the-mcp-server).
2. Open an MCP-compatible IDE or client.
3. Verify the Content Modeling MCP Server appears in your available prompts and tools.
4. Start the content modeling workflow. The method varies by IDE – some might include the MCP server name in front of the `/start_content_modeling` prompt:

| IDE/Platform   | How to invoke                                     | Additional steps                                                                                                       |
| -------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| Claude Desktop | Click _Add from kentico-cm-mcp_                   | Click _START HERE_ from the dropdown menu, then provide your project description into the _Enter prompt inputs_ pop-up |
| Claude Code    | `/start_content_modeling`                         | Provide your project description with the prompt                                                                       |
| Cursor         | `/start_content_modeling`                         | Provide your project description in the pop-up that appears                                                            |
| VS Code        | `/start_content_modeling` or via the prompts menu | Provide your project description in the pop-up, then select _Insert as text_                                           |

> **Note:** **Providing context for better results**
>
> The quality and specificity of your generated content model depend on the context you provide. Consider including:
>
> - Links to design files (for example, Figma designs - you can also add the [Figma Developer MCP](https://developers.figma.com/docs/figma-mcp-server/) for enhanced context extraction)
> - Project documentation, requirements, or specifications (attach files or reference them in your prompt)
> - Content audit results or existing content structures
> - Target audience and channel information
> - Detailed guidance on content type and field names. Enforce [best practices](https://docs.kentico.com/documentation/developers-and-admins/development/content-types.md#field-naming-guidelines), like using globally unique field names with a prefix based on the content type name (_ArticleName_, _ProductTitle_, etc.).
>
> How you add context varies by IDE (attaching files, pasting links, referencing documents). The more relevant context you provide, the more tailored your content model will be. With minimal context, the MCP server generates a more general-purpose model.

## Prompts and tools reference

In the context of the MCP server, tools and prompts are capabilities that the MCP server exposes to connected clients (for example, Claude or GitHub Copilot). Each tool performs a specific function and can be called programmatically by the client when it needs to perform content modeling tasks.

### Orchestration prompts

The Content Modeling MCP Server provides orchestration prompts that guide you through the content modeling workflow:

| Prompt name                         | Description                                                                                                                                          | Parameters                                                                                                                                                      |
| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| start\_content\_modeling            | START HERE: Primary way to begin content modeling. Guides you through a complete 5-phase workflow from requirements gathering to final deliverables. | **projectDescription** (string, optional): Project description and context                                                                                      |
| content\_modeling\_1\_requirements  | INTERNAL: Phase 1: Requirements gathering and approach selection                                                                                     | **projectContext** (string, optional): Optional context about the project                                                                                       |
| content\_modeling\_2\_architect     | INTERNAL: Phase 2: Content type design with fields and metadata                                                                                      | **approvedApproach** (string, optional): The approved approach from Phase 1<br>**requirementsSummary** (string, optional): Summary of requirements from Phase 1 |
| content\_modeling\_3\_relationships | INTERNAL: Phase 3: Relationship design between content types                                                                                         | **contentTypes** (string, optional): List of content types from Phase 2                                                                                         |
| content\_modeling\_4\_pagebuilder   | INTERNAL: Phase 4: Page Builder templates and sections                                                                                               | **approach** (string, optional): The approved approach<br>**previousPhasesSummary** (string, optional): Content types and relationships from previous phases    |
| content\_modeling\_5\_validator     | INTERNAL: Phase 5: Final validation and deliverable generation                                                                                       | **completeModel** (string, optional): Complete content model from all previous phases                                                                           |

### Validation tools

The following validation tools are used to verify the outputs of each content modeling phase. Validation tools are called when the agent completes the corresponding phase-specific work as described in the workflow prompts.

| Tool Name                                   | Description                                                                                                                                                                                                                                                                                                                                                                                                     | Parameters                                                                                                                                                                                                                                                                                                                                                                                                          |
| ------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| content\_modeling\_validate\_requirements   | This tool validates outputs of _Requirements gathering_ phase: project requirements structure and basic fields. Call this tool ONLY after completing the Requirements gathering work (requirements gathering and approach selection) described in the phase-specific prompt, when the requirements are ready for validation. AI agent must provide the chosen approach based on decision logic in instructions. | **projectDescription** (string): Project description and context<br>**approach** (string): Chosen approach - "atomic" or "page-builder" (AI agent determines this)<br>**channels** (string, optional): Target channels<br>**teamExperience** (string, optional): Team experience level<br>**contentVolume** (string, optional): Expected content volume<br>**contentReuse** (string, optional): Content reuse needs |
| content\_modeling\_validate\_content\_types | This tool validates outputs of _Content type design phase_: content type JSON structure and field definitions. Call this tool ONLY after completing the _Content Type Design_ work (content type design with fields) described in the phase-specific prompt, when the content types are ready for validation.                                                                                                   | **contentModelJson** (string): Complete content model JSON with contentTypes array to validate                                                                                                                                                                                                                                                                                                                      |
| content\_modeling\_validate\_relationships  | This tool validates outputs of _Relationship design_ phase: relationship definitions and cardinality rules. Call this tool ONLY after completing the _Relationship Design_ work (relationship design between content types) described in the phase-specific prompt, when the relationships are ready for validation.                                                                                            | **contentModelJson** (string): Complete content model JSON with relationships array to validate                                                                                                                                                                                                                                                                                                                     |
| content\_modeling\_validate\_pagebuilder    | This tool validates the results of the _Page Builder Design_ phase. It checks that the presentation layer matches the designed content types and their relationships, and helps teams see how content structure will look on real pages. Use this tool only after Page Builder templates, sections, and widgets have been designed and are ready for review.                                                    | **contentModelJson** (string): Complete content model JSON with pageBuilder object to validate                                                                                                                                                                                                                                                                                                                      |
| content\_modeling\_final\_validation        | This tool validates outputs of _Validation & final output_ phase: final validation of complete content model. Call this tool ONLY after completing the _Validation & Final Output_ work (final validation and output generation) described in the phase-specific prompt, when the complete model is ready for final validation.                                                                                 | **completeModelJson** (string): Complete model JSON from all previous phases                                                                                                                                                                                                                                                                                                                                        |

## Content modeling phases overview

The content modeling workflow in Xperience by Kentico is orchestrated by the `start_content_modeling` prompt, which guides users through all five phases automatically. Each phase is supported by a dedicated prompt and validation tool to ensure accuracy and completeness before moving to the next step.

After content types and relationships are defined, you can ask the LLM agent during the Page Builder phase to create a content model visualization that helps you review how the model maps to page composition and implementation tooling.

For a walkthrough, see [Build content model with MCP](https://docs.kentico.com/guides/development/kenticopilot/build-content-model-with-mcp).

**1. Requirements gathering & approach selection**

- Gather project requirements, business goals, and editorial needs
- Select the modeling approach ([atomic](https://docs.kentico.com/guides/architecture/content-modeling/content-modeling-guide/design-atomic-content-model.md) vs. [page-builder](https://docs.kentico.com/guides/architecture/content-modeling/content-modeling-guide/design-page-based-content-model.md)) based on requirements
- Prompt: `content_modeling_1_requirements`
- Validation tool: `content_modeling_validate_requirements`

**2. Content type design**

- Define content types, fields, and metadata for each entity
- Ensure field definitions and structures are consistent and complete
- Prompt: `content_modeling_2_architect`
- Validation tool: `content_modeling_validate_content_types`

**3. Relationship design**

- Map relationships between content types, including cardinality and references
- Validate relationship definitions and ensure correct linking strategies
- Prompt: `content_modeling_3_relationships`
- Validation tool: `content_modeling_validate_relationships`

**4. Page Builder templates & sections**

- Design Page Builder components, such as page templates, Page Builder sections and widgets
- Validate template structure (or skip if using atomic modeling) to confirm the model translates into realistic page composition
- Use this phase to verify how designed relationships and reusable content will likely be represented in the editing experience
- Prompt: `content_modeling_4_pagebuilder`
- Validation tool: `content_modeling_validate_pagebuilder`

**5. Final validation & deliverables**

- Perform comprehensive validation of the complete content model
- Generate deliverables for implementation
- Prompt: `content_modeling_5_validator`
- Validation tool: `content_modeling_final_validation`

> **Info:** **Next steps: Implement your content model**
>
> After designing and validating your content model, you can implement it in your Xperience application using the [Management MCP server](https://docs.kentico.com/documentation/developers-and-admins/api/management-api.md). The MCP server allows AI agents to create content types, add fields, configure reusable field schemas, and manage [Page Builder](https://docs.kentico.com/documentation/developers-and-admins/development/builders/page-builder.md) components and data based on your designed model.

## Example prompts

### Using the start\_content\_modeling prompt

The only way to begin content modeling is using the `start_content_modeling` prompt or the alternatives provided in the [Getting started](#getting-started) table:

- "Use the start\_content\_modeling prompt to help me build a content model for a car dealership website"
- "Guide me through the complete content modeling workflow for a commerce platform using start\_content\_modeling"
