MCP JIRA Server

Instructions

Implementation Reference

• mcp_jira/server/app.py:53-124 (handler)

  The primary handler function for the 'create_jira_issue' MCP tool. It is decorated with @mcp_server.tool for registration, handles input parameters, delegates to the helper function in jira_tools, manages errors, and returns formatted MCP TextContent response.

      @mcp_server.tool(
          name="create_jira_issue",
          description="Creates a new JIRA issue from Markdown description.",
      )
      def create_jira_issue_tool(
          project: str,
          summary: str,
          description: str, # This will be Markdown input
          issue_type: str = "Task",
          site_alias: str = None,
          assignee: str = None,
          additional_fields: Dict[str, Any] = None # For future flexibility
      ) -> types.TextContent:
          """
  Instruction to LLM (for Jira ADF compatibility):
  
  When passing content that includes code, always use fenced code blocks
  formatted like this Markdown example:
  
  Example content:
  
  This is a paragraph introducing a code block.
  
  ```python
  def hello():
      print("Hello, world!")
  ```
  
  Create a JIRA issue with markdown description converted to ADF.
  """
          logger.debug(
              f"create_jira_issue_tool received: project={project}, summary={summary}, "
              f"issue_type={issue_type}, site_alias={site_alias}, assignee={assignee}, additional_fields_present={additional_fields is not None}"
          )
          try:
              # Call the business logic function directly
              result = jira_tools.create_jira_issue(
                  project=project,
                  summary=summary,
                  description=description,
                  issue_type=issue_type,
                  site_alias=site_alias,
                  assignee=assignee,
                  additional_fields=additional_fields,
                  server_config=config
              )
              
              logger.info(f"JIRA issue creation result: {result}")
              
              issue_key = result.get('key')
              issue_id = result.get('id')
              browse_url = result.get('url', "N/A")
  
              return types.TextContent(
                  type="text",
                  text=f"Successfully created JIRA issue: {issue_key} (ID: {issue_id}). URL: {browse_url}",
                  format="text/plain"
              )
          except JiraServiceError as e:
              logger.error(f"JiraServiceError in create_jira_issue_tool: {e}", exc_info=True)
              return types.TextContent(
                  type="text",
                  text=f"Error creating JIRA issue: {e}",
                  format="text/plain"
              )
          except Exception as e:
              logger.error(f"Unexpected error in create_jira_issue_tool: {e}", exc_info=True)
              return types.TextContent(
                  type="text",
                  text=f"An unexpected error occurred: {e}",
                  format="text/plain"
              )

• mcp_jira/tools/jira_tools.py:11-64 (helper)

  Helper function implementing the core logic for creating a JIRA issue. Resolves configuration, instantiates JiraClient, and invokes the create_issue method.

  def create_jira_issue(
      project: str, 
      summary: str, 
      description: str, 
      issue_type: str = "Task", 
      site_alias: Optional[str] = None,
      assignee: Optional[str] = None,
      additional_fields: Optional[Dict[str, Any]] = None,
      server_config: Optional[ServerConfig] = None
  ) -> Dict[str, Any]:
      """
      Create a JIRA issue with markdown description converted to ADF.
      
      Args:
          project: Project key (e.g., 'ABC')
          summary: Issue summary/title
          description: Issue description in markdown format
          issue_type: Type of issue (default: "Task")
          site_alias: Optional site alias for multi-site configurations
          assignee: Optional assignee email address
          additional_fields: Optional dict of additional JIRA fields
          server_config: Server configuration object
          
      Returns:
          Dict containing created issue information (id, key, url)
          
      Raises:
          JiraServiceError: If issue creation fails
      """
      try:
          # Get active JIRA site configuration
          active_site_config = get_active_jira_config(alias=site_alias, server_config=server_config)
          
          # Create JiraClient instance
          jira_client = JiraClient(site_config=active_site_config)
          
          # Create the issue
          result = jira_client.create_issue(
              project_key=project,
              summary=summary,
              description=description,  # Will be converted to ADF by JiraClient
              issue_type=issue_type,
              assignee=assignee,
              **(additional_fields or {})
          )
          
          return result
          
      except JiraServiceError:
          # Re-raise JiraServiceError as-is
          raise
      except Exception as e:
          # Wrap unexpected errors
          raise JiraServiceError(f"Unexpected error creating JIRA issue: {e}")