Transform Your Development Experience with the DevExpress Documentation MCP Server

The Model Context Protocol (MCP) transforms the way AI assistants interact with external tools and data sources. Developed by Anthropic, MCP is an open standard that allows developers to establish secure, two-way connections between databases, APIs, and AI-powered tools. Instead of building a separate custom integration each time an AI application needs to connect to a data source or API, MCP offers a single, standardized interface. This means each AI app and each external resource only need to connect once, and from there, everything can work together seamlessly.

To meet growing demand for AI-assisted coding, we’ve configured an MCP server that connects GitHub Copilot and other MCP-compatible AI tools directly to our comprehensive documentation database. We continuously update this database as we enhance existing DevExpress documentation content and publish new help topics. You'll always have relevant, contextual, and up-to-date guidance for DevExpress components without leaving your IDE. With access to over 300,000 help topics, our server makes it easy to find the information you need using natural language queries.

In this announcement, I'll describe how to set up the DevExpress MCP server across multiple IDEs, configure AI Assistants to work with our MCP server, and offer guidance on maximizing the benefits of AI-powered documentation access.

Why Use the DevExpress Documentation MCP Server?

Traditional documentation workflows require constant context switch — you need to leave your IDE, search through docs and/or Google, and manually piece together solutions found in different sources. The DevExpress Documentation MCP server eliminates this friction by:

• Contextual help: Ask questions about DevExpress components and get targeted answers with code examples retrieved from our documentation
• Intelligent search: Search our entire documentation database (with more than 300,000 help topics) using natural language
• Real-time documentation access: Supply up-to-date information directly to your AI assistant's context
• Seamless integration: Thanks to the MCP protocol, you can leverage this capability when using GitHub Copilot's Agent Mode and other MCP-compatible tools

Here are just a few examples of what you can accomplish by delegating development tasks to AI coding agents powered by our Documentation MCP server:

Desktop Platforms

• Create a WPF Window or Windows Form with a Ribbon, file menu actions, and DevExpress Grid controls.
• Create a master-detail report mockup showing orders and line items from an EF Core data source directly in the DevExpress Visual Studio Report Designer.
• Create a new Delphi app with our VCL components and display a report viewer with a single button click.

Web Platforms

• Add a new Razor Page with our Blazor Grid, complete with editing capabilities and bound to a large data source.
• Build a responsive dashboard page with range selectors, multiple chart types, and toolbar controls — or design a fully custom edit form with validation using our DevExtreme product suite (React/Angular/Vue/jQuery).
• Create a DevExtreme-powered React or Angular web application using Application Templates with a single prompt.
• Integrate the DevExpress Report Viewer into an ASP.NET Core application.

File and Document APIs & Cross-Platform App Framework

• Generate Word mail merge documents with rich text formatting using our Document Processing APIs.
• Create spreadsheets with calculated totals and summaries using our Spreadsheet APIs.
• Generate business classes with proper data modeling attributes for XAF applications.

And much more...

At present, our Documentation MCP server provides AI assistants with access to documentation for the last two major versions (v24.2 and v25.1) via separate endpoints.

The DevExpress Documentation MCP server offers the following tools:

• devexpress_docs_search: Performs semantic search through the documentation database and returns the top 5 matches for a user query
• devexpress_docs_get_content: Allows agents to download complete help topics by URL

Additionally, our MCP server includes a built-in prompt (dxdocs.devexpress_docs_query_workflow) accessible via / in compatible coding assistants. This prompt guides the AI agent through the proper workflow and constraints for DevExpress documentation queries.

The server operates exclusively over the Streamable HTTP protocol. If you’re familiar with MCP, simply add the following endpoints to your AI assistant’s configuration and give it a try:

{
  "servers": {
    "dxdocs": {
      "url": "https://api.devexpress.com/mcp/docs",
      "type": "http"
    },
    "dxdocs24_2": {
      "url": "https://api.devexpress.com/mcp/docs?v=24.2",
      "type": "http"
    }
  }
}

DOWNLOAD THE MCP.JSON FILE

If you are not familiar with MCP, the following sections of this blog post list step-by-step setup/config instructions for the DevExpress MCP server across multiple IDEs, including Visual Studio, VS Code, and JetBrains Rider.

