Klaro Cards joins the MCP frenzy

If you're tech-savvy and passionate about the field of AI (Artificial Intelligence), you've probably already heard of it—maybe you've read about it or even experimented with it yourself.

But if you've never heard of MCP (Model Context Protocol) and you're curious to learn more, you can check it out at https://modelcontextprotocol.io/introduction.

This blog post is aimed at the more techy, hacky, geeky pioneers among you. So feel free to skip it if it's not quite your cup of tea.

MCP is everywhere. It's on everyone's lips, and not a week goes by without big news surrounding it.

Naturally, we've decided to follow this momentum and experiment with MCP ourselves.

MCP concepts

The Model Context Protocol (MCP) is an open protocol that enables integration between LLM (Large Language Model) applications and external APIs, tools, or data sources.

In other words, it's what allows you to interact with external systems via LLMs and natural language—whether that’s your favorite email provider, GitHub, PostgreSQL, or even your go-to 3D creation software.

The MCP specification introduces a number of key concepts. Among them are three fundamental primitives that MCP servers expose to MCP clients (which we'll simply refer to as “chatbots” for the rest of this post):

• Prompts – Predefined, reusable prompt templates designed to guide the chatbot in specific tasks or workflows.
• Resources – Read-only data sources the chatbot can access when relevant.
• Tools – Functions the chatbot can call to take action or trigger operations (e.g. API requests, database updates, etc.).

What this means for Klaro Cards

In the context of Klaro Cards, we could expose:

• Resources such as cards, boards, and project metadata available to the user.
• Prompts templates of chat prompts tailored for the context of Klaro Cards and ready to assist with onboarding, project setup, or advanced configuration tasks.
• Tools that allow the chatbot to create or update cards, dimensions, and boards.

Together, these MCP primitives turn Klaro Cards into an LLM-friendly, API-aware environment—allowing users to interact with their project data using natural language in a powerful and secure way.

Experimenting with Klaro Cards's MCP server

To start experimenting with our MCP server, you'll need to authenticate with it. While we're currently working on adding support for an OAuth2 authentication flow, for now, we’ll stick to using our trusty JWT tokens.

You can obtain a valid JWT token in two ways:

• Using our API via curl or postman. Check out the documentation of the POST /auth/tokens web service
• Using your browser’s network inspector during a normal session in Klaro Cards' web application. Check for XHR requests sent to an api endpoint, and find the Authorization header sent to the backend.

The Klaro Cards MCP server is only installed on the public cloud version of Klaro Cards (for projects hosted on https://xxx.klaro.cards). If you have subscribed to a dedicated Klaro Cards instance and would like the MCP server to be deployed there, please contact your Klaro Cards representative.

Setting up Copilot in VSCode

To set up Copilot to use Klaro Cards's MCP server, open the command palette (CMD/CTRL-SHIFT-P) and run:

MCP: Open User Configuration

Then make sure the configuration file that VSCode opens (mcp.json) includes an entry like this:

{
  "servers": {
    "klaro": {
      "url": "https://ai.klaro.cards/mcp",
      "headers": {
        "Authorization": "Bearer eyJhbGciOiJIUzI1NiJ9..." // This is where you place your JWT token
      }
    }
  }
}

Once that's done, VSCode should offer the option of starting the MCP client for Klaro Cards’s server (see screenshot). If everything goes well, you should see that VSCode successfully connects and fetches the list of available tools.

At the time of writing, there are 16 tools available—but don’t be surprised if that number is higher when you try it out. It just means we geeked out a little more 😄

So, VSCode is now connected to our MCP server—what’s next?

Creating a Copilot Chat mode with a System Prompt

We recommend creating a dedicated chat mode in Copilot to avoid any accidental interactions with other tools or settings.

To do this:

• Open the Copilot side panel.
• At the bottom, click the dropdown that lets you switch between modes (Agent, View, Edit).
• Select "Configure modes". This will open the command palette and let you choose: + Create new custom chat mode file

VSCode will ask where you'd like to store the new mode file—either in the current workspace/project or globally. It will also prompt you to name it. We suggest naming it: Klaro

VSCode will then open a new YAML file where you can define the chat mode description, specify the tools it can access, and write a system prompt for the agent.

Here’s an example of ours:

---
description: 'Klaro.cards'
tools: ['klaro'] # important, this must match the name you've chosen for the MCP server in mcp.json
---
You are an expert assistant for Klaro.cards — a flexible, non-opinionated information management system built around cards, dimensions, and boards.

Each Klaro project consists of cards, which represent atomic pieces of structured content. Every card includes:
- A single "Kind" dimension,
- A title (from a unique "Title" dimension),
- And optionally, a specification (from a unique "Specification" dimension, also sometimes referred to as the card’s content or description).

Cards can be further enriched with additional user-defined dimensions.

Dimensions define structured data fields attached to cards. Each dimension has a name, a data type (e.g., Text, Integer, Date, UserDefined, ProjectMember, or Reference), and may support multiple values or be marked as required.

Boards are saved views that combine filters on dimensions with a display mode (e.g., Kanban, List, Matrix, Gantt, Gallery, or Chart). Filters can be applied to any dimension and are used to narrow down the set of visible cards.

You can interact with the Klaro MCP API using the available tools to:
- List and inspect projects, cards, dimensions, and boards.
- Create, edit, and delete cards or their values.
- Filter, group, or sort cards based on dimension values.
- Analyze project data and extract insights.
- Understand relationships between linked cards via reference dimensions.

Be precise, proactive, and helpful when guiding users. When in doubt, ask for clarification before performing actions.

Don't forget to select that chat mode in the dropdown when created. You're now ready to interact with Copilot to manage your Klaro Cards project.

Setting up OpenAI's platform

If you've got an account at OpenAI, you should be able to integrate with Klaro's MCP.

• Head to OpenAI platform to create a new chat
• In the tools section of your new prompt click on MCP Server
• In the next modal, click on + Add new
• Then provide the MCP connection information:
  • URL: https://ai.klaro.cards/mcp
  • Label: Klaro
  • Description: Klaro
  • Authentication: 'Access token / API key' and place your token
• If everything goes well, you should then see a list of all the tools provided by the MCP server