Skip to main content
Glama
ParasSolanki

Jira MCP Server

by ParasSolanki

create_issue

Create Jira issues by specifying project, summary, and description to track tasks, bugs, or features in your workflow.

Instructions

Create an issue in Jira

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
projectKeyOrIdYesThe key or ID of the project
summaryYesThe summary of the issue
descriptionYesThe description of the issue

Implementation Reference

  • Core handler function for the 'create_issue' tool. Constructs a Jira issue payload with project, task type, summary, and description, then POSTs it to the Jira REST API endpoint `/rest/api/2/issue` using the `$jiraJson` utility.
    export async function createIssue(input: CreateIssueInput) {
      const url = new URL(`/rest/api/2/issue`, env.JIRA_BASE_URL);
    
      const payload = {
        fields: {
          project: { key: input.projectKeyOrId },
          issuetype: { name: ISSUE_TYPES.TASK },
          summary: input.summary,
          description: input.description,
        },
      };
    
      const json = await $jiraJson(url.toString(), {
        method: "POST",
        body: JSON.stringify(payload),
      });
    
      if (json.isErr()) return err(json.error);
    
      return ok(json.value);
    }
  • Zod input schema for validating the parameters of the 'create_issue' tool: projectKeyOrId, summary, and description.
    export const createIssueInputSchema = z.object({
      projectKeyOrId: z.string().describe("The key or ID of the project"),
      summary: z.string().describe("The summary of the issue"),
      description: z.string().describe("The description of the issue"),
    });
  • Tool registration object defining the name, description, and input schema for 'create_issue', exported for use in the main app.
    export const CREATE_ISSUE_TOOL: Tool = {
      name: "create_issue",
      description: "Create an issue in Jira",
      inputSchema: zodToJsonSchema(createIssueInputSchema) as Tool["inputSchema"],
    };
  • src/app.ts:39-48 (registration)
    Central tools array registration that includes CREATE_ISSUE_TOOL among other tools, used by the MCP server's ListToolsRequestHandler.
    export const tools = [
      // list
      LIST_PROJECTS_TOOL,
      LIST_BOARDS_TOOL,
      LIST_SPRINTS_FROM_BOARD_TOOL,
      LIST_ISSUES_FROM_SPRINT_TOOL,
    
      // create
      CREATE_ISSUE_TOOL,
    ] satisfies Tool[];
  • Dispatch logic in the main CallToolRequestHandler that validates input using the schema and invokes the createIssue handler for the 'create_issue' tool.
    if (name === CREATE_ISSUE_TOOL.name) {
      const input = createIssueInputSchema.safeParse(args);
    
      if (!input.success) {
        return {
          isError: true,
          content: [{ type: "text", text: "Invalid input" }],
        };
      }
    
      const result = await createIssue(input.data);
    
      if (result.isErr()) {
        console.error(result.error.message);
        return {
          isError: true,
          content: [{ type: "text", text: "An error occurred" }],
        };
      }
    
      return {
        content: [
          { type: "text", text: JSON.stringify(result.value, null, 2) },
        ],
      };
    }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create' which implies a write operation, but doesn't cover important aspects like authentication requirements, error handling, whether the operation is idempotent, or what happens on success/failure.

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 a single, clear sentence with zero wasted words. It's perfectly front-loaded with the essential information and couldn't be more concise while still conveying the core purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a creation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation, what the response looks like, error conditions, or any behavioral nuances. The 100% schema coverage helps with parameters but doesn't compensate for the lack of operational context.

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 schema description coverage is 100%, so all parameters are documented in the schema itself. The description doesn't add any additional parameter context beyond what's already in the schema, which meets the baseline expectation when schema coverage is complete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create') and resource ('an issue in Jira'), making the tool's purpose immediately understandable. However, it doesn't differentiate from potential siblings like 'update_issue' or 'create_subtask' which aren't in the provided list, so it misses full sibling distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like needing a valid project key, nor does it differentiate from related operations like updating issues or creating tasks in other systems.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

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/ParasSolanki/jira-mcp-server'

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