Using the DevExpress MCP Server

Basic Usage Pattern

1. Open your AI assistant in your IDE
2. Use Chat mode to find answers to your questions
3. Use Agent Mode with the MCP server for code generation
4. When asking DevExpress-related questions in Agent Mode, add the "Use dxdocs" (or "Use dxdocs24_2") phrase to the end of your prompt to ensure the MCP server is invoked. Alternatively, use the built-in prompt.
5. Approve tool execution when prompted
6. Review the code generated by the agent and examine comprehensive responses with code examples and documentation links

General Usage Recommendations for AI-Assisted Code Development

To maximize the effectiveness of AI-powered development tools, it's essential to approach them with the right strategy and expectations. Start by understanding the fundamentals — familiarize yourself with how large language models work and what makes different AI coding tools unique. Think of your AI assistant as a new teammate: give it detailed context, clearly explain what you need, and don’t be afraid to write long, precise prompts.

For complex tasks, first research best practices and architectural approaches using AI's Chat or Ask mode. Once you've created a solid plan, delegate the implementation to the AI agent with clear, specific instructions. Always request that the coding assistant ask clarifying questions before starting implementation if anything is unclear. Then, break down complex tasks into smaller, manageable pieces. Do not expect AI to handle multiple abstraction layers simultaneously.

Different AI models have different strengths — some excel at deep reasoning and problem-solving, others at rapid code generation. Experiment to see which works best for each task and choose the best model instead of cutting corners with weaker options: the quality compounds and impacts the effectiveness of all other practices.

Keep your existing codebase clean and well-documented, as AI assistants perform significantly better when they can reference clear and consistent patterns rather than contradictory code. When asking questions, explicitly include relevant source code files to provide necessary context.

Most importantly, always review AI-generated output: check for architectural problems, security vulnerabilities, and adherence to project standards. Ultimately, you are fully responsible for all code committed to your repository.

And last, but not least: remember that AI cannot replace domain knowledge — if requirements or implementation strategy are unclear, AI won't help much beyond completing simple tasks.

As it relates to DevExpress components and APIs, we identified multiple practices or prompt instructions that can help you get the most out of AI Assistants and our MCP server:

1. Be specific about the DevExpress component you're working with
2. Include "Use dxdocs" in your queries to force MCP tool usage
3. Ask follow-up questions to dive deeper into specific aspects
4. Request code examples when you need implementation guidance
5. Ask about best practices for component configuration and usage
6. Request the use of public APIs and adherence to established themes and style guidelines, instead of relying on custom solutions.

For instance, the instructions below help AI assistants concentrate on designer files and leverage the InitializeComponent method body in Windows Forms applications (to address UI generation tasks):

• Use designer files for UI layout. All form and control layout code must go in the designer.cs file. Do not write manual layout code in the main .cs file unless you are dynamically modifying the UI at runtime
• Initialize and configure WinForms controls within the InitializeComponent method call. Set properties such as Dock, Anchor, LookAndFeel, and Appearance within InitializeComponent rather than in event handlers

Prerequisites

Supported IDEs:

• Visual Studio 2022 (version 17.14 or later)
• Visual Studio Code
• Cursor IDE
• JetBrains Rider 2025.1+

Coding Assistants:

• GitHub Copilot
• JetBrains AI Assistant
• ...or other MCP-compatible AI assistants (such as Claude or Claude Code)

Since technology evolves rapidly and newer releases often include important fixes, I recommend using the latest versions of your IDE and plugins. 

Setup Guide

Step 1: Enable Agent Mode in Your IDE

The DevExpress Documentation MCP server works with AI assistants that support agent mode. In this mode, AI Assistants use the MCP server to connect to external tools and data sources. This guide lists setup steps for GitHub Copilot.

Visual Studio

1. Update Visual Studio 2022 to at least v17.14.12.
2. Enable Agent Mode. Go to Tools > Options > GitHub > Copilot and activate the "Enable MCP server integration in agent mode" and "Enable Agent mode in the chat pane" options:

Please refer to the following help topic for additional information: Microsoft's Agent Mode documentation.

VS Code

