Model Context Protocol (MCP) is an open standard created by Anthropic that allows AI agents to securely connect to external data sources and tools. GitLab supports MCP in two ways:

• MCP Clients: Connect GitLab’s Duo features like Agentic Chat (part of Duo Agent Platform) to external MCP servers to access and interact with data and tools in external systems.
• MCP Server: Allow external AI tools to connect to your GitLab instance and let these tools have secure access to projects, issues, merge requests and more.

This article focuses on GitLab’s MCP client capability, demonstrating how to connect both the GitLab knowledge graph and Jira through MCP. We will also have a look at the MCP Dashboard. The content draws from the official GitLab documentation, my colleague Falko Sieverding’s excellent work (for example here and here), and my own homelab testing.

Disclaimer: Notice that the capabilities being discussed in this blogpost are currently in experimental or beta status, handle with caution.

Prerequisites

GitLab’s MCP Client is currently supported in Visual Studio Code (VSC), VS Codium (a VSC fork) and the IDEs provided by JetBrains. You can use MCP in Duo Agentic Chat and in the software development flow. Duo Agentic Chat is part of Duo Agent Platform (DAP), so this should be enabled in your environment, on top on some other prerequisites mentioned here.

VSCodium

You’ll need one of the supported IDEs, I have VSCodium running on my MacBook:

brew upgrade vscodium

You’ll also need the GitLab workflow extension available (same applies to VSC):

codium --install-extension GitLab.gitlab-workflow --force

and/or update the extension to the latest version:

codium --update-extensions

Visual Studio Code

Or if you’re using Visual Studio code:

code --install-extension GitLab.gitlab-workflow --force
code --update-extensions

For VSCodium and VSC you need to enable all GitLab Duo settings under Settings>Extensions>GitLab Workflow>GitLab Duo.

GitLab CLI

Also install the GitLab CLI (glab):

brew install glab

and/or update glab to the latest version with:

brew upgrade glab

GitLab Knowledge Graph

Now let’s have a look at the GitLab Knowledge Graph. With the GitLab Knowledge Graph (GKG) you create a structured, queryable representation of code repositories that will power your AI agents.

The GitLab Duo Agent Platform uses the GitLab Knowledge Graph to increase the accuracy of AI agents. You can use the Knowledge Graph framework in your AI projects to enable rich code intelligence across your codebase (source).

The GKG generates a project graph for your repo that you can use yourself but can also be leveraged by AI agents, such as the Agentic Agent that is part of Duo Agent Platform.

Installing the GKG is done through this one-liner:

curl -fsSL https://gitlab.com/gitlab-org/rust/knowledge-graph/-/raw/main/install.sh | bash

The Knowledge Graph consist of a service component that is running on your laptop and a GKG command line CLI. When you navigate to your project directory and run:

gkg index

The knowledge graph will discover Git repositories and the current- and sub-directories, analyze the code and store the results. You can access the knowledge graph via

http://localhost:27495

After you’ve verified the gkg CLI command is accessible in your terminal, you can also access the GitLab Knowledge directly from your IDE (VSC, VSCodium, Jetbrains). In VSC/VSCodium just use Cmd+Shift+P and look for Knowledge Graph. If the current project is not indexed, it will be indexed automatically and displayed in the IDE.

Model Context Endpoint

The Knowledge Graph exposes a HTTP endpoints to interact with available data, both HTTP and Server-Sent Events (SSE) are supported. For Agentic Chat to interact with the knowledge graph, you need to configure ~/.gitlab/duo/mcp.json:

{
  "mcpServers": {
    "knowledge-graph": {
      "type": "sse",
      "url": "http://localhost:27495/mcp/sse",
      "approvedTools": true
    }
  }
}

Another option is to add the mcp.json configuration directly into the project, storing mcp.json in the .gitlab/duo/ directory. After restarting the IDE, you can test the connection by asking Agentic Chat to use the Knowledge Graph:

Using the knowledge graph, can you summarize this project for me?

As you can see, Agentic Chat is now leveraging the information that is stored in the Knowledge Graph, so that is great news.

Connect to Jira

We can use Model Context Protocol to connect to Jira and enrich Agentic Chat and the software development flow.

For this, you’ll need a Jira account and to configure the client connection using the mcp.json file mentioned earlier. You can find an extensive list of supported clients and their configuration instructions on this page. The ‘Setting up IDE‘ scenario is most relevant for our use case.

The most easy way to configure MCP is to add the code under “option 3” in our mcp.json, so it will look like this:

{
  "mcpServers": {
    "knowledge-graph": {
      "type": "sse",
      "url": "http://localhost:27495/mcp/sse",
      "approvedTools": true
    },
    "atlassian-mcp-server": {
      "type": "sse",
      "url": "https://mcp.atlassian.com/v1/sse",
      "approvedTools": true
    }
  }
}

You may need to restart your IDE after applying this change.

Type Setting

Although the official documentation states that the type for the atlassian-mcp-server is http, I ran into issues here.

{
  "status": "error",
  "error": {
    "code": "AUTH_FLOW_FINALIZATION_FAILED",
    "message": "OAuth flow finalization failed for server: atlassian-mcp-server"
  }
}

After changing it to sse everything works as expected.

"type": "sse"

Approved Tools Setting

You may have noticed I’ve added the line:

approvedTools: true

is added to the configuration. With this you tell DAP to fully trust this MCP connection. You can also use to just trust a subset of tools that this MCP server is providing. Then you would get something like:

approvedTools: ["getAccessibleAtlassianResources", "getJiraIssue"]

If a tool is not approved, DAP will ask you to approved every time a specific tools is being used.

Test the connection

Now it’s time to test the connection to Jira, you can simply ask a question about the information available in Jira:

List all the tasks that are in the My Software Team space in Jira.

You can also ask the GitLab agent to create Jira tasks directly. For example:

Create a new task in “My Software Team” in Jira with the title “Triage high and critical software vulnerabilities”. In the description, add the necessary steps to triage these vulnerabilities in GitLab. Set the status to “In Progress” and assign it to me. The due date is December 31st, 2025.

The agent processes this request and creates a new Jira issue matching the specifications:

You can also use the information in a task to build a new feature in your app of course.

MCP Dashboard

The MCP Dashboard is a capability that was recently added and is available in your IDE. This dashboard gives insight on the connection status of the MCP client(s), and also provides information on the tools that are being used. You can access the dashboard using Cmd-Shift-P in VSC / VSCodium and search for “MCP”. Then choose GitLab: Show MCP Dashboard. You’ll see something similar to this:

You can click each of the tiles to get more information about the connection status, available tools as well as the server logs – what tools are being executed by the client:

I think this is a very valuable addition to the work GitLab is doing in this area.

Wrapping up

This article we’ve explored GitLab’s MCP client capabilities, demonstrating how to leverage both the GitLab Knowledge Graph and Jira integration to enhance your AI-powered development workflow. We walked through the prerequisites, installation steps, and configuration needed to connect these tools to GitLab Duo’s Agentic Chat, and explored the valuable MCP Dashboard for monitoring connection status and tool usage.

While these features are still in experimental or beta status, they showcase the exciting potential of connecting external data sources and tools through the Model Context Protocol standard. I hope this guide has been helpful in getting you started with GitLab’s MCP client functionality in your own homelab or development environment. If you have any specific questions or run into issues while setting this up, please feel free to leave a comment below!