Enhance Kentico Development with a Custom AI Chat Mode in GitHub Copilot

Here at Kentico, we're fans of using agentic AI software development workflows to help us experiment more and move faster. With the speed of AI innovation happening across the software development tool landscape, it can be easy to miss AI capabilities in the tools you're already using.

One of those recently released and potentially overlooked tools is VS Code's custom chat modes for GitHub Copilot. Let's see how we can combine a custom chat mode and Context7's MCP server to bring Xperience by Kentico's guides and documentation directly into our Copilot experience.

Goal: Keeping our agent on track

General purpose large language models, like ChatGPT, Claude, or Gemini have expert-level knowledge about many topics but they can easily be tripped up by niche context details - like the difference between Xperience by Kentico's features and those in older versions of Kentico's products.

This product confusion can make it difficult to reliably use agentic software development in tools like Copilot, Cursor, or Claude Code - we know the difference between the products, but the LLM does not.

We'd like to focus the agent's attention and context on Xperience by Kentico exclusively when we ask questions about architecture, features, code examples, and best practices.

Context7 MCP server configuration

We already have a fantastic resource of well organized and detailed information about Xperience by Kentico - the Kentico Learn Portal!

If only we could give our agent access to all that context when asking questions...

Thankfully, our team here at Kentico already set up an open-source markdown repository containing all of our docs and training guides. This repository is indexed by Context7 - a service that parses and generates vector embeddings from software library documentation. We can query those embeddings using the Context7 MCP server.

VS Code added support for MCP servers earlier this year and Context7's repo documents how to configure theirs in one simple step.

The MCP server is delivered via an npm package, but VS Code handles the installation.

{
  "servers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp@latest"]
    }
  },
  "inputs": []
}

We just need to create a file .vscode\mcp.json and add the server configuration above to the file.

Once added, you can start the MCP server by hovering over the context7 JSON property key, using the VS Code menu, the visual management interface.

We now have the documentation data source set up, but we need our AI agent to use it and not get distracted with older Kentico product information.

Create a new chat mode definition

Chat modes in GitHub Copilot let you change how the LLM model is used by Copilot. There are 3 built-in modes, with Agent mode being the most commonly used for agentic AI software development workflows.

Custom chat modes give us even more control over the AI chat experience.

Let's create a custom chat mode for documentation search.

---
description: "Search through Xperience by Kentico's 
documentation and training materials for information about product 
architecture, features, best practices, API information, 
and code examples."
tools: ["context7"]
---

# Xperience Docs Search instructions

You are in search mode. Your job is to search Xperience by Kentico's 
documentation and guide materials to answer questions about specific 
product architecture, feature, best practices, API information, 
and code example topics.

When searching, always prioritize the documentation resources for 
answers on features, tools, and APIs.

## Response style

The response should be brief and to the point. Prefer concise answers
that directly address the request. The goal of the response is to 
help the user find the information they need quickly and efficiently.

## Response content

You should respond to questions with the following information

- The product architecture, feature, or API that is most applicable 
   to the request
- Related product concepts that might give helpful context to the 
   request
- Example code, if this has been requested
- Inline links and citations to the source documentation to make it 
   easy to navigate to the docs and discover more on the requested topic
- Best practices and tips related to the request and potential issues
   to watch out for

We're being very explicit with the chat mode description, request, and response guidelines and also limiting the tools that the AI has access to. In this case it can only use Context7 to do documentation searches and cannot access the repository, so I don't need to worry about surprise edits when I just want to learn about a feature.

If we wanted a general purpose set of rules we could instead use custom instructions, but we want to make sure that when we're doing product or API exploration we aren't accidentally misled by outdated information coming from a web search or the model's training.

Using a custom chat mode also lets us avoid overloading the context window for the agent with a bunch of rules about code or git commit conventions that aren't relevant to a documentation search and summary.

Ask Copilot about Xperience by Kentico's product features

Now let's open the GitHub Copilot chat interface and change the chat mode to the one we just created.

Here's an example request I made to Copilot using this documentation search chat mode.

How does digital commerce work with the Email Builder?

And here's the response that came back from Copilot, using the Context7 MCP server and the Xperience by Kentico documentation and guides.

[Inject]
private IEmailBuilderOrderContextAccessor OrderContextAccessor { get; set; } = default!;

[Inject]
private IInfoProvider<OrderInfo> OrderInfoProvider { get; set; } = default!;

protected override async Task OnInitializedAsync()
{
    if (!EmailContextAccessor.GetContext().IsPreview)
    {
        // Get order ID from context
        int orderId = OrderContextAccessor.Context.OrderId;
        
        // Retrieve order details
        OrderInfo order = await OrderInfoProvider.GetAsync(orderId);
        decimal? orderGrandTotal = order?.OrderGrandTotal;
        
        // Get order items
        IEnumerable<OrderItemInfo> orderItems = await OrderItemInfoProvider.Get()
                    .WhereEquals(nameof(OrderItemInfo.OrderItemOrderID), orderId)
                    .GetEnumerableTypedResultAsync();
    }
}

// From your Program.cs
builder.Services.AddKentico(features =>
{
    features.UseCommerce();           // Digital commerce
    features.UseEmailBuilder();      // Email Builder
    features.UseEmailMarketing();    // Email marketing
});

if (!EmailContextAccessor.GetContext().IsPreview)
{
    // Use real order data
}
else
{
    // Use sample order data for preview
}

This is a pretty good summary about how to use the Email Builder in a digital commerce scenario and I especially like the simple best practices called out near the bottom with additional links to the docs if I want to investigate related topics in detail.

Where do we go from here?

I got the idea for this Xperience Docs Search chat mode by watching this video from the VS Code team about custom chat modes and in my limited experiments it has worked really well.

If I were to further enhance this custom chat mode I think I would include instructions to identify where I could apply the topic I searched for in my project, or where I wasn't following best practices.

I might try defining a couple styles of response

• Detailed - basically what we have now

• Brief - a short description and links to the docs but nothing else

• Example code - just showing example code that I could quickly copy and paste into my project or ask an agent to reference to build a new feature

Have you had any experience with custom chat modes or have you preferred to stick to things like prompt files and custom instructions?

Let me and others know what's working for you in the discussion for this post!