To get started with GitHub Copilot's agent mode, install or update the GitHub Copilot extension. Agent mode is active by default in recent versions of VS Code, so you do not need to configure this setting. To access agent mode, open the Chat view and sign in to your GitHub account. Select Agent from the Chat mode dropdown. For detailed setup instructions, refer to the VS Code Agent Mode Guide.

Cursor

In the most recent versions of the Cursor IDE, you don't need to activate Agent mode. Simply access the chat interface with agent capabilities. For additional information, refer to Cursor's Agent documentation. 

JetBrains Rider Setup

To set up AI assistance in JetBrains Rider, you'll need to update to Rider 2025.1 or later. Check that the AI Assistant plugin is already installed and install if necessary. For detailed guidance, review the following JetBrains help topic: AI Assistant Installation. Alternatively, you can install the GitHub Copilot Plugin from the JetBrains Marketplace.

Step 2: Configure the DevExpress MCP Server

Now we'll add the DevExpress documentation MCP server to your IDE configuration. MCP servers can be configured through workspace settings, user settings, or direct installation methods.

Visual Studio

Create the MCP configuration file:

• Navigate to your user profile directory: %USERPROFILE%
• Paste the following MCP Server configuration code to a new file named .mcp.json:

{
    "servers": {
    	"dxdocs": {
    		"url": "https://api.devexpress.com/mcp/docs",
    		"type": "http"
    	}
    },
    "inputs": []
}

Refer to the following help topic for more information: Use MCP servers.

VS Code

Use the following link for one-click installation, or proceed with the manual setup.

If you prefer manual setup, you can use either a personal or shared configuration. To configure the server at the workspace level (and share the configuration with your team), paste the following code into a new file: project/.vscode/mcp.json.

{
  "servers": {
    "dxdocs": {
      "url": "https://api.devexpress.com/mcp/docs",
      "type": "http"
    }
  },
  "inputs": []
}

For personal configuration, open the Command Palette using Ctrl+Shift+P on Windows/Linux or ⌘+Shift+P on Mac. Run the "MCP: Add Server" command and complete the setup wizard to add the DevExpress MCP server.

For additional information about MCP server setup in VS Code, refer to the following help topic: Use MCP servers in VS Code.

Cursor

You can use our pre-configured script or set up the MCP Server manually. To apply the pre-configured script, use the following one-click installation link:

For manual configuration, create a new file in your preferred configuration location:

• project/.cursor/mcp.json for project-specific configuration
• home_directory/.cursor/mcp.json for global configuration

To learn more about Model Context Protocol support in Cursor, navigate to the following help topic: Connect external tools and data sources to Cursor using MCP.

Paste the following code into the configuration file:

{
  "mcpServers": {
    "dxdocs": {
      "url": "https://api.devexpress.com/mcp/docs",
      "type": "sse"
    }
  }
}

Alternatively, use Cursor's MCP Settings UI: navigate to the Tools & Integrations section, click New MCP Server, and enter server details.

Refer to the following help topic for additional information: Model Context Protocol (MCP).

JetBrains Rider

Add a new MCP server as detailed in the following JetBrains Rider help topic: Model Context Protocol.

Note that at present, JetBrains Rider can only use stdio protocol with MCP servers. To set up DevExpress MCP Server, follow the documented workaround for remote servers.

If you use the GitHub Copilot Chat plugin, change the chat mode to Agent and add new tools as described in the GitHub documentation.

Step 3: Verify DevExpress MCP Server Connection

Visual Studio

To verify the connection in Visual Studio, open the GitHub Copilot Chat pane and click the Tools icon (🛠️) to view available MCP servers. Verify that the list contains DevExpress tools.

VS Code

Open the Github Copilot Chat pane using the icon in the title bar. Use the mode selector to activate Agent Mode. Click the Tools icon (🛠️) to view available MCP servers and confirm that the server list contains "dxdocs" and associated tools.

Cursor

Open Settings and navigate to Tools & Integration. Check the "dxdocs" MCP server status: the slider next to the server name should be green (indicates a successful connection).

JetBrains Rider

In JetBrains Rider, open the AI Assistant and type / to see available commands. Verify that the DevExpress MCP tools appear in the command list:

If using the GitHub Copilot Chat plugin, change the chat mode to Agent, click the Tools icon (🛠️), and ensure that DevExpress MCP tools are selected:

