Polarionmcpservers

This project provides an MCP server implementation integrated with the Polarion ALM system, supporting deployment through Docker and local operation, and realizing functions such as work item reading.

Developer tools Knowledge management and memory #ALM integration #Work item management #SSE service #Docker deployment .C#

rating : 2.5 points

downloads : 219

update time : 2025-04-28

What are Polarion MCP Servers?

Polarion MCP Servers are integrated services designed for the Polarion Application Lifecycle Management (ALM) system, providing access to Polarion work items through the Model Context Protocol. It includes two deployment methods: a remote server version based on SSE and a local console version.

How to use Polarion MCP Servers?

You can quickly deploy the remote server version through a Docker container or download the local console version and run it directly. After deployment, configure the client tool to connect and start using.

Use cases

Suitable for teams that need to integrate Polarion work item data into development environments (such as VS Code) or AI assistants (such as Claude), achieving seamless integration between the development process and requirements management.

Main features

Remote accessProvides the ability to remotely access Polarion work items through SSE (Server-Sent Events) technology

Local integrationThe console version supports direct integration of Polarion data on local workstations

Multi-client supportSupports multiple client tools such as Cline, VS Code, and Claude

Advantages and limitations

Advantages

Simplify the process of accessing Polarion data

Support integration with multiple development environments and tools

Provide a containerized deployment solution for easy maintenance

Limitations

Claude Desktop currently does not support the SSE protocol

Requires configuration of Polarion server connection information

Only supports reading work items, not writing

How to use

Prepare the deployment environment

Create a configuration directory on a Linux server and download the Docker image

Configure connection information

Create an appsettings.json file and configure the Polarion server connection parameters

Start the container

Run the Docker container and map ports and configuration files

Usage examples

VS Code integrationConfigure the connection to the Polarion MCP server in VS Code to view relevant requirements in real-time

Team requirements reviewThe development team can directly view Polarion requirements in the IDE without switching applications

Frequently Asked Questions

How to verify if the server is running normally?

Why can't Claude Desktop connect?

How to update the Polarion connection configuration?

Related resources

Polarion official documentation

Official documentation for the Polarion ALM system

MCP protocol specification

Technical specification for the Model Context Protocol

Example project repository

Example code for Polarion MCP integration

🚀 Polarion Model Context Protocol (MCP) Server

This repository contains an implementation of the Model Context Protocol (MCP) server for Polarion Application Lifecycle Management (ALM) integration.

The MCP tool can be used with Polarion work items, including:

Reading Polarion work items

📦 Projects

PolarionRemoteMcpServer: An SSE-based MCP server suitable for server-side installation.
PolarionMcpServer: A console-based MCP server suitable for Polarion workstation integration.

🐳 Running via Docker and Linux Server (Recommended)

On your Linux server, create a configuration and log directory:

mkdir -p /opt/polarion-mcp-server
cd /opt/polarion-mcp-server

Pull the Docker image:

docker pull tizzolicious/polarion-remote-mcp-server

Create a custom /opt/polarion-mcp-server/appsettings.json file and adjust it according to your Polarion configuration:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "PolarionClientConfiguration": {
    "ServerUrl": "https://your-polarion-server/",
    "Username": "your-username",
    "Password": "your-password",
    "ProjectId": "your-project-id",
    "TimeoutSeconds": 60
  }
}

Run the Docker container:

docker run -d \
  --name polarion-mcp-server \
  -p 8080:8080 \
  -v appsettings.json:/app/appsettings.json \
  tizzolicious/polarion-remote-mcp-server

Now the server should be up and running. You can access it via http://{{your-server-ip}}:5090/sse.

⚙️ Configuration Options

The /opt/polarion-mcp-server/appsettings.json file in the PolarionClientConfiguration node requires the following settings:

Setting	Description
ServerUrl	Your Polarion server URL (e.g., "https://polarion.example.com/")
Username	A Polarion username with appropriate permissions
Password	The password for the Polarion user
ProjectId	The ID of the Polarion project to access
TimeoutSeconds	The connection timeout in seconds (default is 60)

💻 Configuring the MCP Client

In Cline:

Open the MCP settings UI in Cline.
Click the "Remote Server" tab.
Set the "Server Name" to "Polarion".
Set the "Server URL" to "http://{{your-server-ip}}:5090/sse".
Click "Add Server".

In Visual Studio Code:

Add the following configuration to your settings.json file:

"servers": {
    "polarion-remote": {
        "type": "sse",
        "url": "ttp://{{your-server-ip}}:8080/sse",
        "env": {}
    }
}

In Claude Desktop:

Open the "Settings" menu in Claude.
Select "Project Settings".
Add a new "Remote Server":
- Set the type to "MCP".
- Set the URL to "http://{{your-server-ip}}:8080/sse".

🛠️ Building the Project

Requirements

.NET SDK version 6 or higher
Docker installed on your system

How to Build

Clone this repository to your local machine.
Open a terminal and navigate to the cloned directory.
Run the following command to build the project:
```
dotnet build
```

How to Publish

Run the following command in the terminal to generate the Docker image:
```
docker-compose build
```
To run the server, execute the following command:
```
docker-compose up
```

By following these steps, you should be able to successfully set up and run the Polarion MCP server.