I want to build an MCP server using Node.js that can access my Azure DevOps boards and pipelines. The goal is to integrate it with GitHub Copilot chat (Agent Mode) so that when I prompt something like “Get details of a work item,” Copilot will automatically fetch and respond with the relevant work item details.

Building an MCP Server for Azure DevOps Integration with GitHub Copilot

Overview

Building an MCP (Model Context Protocol) server for Azure DevOps integration with GitHub Copilot Agent Mode enables seamless interaction with your Azure DevOps boards and pipelines directly through natural language prompts. This integration allows Copilot to automatically fetch work item details, create new work items, manage build pipelines, and more, all through conversational commands.

Prerequisites and Setup

Required Dependencies

To build your MCP server, you'll need to install the following packages[1][2]:

npm install @modelcontextprotocol/sdk azure-devops-node-api zod

The key dependencies are:

@modelcontextprotocol/sdk: The official MCP SDK for Node.js[1]
azure-devops-node-api: Microsoft's official Node.js client for Azure DevOps[2][3]
zod: For input validation and schema definition[1]

Azure DevOps Authentication

You'll need to create a Personal Access Token (PAT) for authentication[4][5]:

Navigate to your Azure DevOps organization
Go to User Settings → Personal access tokens[4]
Click New Token
Set appropriate scopes:
- Work Items: Read & Write (for accessing and modifying work items)[6]
- Build: Read & Execute (for pipeline operations)[5]
- Project and Team: Read[6]

Project Structure

Create the following project structure for your MCP server:

azure-devops-mcp-server/
├── package.json
├── index.js
├── mcp.json
└── setup-env.sh

Package Configuration

Your package.json should include the MCP SDK and Azure DevOps client[1][2]:

{
  "name": "azure-devops-mcp-server",
  "version": "1.0.0",
  "type": "module",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.11.0",
    "azure-devops-node-api": "^15.1.0",
    "zod": "^3.24.4"
  }
}

Core MCP Server Implementation

Server Initialization

The MCP server uses the official SDK to create a standardized interface[1][7]:

import { McpServer } from '@modelcontextprotocol/sdk/mcp/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/mcp/server/stdio.js';
import * as azdev from 'azure-devops-node-api';

// Initialize Azure DevOps connection
const authHandler = azdev.getPersonalAccessTokenHandler(process.env.AZURE_DEVOPS_PAT);
const connection = new azdev.WebApi(process.env.AZURE_DEVOPS_ORG_URL, authHandler);

// Initialize MCP server
const server = new McpServer({
    name: 'azure-devops-mcp-server',
    version: '1.0.0',
    description: 'MCP Server for Azure DevOps Boards and Pipelines',
});

Essential Tools Implementation

Work Item Management

Get Work Item Details[8][9]:

server.registerTool({
    name: 'get_work_item',
    description: 'Retrieve details of a specific work item by ID',
    inputSchema: z.object({ id: z.number().int().positive() }),
    handler: async (args) => {
        const witApi = await connection.getWorkItemTrackingApi();
        const workItem = await witApi.getWorkItem(args.id, PROJECT);
        
        return {
            success: true,
            data: {
                id: workItem.id,
                title: workItem.fields?.['System.Title'],
                state: workItem.fields?.['System.State'],
                assignedTo: workItem.fields?.['System.AssignedTo']?.displayName,
                url: workItem._links?.html?.href
            }
        };
    }
});

Create Work Items[10][11]:

server.registerTool({
    name: 'create_work_item',
    description: 'Create a new work item in Azure DevOps',
    inputSchema: z.object({
        title: z.string().min(1),
        workItemType: z.string().default('Task'),
        description: z.string().optional()
    }),
    handler: async (args) => {
        const witApi = await connection.getWorkItemTrackingApi();
        const patchDocument = [
            {
                op: 'add',
                path: '/fields/System.Title',
                value: args.title
            }
        ];
        
        const workItem = await witApi.createWorkItem(
            null, 
            patchDocument, 
            PROJECT, 
            args.workItemType
        );
        
        return { success: true, data: workItem };
    }
});

Pipeline Management

List Build Definitions[12]:

server.registerTool({
    name: 'get_build_definitions',
    description: 'List all build definitions (pipelines) in the project',
    handler: async () => {
        const buildApi = await connection.getBuildApi();
        const definitions = await buildApi.getDefinitions(PROJECT);
        
        return {
            success: true,
            data: definitions.map(def => ({
                id: def.id,
                name: def.name,
                queueStatus: def.queueStatus,
                url: def._links?.web?.href
            }))
        };
    }
});

Queue Build[13]:

server.registerTool({
    name: 'queue_build',
    description: 'Queue a new build for a specific build definition',
    inputSchema: z.object({ definitionId: z.number().int().positive() }),
    handler: async (args) => {
        const buildApi = await connection.getBuildApi();
        const build = { definition: { id: args.definitionId } };
        const queuedBuild = await buildApi.queueBuild(build, PROJECT);
        
        return {
            success: true,
            data: {
                id: queuedBuild.id,
                buildNumber: queuedBuild.buildNumber,
                status: queuedBuild.status
            }
        };
    }
});

GitHub Copilot Integration

VS Code Configuration

Create a .vscode/mcp.json file in your workspace or configure globally[14][15]:

{
  "mcpServers": {
    "azure-devops": {
      "command": "node",
      "args": ["./index.js"],
      "env": {
        "AZURE_DEVOPS_ORG_URL": "https://dev.azure.com/yourorg",
        "AZURE_DEVOPS_PAT": "your-personal-access-token",
        "AZURE_DEVOPS_PROJECT": "your-project-name"
      }
    }
  }
}

Agent Mode Usage

Once configured, you can use GitHub Copilot in Agent Mode with natural language prompts[16][17]:

"Get details of work item 1234" - Retrieves specific work item information
"Create a new task called 'Implement user authentication'" - Creates a new work item
"Show me all build definitions" - Lists available pipelines
"Queue a build for definition ID 15" - Triggers a pipeline execution
"Get the recent builds" - Shows latest build history

Security and Best Practices

Environment Variables: Store sensitive information like PATs in environment variables, never in code[5][18]
Scope Limitation: Grant minimal required permissions to your PAT[6]
Token Rotation: Regularly rotate your Personal Access Tokens[5]
Error Handling: Implement comprehensive error handling for API calls[19]

Advanced Features

Batch Operations

For handling multiple work items efficiently, use the batch API[9]:

server.registerTool({
    name: 'get_work_items_batch',
    description: 'Get multiple work items by IDs',
    inputSchema: z.object({ ids: z.array(z.number()) }),
    handler: async (args) => {
        const witApi = await connection.getWorkItemTrackingApi();
        const workItems = await witApi.getWorkItemsBatch({
            ids: args.ids,
            fields: ['System.Title', 'System.State', 'System.AssignedTo']
        });
        return { success: true, data: workItems };
    }
});

Board Integration

Access Azure DevOps boards for Kanban-style workflows[20]:

server.registerTool({
    name: 'get_boards',
    description: 'List all boards in the project',
    handler: async () => {
        const workApi = await connection.getWorkApi();
        const boards = await workApi.getBoards(PROJECT, TEAM);
        return { success: true, data: boards };
    }
});

Testing and Deployment

Local Testing

Set up environment variables:

export AZURE_DEVOPS_ORG_URL="https://dev.azure.com/yourorg"
export AZURE_DEVOPS_PAT="your-pat-token"
export AZURE_DEVOPS_PROJECT="your-project"

Start the MCP server:

node index.js

Test in VS Code with Copilot Agent Mode enabled[21][22]

Production Considerations

Error Handling: Implement robust error handling for network issues and API limitations
Rate Limiting: Respect Azure DevOps API rate limits[23]
Logging: Add comprehensive logging for debugging and monitoring
Configuration Management: Use configuration files for different environments

The MCP server architecture provides a powerful way to extend GitHub Copilot's capabilities with Azure DevOps integration[24][25]. This setup enables developers to manage their development workflow entirely through natural language interactions, significantly improving productivity and reducing context switching between tools.

SaravananRajaraman/MCP Server.md

Select an option

No results found