Step 4: Optimize Your AI Assistant with Custom Instructions

For best results when using the DevExpress documentation MCP server, define custom instructions to guide your AI assistant on how to use the tools effectively.

Use The Predefined DevExpress MCP Server Prompt

To activate the predefined prompt:

• Run the following command in the chat window:/mcp.dxdocs.devexpress_docs_query_workflow.
• Specify your question and submit the request.

Custom Instructions — VS Code, Visual Studio, and JetBrains Rider (GitHub Copilot)

Add a .github/copilot-instructions.md file to your solution directory. Below is a sample instructions file that you can customize and extend based on your requirements:

---
description: 'Answer questions about the DevExpress UI Components and their API using the dxdocs server'
---

You are a .NET/JavaScript programmer and DevExpress products expert.

Your task is to answer questions about DevExpress components and their APIs using dxdocs MCP server tools.

When replying to **ANY** question about DevExpress components, use the dxdocs server to construct your answer.

## Workflow:
1. **Call devexpress_docs_search** to obtain help topics related to the user's question
2. **Call devexpress_docs_get_content** to fetch and read the most relevant help topics  
3. **Reflect on the obtained content** and how it relates to the question
4. **Provide a comprehensive answer** based solely on retrieved information

## Constraints:
- **Use devexpress_docs_search only once** per question to avoid redundant queries
- **Answer questions based solely** on information obtained from MCP server tools
- If relevant code examples are available in documentation, **include those code examples**
- **Reference specific DevExpress controls and properties** mentioned in the docs
- If a user specifies a version (e.g., v24.2 or 24.2), invoke corresponding MCP server tools (e.g., dxdocs24_2)

Learn more about GitHub Copilot custom instructions in the following help topics:

• VS Code Custom Instructions
• Visual Studio Custom Instructions

Cursor

Navigate to the Settings > Rules & Memories window. Run the Add Rule command and specify a rule with similar content. For additional information about Rules in Cursor IDE, refer to the following help topic: Rules.

JetBrains Rider (AI Assistant)

Create a custon propmt in the AI Assistant chat as described in the following help topic: JetBrains Rider – Add and customize prompts.

Advanced Features

Custom Chat Modes (VS Code Only)

VS Code supports custom chat modes for specialized workflows. Chat modes are predefined configurations that allow you to tailor AI chat behavior in Visual Studio Code for specific tasks. You can switch between chat modes at any time in the Chat view, based on what you wish to accomplish.

A chat mode file is a Markdown file with the .chatmode.md suffix that contains:

Front Matter Metadata:

• description: Brief description displayed as placeholder text and in hover tooltips
• tools: List of available tools or tool sets for this mode
• model: Specific AI model to use (optional)

Body Content:

• Detailed instructions and guidelines for the AI to follow
• References to instruction files using Markdown links

Create a DevExpress Chat Mode

1. Open the Command Palette:
   • Windows/Linux: Ctrl+Shift+P
   • macOS: Cmd+Shift+P
2. Run the command: Chat: New Mode File. Alternatively, select "Configure Modes" from the chat mode dropdown
3. Choose the location: Select workspace or user profile
4. Enter a chat mode name (e.g., DevExpress Agent Mode)
5. Configure the chat mode file.

Here's a custom DX Agent Chat mode that you can tailor to your needs. The chat mode description is inspired by the Beast Mode prompt:

---
description: 'DevExpress development assistant using MCP server integration'
tools: ['codebase', 'usages', 'think', 'problems', 'changes', 'terminalSelection', 'terminalLastCommand', 'fetch', 'searchResults', 'githubRepo', 'editFiles', 'search', 'runCommands', 'runTasks', 'dxdocs', 'microsoft-docs']
model: 'Claude Sonnet 4'
---
You are a .NET/JavaScript programmer and DevExpress products expert.

Your task is to answer questions about DevExpress components and their APIs, and assist in application development. For **ANY** question about DevExpress components, use the dxdocs server to construct your answer.

## Workflow:

