openproject-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct resource or action: current user, projects, work-package search, single work package, comments, statuses, and types. There is no meaningful overlap between search_work_packages and get_work_package because one is full-text search and the other is retrieval by ID.
Naming Consistency5/5
All tools follow a consistent verb_noun snake_case pattern: get_current_user, list_projects, search_work_packages, get_work_package, and so on. The one longer name, get_work_package_comments, still fits the established convention.
Tool Count5/5
Seven tools is a well-scoped size for a read-oriented OpenProject integration. Each tool has a clear purpose and none are redundant, so the count feels intentional rather than padded or thin.
Completeness2/5
The surface is entirely read-only: it can search, view, and list work packages, projects, comments, statuses, and types, but it cannot create, update, transition, or comment on work packages. For a project-management domain this is a significant functional gap that prevents agents from completing common workflows.
Average 4.2/5 across 7 of 7 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must carry behavioral weight. 'List' implies a read-only operation and 'configured on this instance' clarifies scope, but it does not explicitly state side-effect-free behavior or return format details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence contains the verb, resource, scope, and clarifying examples with no filler or repetition of the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless listing tool with no output schema, the description fully covers what the agent needs: it identifies the resource, the instance scope, and representative returned values. Nothing material is missing for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, which warrants a baseline of 4. The description adds context about what the output domain is (configured work package types) even though there are no input semantics to document.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses a specific verb ('List') and resource ('work package types configured on this instance') and gives concrete examples (Task, Bug, Milestone), which clearly separates it from siblings like list_projects and list_statuses.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The read intent is implied: when an agent needs work package types, this is the obvious tool. However, the description does not explicitly state when to use it over alternatives such as list_statuses or list_projects, nor does it mention any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It conveys that the operation is a read/identity lookup and adds the useful behavioral context of being a precursor to search_work_packages. However, it does not disclose output shape, possible errors, or whether authentication is required.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler: the first states the purpose, the second gives a direct usage instruction. Every phrase adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool, the description is nearly complete: it says what the tool does and when/how to use it. It omits details about the exact response format, but with no output schema that is a minor gap for such a simple identity-lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema provides no parameter documentation. The description compensates by explaining the intended data flow into search_work_packages, which is more useful than any parameter description would be here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource ('Identify the OpenProject account this server authenticates as') and clearly distinguishes this from sibling tools by focusing on the authenticated identity rather than work packages or projects. It is not a tautology of the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to call the tool ('when a question says 'my' or 'me'') and how to use its result ('then pass assignedToMe to search_work_packages'). It lacks an explicit when-not-to-use statement or alternatives, but the guidance is clear and actionable for the common case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states 'Read', which implies a non-mutating operation, but does not disclose potential errors (e.g., invalid id), auth requirements, or response characteristics. Given the lack of annotation support, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the primary purpose front-loaded and the usage hint in a separate sentence. No filler or redundant phrasing; every part contributes to the agent's understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter read operation with no output schema, the description adequately covers what it returns (full work package with specified fields) and how to get the id. It omits error handling details, but these are less critical for a straightforward fetch. Overall, it is sufficiently complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the id parameter (with an example), and the description adds operational context by directing the agent to get the id from search_work_packages. This goes beyond the schema's static definition by explaining how to obtain a valid value, which is helpful for correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads one work package in full, listing specific fields (description, priority, author, progress). It distinguishes from sibling tools like search_work_packages (which searches) and get_work_package_comments (which fetches comments only) by focusing on full details of a single work package.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly instructs the agent to obtain the id from search_work_packages first, establishing a clear usage workflow. This also implies when to use this tool (after searching) and implicitly differentiates it from alternatives like search (for lists) or comments (for a subset of data).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral disclosure burden. It adds meaningful behavior—comments are ordered oldest first, and status changes without an accompanying comment are omitted—which goes beyond the tool name and helps an agent predict output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences deliver the essential behavior and constraints with no filler. The core purpose is front-loaded, and the ordering/filtering detail adds necessary specificity without bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with two well-documented parameters, the description is largely complete: it specifies scope, ordering, and an important filtering rule. It could mention the return shape slightly more explicitly, but the tool name and schema make this a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents the 'id' and 'limit' parameters well. The description does not add parameter-specific meaning beyond referring to 'one work package,' so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Read') and resource ('comments on one work package'), making the tool's purpose immediately clear. It also distinguishes itself from siblings like get_work_package by focusing on comments rather than the work package itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use this tool to read comments for a single work package. It does not explicitly mention alternatives or when-not-to-use, but the sibling tools are distinct enough that no exclusion is necessary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the behavioral burden. The verb 'List' implies a read-only operation and 'configured on this instance' indicates instance-level data, but the description does not explicitly mention side-effect-free behavior, permissions, or return format. This is a minor gap for a zero-parameter list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences: the first states the core operation, the second gives a practical use case. There is no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter list tool with no output schema and no annotations, the description covers what the tool does and when to invoke it. It could add more detail about the returned status shape, but that is not essential for deciding to call the tool; no critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the description has no parameter documentation burden. The baseline of 4 applies because nothing about parameters needs to be explained; all schema properties are already covered.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States the specific action ('List') and exact resource ('work package statuses configured on this instance'). It is clearly distinguishable from sibling list tools like list_projects and list_types because it names the resource. No ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides a concrete trigger scenario: when a question names a status and the agent needs to verify whether it exists. It does not explicitly discuss when not to use it, but given the resource-specific siblings, the context is clear enough. This is adequate usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears the burden of explaining behavior. It discloses account-scoped visibility, the expected output fields, and a downstream usage constraint. It does not explicitly state 'no side effects' or discuss rate limits, but for a list operation the core behavioral details are present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler: the first defines the operation and result fields, and the second connects the output to a sibling tool. The most important scope detail is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-optional-parameter list tool, the description plus schema fully covers what the agent needs: what is returned, scope visibility, and how to use the result downstream. No output schema is declared, but the stated fields are sufficient for calling the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents both parameters (limit and query) with 100% coverage, so the description need not repeat them. It also adds no parameter-specific nuance, keeping it at the baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource ('List the projects visible to this account') and names the returned fields. It also differentiates itself from the sibling search_work_packages by explaining that its returned id is the projectId for that tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear context for when to call this tool: to see account-visible projects and obtain ids for scoped work-package searches. It does not explicitly enumerate exclusions or alternative tools, but the workflow pointer is concrete and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden and does a good job: it states the query-less default, that only open items are listed unless includeClosed is set, and that full descriptions are intentionally deferred to another tool. It does not mention pagination or auth expectations, but neither is critical for a read-only search call.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, no filler, and the most important behavioral detail (query-less default) is front-loaded. Every sentence contributes either purpose, behavior, return content, or a routing pointer.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no output schema, the description enumerates the returned fields and the follow-up path to get_work_package, which is enough for an agent to chain calls. It is not exhaustive about all sibling relationships or edge-case behaviors, but it is complete for the tool's core use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds meaningful value by explaining what happens when query is omitted—it lists the most recently updated open items—thus clarifying query's optionality and the implied ordering/filtering beyond what the schema states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a clear action ('Search work packages') and resource, then clarifies the kinds of entities included (tasks, bugs, milestones) and the full-text scope. It also distinguishes itself from get_work_package by noting it returns only summary fields and that details come from the sibling tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains the default behavior when no query is given and explicitly routes the agent to get_work_package for full descriptions. It does not enumerate when to prefer other siblings like list_statuses or list_types, but the most important differentiation is present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![openproject-mcp MCP server](https://glama.ai/mcp/servers/Nraitschew/openproject-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Nraitschew/openproject-mcp)

Score Badge

Copy to your README.md:

[![openproject-mcp MCP server](https://glama.ai/mcp/servers/Nraitschew/openproject-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Nraitschew/openproject-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Nraitschew/openproject-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server