The Copr MCP server lets you interact with Fedora Copr (a build system for RPM packages) to manage builds, projects, and repositories through an AI agent interface.
Check build status – Get the current state of a specific Copr build by ID.
List builds in a project – Retrieve all builds for a given Copr project (ownername/projectname).
Create a project – Create a new Copr project with a specified owner and build chroots (e.g., fedora-rawhide-x86_64).
Submit builds – Initiate new builds from supported source types like PyPI or DistGit.
Enable a repository – Get instructions for enabling a Copr repository on a user's system.
List mock chroots – List all available mock chroots (build targets) across Fedora/RHEL versions and architectures, or those configured for a specific project.
Get build log URLs – Retrieve log URLs for a build, including SRPM, dist-git import, and per-chroot logs.
Fetch build log content – Download and return the text content of a build log.
Check authentication – Verify whether the user's API auth key is valid.
Provides tools for managing Fedora Copr builds and projects, including checking build status, listing recent builds, building packages, and creating projects.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Copr MCP List the last 5 builds in frostyx/foo"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Please see the First look at the Copr MCP server.
Install dependencies
uv syncRelated MCP server: TeamCity MCP Server
Register the MCP server with Claude Code, Codex, Cursor, or any other agent.
To register the copr server with Claude Code, execute this command
$ claude mcp add copr --scope user \
-- uv run --directory "$(pwd)" python main.pyIf you don't need this MCP server anymore, uninstall it.
$ claude mcp remove copr$ codex mcp add copr -- uv run --directory "$(pwd)" python main.pyIf you don't need this MCP server anymore, uninstall it.
$ codex mcp remove coprIf you use Cursor, open or create ~/.cursor/mcp.json and add the copr
entry to the list of mcpServers.
Change the directory (~/src/copr-mcp) to wherever you've cloned this
copr-mcp project.
{
"mcpServers": {
"copr": {
"command": "uv",
"args": [
"run",
"--directory",
"~/src/copr-mcp",
"python",
"main.py"
]
}
}
}If you don't need this MCP server anymore, removing the copr
entry from the mcpServers list in ~/.cursor/mcp.json.
Open the Command Palette in VSCode by pressing
Ctrl+Shift+P. Then type >MCP: Open User Configuration. The file mcp.json that opens should look something like this:
{
"servers": {}
}Add the copr MCP server like so:
{
"servers": {
"copr": {
"type": "local",
"command": "uvx",
"args": ["--from", "git+https://github.com/fedora-copr/copr-mcp@main", "--verbose", "copr-mcp-server"]
}
}
}Save the file (~/.config/Code/mcp.json) and start the server by hitting the
little "Save" link that appears right above the line with "copr": {.
Test the server by opening the Chat view with Ctrl+Alt+I. Then type the following and press Enter:
Use copr_list_mock_chroots from the copr MCP server and list all supported mock chroots.You should see a Run copr_list_mock_chroots copr (MCP Server) followed by some
text and a button that says Allow in this Session.
If you don't need this MCP server anymore, remove the copr entry from the
servers list in the MCP: Open User Configuration
(~/.config/Code/mcp.json).
Once the MCP server is registered, go to i.e. Claude or Cursor and ask it questions like
Tell me the status of Copr build 8101723
Can you give me last 5 builds from the frostyx/foo Copr project?
Build the DistGit package hello in my frostyx/foo project
Create a Copr project frostyx/foo with a fedora-43-x86_64 chroot
Go to https://console.anthropic.com, "API Keys" and generate a new key. Then export it in your terminal:
$ export ANTHROPIC_API_KEY=...Then run
$ uv run main.py --prompt "Tell me the status of Copr build 8101723"To use a different model pass --model
$ uv run main.py --model gpt-5-mini --prompt "Tell me the status of Copr build 8101723"Full list of models can be found here: https://pydantic.dev/docs/ai/api/models/base/#pydantic_ai.models.KnownModelName
$ uv run mypy .
$ uv run ruff check
$ uv run pytestCall an endpoint protected by login to check whether the user auth key is valid
:return: Munch
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description only indicates a login-protected endpoint call. It does not disclose side effects (likely none), error handling, or rate limits. 'Munch' is unclear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences; the core action is stated concisely. However, the ':return: Munch' line is confusing and detracts from clarity; could be omitted or clarified.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should explain the return value. 'Munch' is not standard; the agent lacks information about the response format or what 'valid' means semantically.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, so schema coverage is trivially 100%. Baseline of 4 is appropriate as the description doesn't need to explain parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks user auth key validity via an endpoint. It is a specific verb+resource, and sibling tools are unrelated (copr_*), so differentiation is not needed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the status of a Copr build by its ID.
| Name | Required | Description | Default |
|---|---|---|---|
| build_id | Yes |
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| state | Yes | |
| name | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description alone must disclose behavioral traits. It only states 'Get the status,' implying a read operation with no side effects, but fails to mention auth requirements, error handling, rate limits, or what happens for invalid IDs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, front-loaded with the key information. Given the simplicity of the tool (one parameter, straightforward task), it is appropriately concise, though it could include a bit more detail without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema, so return values are covered. However, given the low parameter coverage and lack of usage guidelines, the description is minimally adequate for a simple retrieval tool but lacks context for an agent to use it correctly in all scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description should add meaning to the parameter. It only says 'by its ID,' which adds no extra information beyond the field name in the schema (build_id). No examples, constraints, or format details are provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get the status of a Copr build by its ID' uses a specific verb and resource, clearly indicating what the tool does. It distinguishes itself from siblings like copr_list_builds (which lists builds) and copr_get_build_log (which retrieves logs).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have a build ID, but it does not provide explicit guidance on when to use this tool versus alternatives like copr_list_builds or copr_get_build_log. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a Copr project with a given name for a specified owner.
When creating a new project, at least one chroot must be specified. For
example fedora-rawhide-x86_64
| Name | Required | Description | Default |
|---|---|---|---|
| ownername | Yes | ||
| projectname | Yes | ||
| chroots | Yes |
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| web_url | Yes | |
| ownername | Yes | |
| name | Yes | |
| full_name | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Only discloses that chroots are required; lacks details on permissions, side effects, duplication handling, or whether it is idempotent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first defines purpose, second adds critical constraint. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Has output schema, so return values not needed. Lacks information about error handling, idempotency, or prerequisites beyond chroots.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage; description adds meaning by linking 'ownername' to owner, 'projectname' to given name, and specifying that chroots must include at least one with an example format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb 'create' and resource 'Copr project', clearly distinguishing from sibling tools which are about builds, logs, chroots, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
States requirement of at least one chroot with example, but does not explicitly mention when to use this tool versus alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Provide instructions for enabling a Copr repository on the user system. This requires root privileges and must be run manually by the user.
| Name | Required | Description | Default |
|---|---|---|---|
| ownername | Yes | ||
| projectname | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries full burden. It discloses that the tool provides instructions rather than performing the action directly, and that root privileges are required. This is valuable behavioral context beyond the input schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two short, direct sentences. The first sentence states the primary action, and the second adds important context. It is concise without unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and 0% parameter coverage, the description provides essential context about manual execution and root privileges. However, it lacks details about the output (e.g., what the instructions look like) and does not fully compensate for missing parameter descriptions. An output schema exists but its content is unknown.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the description does not explain the parameters 'ownername' and 'projectname'. It only implies they identify the repository, but provides no details on format, source, or validation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'Provide instructions for enabling a Copr repository', specifying the verb 'enable' and resource 'Copr repository'. It is distinct from sibling tools like 'copr_submit_build' or 'copr_create_project', but does not explicitly differentiate itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions that the tool 'requires root privileges and must be run manually by the user', providing usage context about manual execution and permission requirements. However, it does not specify when not to use it or suggest alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch and return the text content of any Copr build log URL.
| Name | Required | Description | Default |
|---|---|---|---|
| log_url | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full behavioral disclosure. It only states a fetch operation, lacking details on permissions, errors, or side effects (e.g., read-only nature).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, achieving conciseness, but it omits critical information such as parameter format or return structure, making it less effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 required param, output schema present), the description partially covers purpose but lacks details on error handling, usage context with siblings, and output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage for the single parameter 'log_url', and the description does not explain what constitutes a valid URL or add any semantic context beyond the schema type.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (fetch and return) and the resource (Copr build log URL), and it distinguishes itself from the sibling tool 'copr_get_build_log_url' which retrieves the URL itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, such as prerequisites or the relationship with sibling tools like 'copr_get_build_log_url'. The agent must infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns all log URLs for a Copr build, covering the SRPM builds, the dist-git import, and each per-chroot build.
| Name | Required | Description | Default |
|---|---|---|---|
| build_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the return type (URLs) and coverage. It does not disclose error behavior, authentication needs, or side effects, leaving behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that efficiently conveys the tool's purpose and scope, with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and an output schema, the description adequately covers what the tool returns. Minor gaps exist (e.g., no mention of edge cases), but overall it is complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, yet the description adds no information about the build_id parameter, such as its source or format. The parameter is simple but entirely undocumented beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns all log URLs for a Copr build, specifying coverage of SRPM builds, dist-git import, and per-chroot builds, distinguishing it from copr_get_build_log which likely returns log content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied: use this tool to get log URLs rather than log content. However, no explicit comparison with sibling tools like copr_get_build_log is provided, leaving ambiguity for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the status of all builds in a Copr project identified by its ownername/projectname.
| Name | Required | Description | Default |
|---|---|---|---|
| ownername | Yes | ||
| projectname | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description only implies a read operation, missing details on pagination, authentication, or side effects. Output schema exists but is not referenced.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, clear sentence with no filler; front-loads the action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequately describes the core function but lacks usage context and parameter details; output schema partially compensates but the description is still thin.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description merely says 'identified by its ownername/projectname', adding minimal context about the parameters' role.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves the status of all builds in a Copr project, differentiated from sibling 'copr_build_status' which likely gets a single build.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives like copr_build_status, nor any prerequisites or exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a list of all mock chroots that you can create or use in copr. The response copr will give may vary over time, i.e. when a new Fedora or RHEL version is released.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the transparency burden. It discloses that the response may vary over time (e.g., new Fedora/RHEL releases), which is valuable behavioral context. It does not mention idempotency or safety, but the action is inherently read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences efficiently convey purpose and a key behavioral note. No superfluous words, and the critical information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and the presence of an output schema, the description fully covers the tool's behavior, including the notable variability of the response. No gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is 100%. According to rules, baseline is 4, and the description adds no parameter information since none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Get' and resource 'list of all mock chroots', clearly differentiating from the sibling tool 'copr_list_mock_chroots_for_project' which is project-specific. The purpose is unambiguous and well-defined.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for listing all available chroots, but does not explicitly mention when to avoid this tool in favor of 'copr_list_mock_chroots_for_project'. However, the context is clear and no misleading guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a list of all mock chroots that are configured for a given copr project or nothing if the project could not be found. The response may vary over time, depending on if chroots where added or removed from the copr project.
| Name | Required | Description | Default |
|---|---|---|---|
| ownername | Yes | ||
| projectname | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the burden. It discloses the read-only nature (list), that the response may vary over time as chroots are added/removed, and what happens if the project is not found. This is good behavioral context for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose, with no wasted words. It efficiently conveys the core function and a behavioral note.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given simple parameters and an existing output schema, the description is nearly complete. It covers the main function, variability, and error case. Minor gaps like authentication or response shape are addressed by output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'given copr project' linking to ownername and projectname, but adds no format, examples, or further semantics. The parameter names are self-explanatory but the description adds minimal value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (get a list) and the resource (mock chroots configured for a given copr project). It distinguishes from sibling tool copr_list_mock_chroots by specifying 'for a given copr project' and notes the case of missing project. This specificity meets top criteria.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for a specific project but provides no explicit guidance on when to use this vs alternatives, no prerequisites, and no exclusions. While the purpose is clear, the lack of comparative context limits utility for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Submit a new build into a Copr project defined by its ownername and projectname. Copr supports multiple source types, see the documentation https://docs.copr.fedorainfracloud.org/user_documentation.html#build-source-types
| Name | Required | Description | Default |
|---|---|---|---|
| ownername | Yes | ||
| projectname | Yes | ||
| source | Yes |
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| web_url | Yes | |
| state | Yes | |
| submitter | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description mentions only submission action without disclosing behavioral traits (e.g., idempotency, side effects, success/failure indicators). It does not compensate for missing annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is very concise (two sentences), but could be better structured by including a brief line about source types. It uses a link for details, which is acceptable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (discriminator, multiple source types) and the presence of an output schema, the description is too sparse. It does not explain what the tool returns or how to interpret results, and leaves critical source selection to an external link.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%; the description mentions ownername and projectname but does not explain their purpose or format. The complex 'source' parameter with discriminator is omitted entirely, relying on external docs. The sub-schemas have descriptions, but the tool description adds no value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Submit a new build') and the resource ('Copr project'), and identifies key parameters (ownername, projectname). However, it does not explicitly differentiate from sibling tools like copr_list_builds or copr_build_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, nor any prerequisites or when-not-to-use conditions. The description lacks context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool targets a distinct function: authentication, project creation, build management (status, logs, list, submit), repository enabling, and mock chroot listing. The two log tools (content vs. URLs) are complementary and clearly differentiated.
All tools follow a consistent 'copr_verb_noun' pattern with lowercase and underscores, e.g., copr_create_project, copr_list_builds, copr_submit_build. No deviations or mixed conventions.
With 10 tools, the server covers the core tasks of a build system without being excessive or sparse. Each tool serves a clear purpose within the Copr domain.
The tool set covers the main workflow: authentication, project creation, build submission, status checking, log retrieval, and repository enabling. Missing operations like project update/delete or build cancellation are minor gaps, but the core functionality is present.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Provides capabilities that let LLM agents perform a range of infrastructure management tasks.
Manage projects, tasks, time tracking, and team collaboration through natural language.
Manage Superlist tasks and lists in plain language from any MCP-compatible AI agent.
Inspect and control your Northflank projects, services, jobs, and builds from your AI assistant.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/fedora-copr/copr-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