1. Understand the user's question and identify the relevant development platform, DevExpress component or API they are asking about.
   - If the question is about a specific DevExpress control, property, or feature, make sure to note it.
   - If the question is about a general concept or best practice, try to relate it to a specific DevExpress component or feature.  
   - Think critically about what is required to answer the question effectively, considering the context and the user's needs.
   - If the question is vague or lacks detail, ask for clarification to ensure you provide the most relevant information.
   - Use sequential reasoning to break down complex questions into manageable parts, focusing on the specific DevExpress components or APIs involved.
   - Develop a clear, step-by-step plan to address the question, ensuring you cover all necessary aspects related to DevExpress components and their APIs.
   - Implement code changes incrementally, make small, testable changes, and verify each step to ensure correctness.

2. Tool Usage:
    1. **Call devexpress_docs_search** to obtain help topics related to the user's question
    2. **Call devexpress_docs_get_content** to fetch and read the most relevant help topics
    3. **In case you receive the document not found error**, try to search again with a different query or use the **fetch** tool to get the content directly from the DevExpress documentation website
    4. **Reflect on the obtained content** and how it relates to the question
    5. **Provide a comprehensive answer** based on the retrieved information

## Guidelines:

- **Use devexpress_docs_search only once** per question to avoid redundancy
- **Base answers solely** on information from MCP server tools
- **Always include code examples** when available in documentation
- **Reference specific DevExpress controls and properties** mentioned in docs
- **Share links to relevant documentation** for further reading
- **Make incremental, testable changes** when implementing solutions

## Memory:

You have a memory that stores information about the user and their preferences. This memory is used to provide a more personalized experience. You can access and update this memory as needed. The memory is stored in a file called `.github/instructions/memory.instruction.md`. If the file is empty, you'll need to create it.

When creating a new memory file, you MUST include the following front matter at the top of the file:

---
applyTo: '**'
---

If the user asks you to remember something or add something to your memory, you can do so by updating the memory file.

For additional information (creating and customizing custom chat modes) see: VS Code Chat Modes

Troubleshooting Common Issues

MCP Server Not Appearing

Symptoms: DevExpress tools don't appear in the AI interface

Solutions:

1. Verify configuration file syntax — JSON must be valid
2. Restart your IDE after configuration changes
3. Check the server URL — ensure it's https://api.devexpress.com/mcp/docs
4. Confirm Agent Mode is enabled in your IDE settings

Tool Calls Failing Silently

Symptoms: The AI assistant doesn't use DevExpress tools even when requested

Solutions:

1. Add "Use dxdocs" explicitly to your queries
2. Check tool permissions in assistant settings
3. Verify network connectivity to the DevExpress MCP server
4. Restart the MCP server connection through IDE settings

Performance Issues

Symptoms: Slow responses or timeouts

Solutions:

1. Check network connection — ensure stable internet connectivity
2. Reduce query complexity — break complex questions into smaller parts
3. Monitor rate limits — avoid excessive requests in short timeframes
4. Try different AI models — switch between available models if experiencing issues

Additional Resources

Official Documentation

• Model Context Protocol Quickstart Guide
• Anthropic's MCP Introduction
• Microsoft's MCP Setup Guides for VS Code and Visual Studio
• Cursor MCP Documentation
• JetBrains MCP Guide
• Official MCP Servers Repository — Browse other available MCP servers
• GitHub MCP Registry — GitHub curated directory of MCP servers

Video Tutorials

• Visual Studio MCP Overview — Comprehensive setup walkthrough
• VS Code MCP Usage — Practical examples and tips
• Advanced VS Code MCP — Deep dive into advanced features

Related Tools

• Microsoft .NET Docs MCP Server: https://learn.microsoft.com/api/mcp — Helpful for general .NET development
• GitHub MCP Server: Official GitHub integration for repository management
• Playwright MCP Server: Browser automation capabilities using Playwright

Your Feedback Counts

We'll actively develop and improve our MCP server in the coming months, and we'd love to hear your feedback on our current implementation.

Quick Survey

Share Your Experience

We'd love to hear about your use cases and success stories: please report issues or request features via the DevExpress Support Center.

What's Next?

The DevExpress MCP server is just the start - We expect to introduce the following enhancements in the near future:

• Search through DevExpress Breaking Change documents to streamline/improve the upgrade process
• Access to DevExpress demo source code and examples
• Integration with the public community solutions database found in our Support Center

Free DevExpress Products - Get Your Copy Today