MCP Azure DevOps Server

Instructions

    Lists all available processes in the organization.
    
    Use this tool when you need to:
    - See what processes are available in your Azure DevOps organization
    - Find process IDs for project creation or configuration
    - Check which process is set as the default
    
    Returns:
        A formatted table of all processes with names, IDs, and 
        descriptions
    

Implementation Reference

• src/mcp_azure_devops/features/work_items/tools/process.py:175-192 (handler)

  The MCP tool handler function for 'list_processes', decorated with @mcp.tool(). It wraps the core implementation and handles exceptions.

  @mcp.tool()
  def list_processes() -> str:
      """
      Lists all available processes in the organization.
      
      Use this tool when you need to:
      - See what processes are available in your Azure DevOps organization
      - Find process IDs for project creation or configuration
      - Check which process is set as the default
      
      Returns:
          A formatted table of all processes with names, IDs, and 
          descriptions
      """
      try:
          return _list_processes_impl()
      except Exception as e:
          return f"Error: {str(e)}"

• src/mcp_azure_devops/features/work_items/tools/process.py:95-122 (helper)

  Core implementation that fetches the list of processes using the Azure DevOps client, formats them into a markdown table, and returns the result.

  def _list_processes_impl() -> str:
      """Implementation of processes list retrieval."""
      try:
          process_client = get_work_item_tracking_process_client()
          processes = process_client.get_list_of_processes()
          
          if not processes:
              return "No processes found in the organization."
          
          result = ["# Available Processes"]
          
          headers = ["Name", "ID", "Reference Name", "Description", "Is Default"]
          rows = []
          for process in processes:
              is_default = ("Yes" if getattr(process.properties, 
                                          'is_default', False) 
                            else "No")
              row = (f"| {process.name} | {process.type_id} | " +
                     f"{getattr(process, 'reference_name', 'N/A')} | " +
                     f"{getattr(process, 'description', 'N/A')} | " +
                     f"{is_default} |")
              rows.append(row)
          
          result.append(_format_table(headers, rows))
          return "\n".join(result)
      except Exception as e:
          return f"Error retrieving processes: {str(e)}"

• src/mcp_azure_devops/features/work_items/tools/__init__.py:28-28 (registration)

  The registration call for process tools within the work_items tools aggregator, which triggers the definition and registration of the list_processes tool.

  process.register_tools(mcp)

• src/mcp_azure_devops/features/work_items/tools/process.py:12-18 (helper)

  Utility function used to format the processes list as a markdown table.

  def _format_table(headers, rows):
      """Format data as a markdown table."""
      result = []
      result.append("| " + " | ".join(headers) + " |")
      result.append("| " + " | ".join(["----"] * len(headers)) + " |")
      result.extend(rows)
      return "\n".join(result)

• src/mcp_azure_devops/features/work_items/tools/process.py:124-193 (registration)

  The register_tools function that defines and registers all process-related tools, including list_processes, using @mcp.tool() decorators.

  def register_tools(mcp) -> None:
      """
      Register process tools with the MCP server.
      
      Args:
          mcp: The FastMCP server instance
      """
      
      @mcp.tool()
      def get_project_process_id(project: str) -> str:
          """
          Gets the process ID associated with a project.
          
          Use this tool when you need to:
          - Find out which process a project is using
          - Get the process ID for use in other process-related operations
          - Verify process information for a project
          
          Args:
              project: Project ID or project name
              
          Returns:
              Formatted information about the process including name and ID
          """
          try:
              return _get_project_process_id_impl(project)
          except Exception as e:
              return f"Error: {str(e)}"
      
      @mcp.tool()
      def get_process_details(process_id: str) -> str:
          """
          Gets detailed information about a specific process.
          
          Use this tool when you need to:
          - View process properties and configuration
          - Get a list of work item types defined in a process
          - Check if a process is the default for the organization
          
          Args:
              process_id: The ID of the process
              
          Returns:
              Detailed information about the process including properties and
              available work item types
          """
          try:
              return _get_process_details_impl(process_id)
          except Exception as e:
              return f"Error: {str(e)}"
      
      @mcp.tool()
      def list_processes() -> str:
          """
          Lists all available processes in the organization.
          
          Use this tool when you need to:
          - See what processes are available in your Azure DevOps organization
          - Find process IDs for project creation or configuration
          - Check which process is set as the default
          
          Returns:
              A formatted table of all processes with names, IDs, and 
              descriptions
          """
          try:
              return _list_processes_impl()
          except Exception as e:
              return f"Error: {str(e)}"