# How to Use Azure DevOps MCP Server with GitHub Copilot in VS Code: Complete Setup Guide

Ever find yourself juggling VS Code and Azure DevOps browser tabs all day? I know the feeling—every time I switch contexts, I lose my flow. 😩 But guess what: Microsoft just dropped an official Model Context Protocol (MCP) server that plugs Azure DevOps right into GitHub Copilot. Game‑changer, right? 🎉

In this post, I’ll show you how to set up and use the Azure DevOps MCP server with GitHub Copilot in VS Code. You’ll be able to see work items, update tasks, query project info, and more—all without leaving your editor. Let’s dive in!

## What You'll Need (Prerequisites)

Before we dive in, make sure you have:

* VS Code or VS Code Insiders installed
    
* GitHub Copilot extension is active
    
* Node.js 20 or higher
    
* An Azure DevOps account with appropriate permissions
    
* Azure CLI installed
    

## Step 1: Authenticate with Azure

First, you need to authenticate with Azure DevOps through the Azure CLI (If not installed, [follow the docs](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest)):

```bash
az login
```

This will open your browser and prompt you to sign in to your Azure account. Ensure you use the same account with access to your Azure DevOps organization.

## Step 2: Create the MCP Configuration

In your project root directory, create a `.vscode/mcp.json` file with the following configuration:

```json
{
  "inputs": [
    {
      "id": "ado_org",
      "type": "promptString", 
      "description": "Azure DevOps organization name (e.g. 'contoso')"
    }
  ],
  "servers": {
    "ado": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@azure-devops/mcp",
        "${input:ado_org}"
      ]
    }
  }
}
```

This configuration tells VS Code how to connect to the Azure DevOps MCP server using your organization name.

## Step 3: Start the MCP Server

1. Save the `mcp.json` configuration file
    
2. Open the Command Palette in VS Code (`Ctrl+Shift+P` or `Cmd+Shift+P`)
    
3. Run the MCP server startup command
    
4. When prompted, enter your Azure DevOps organization name (just the name, not the full URL)
    

## Step 4: Enable GitHub Copilot Agent Mode

1. Open GitHub Copilot in VS Code
    
2. Switch to Agent Mode
    
3. Look for Azure DevOps tools in the available tools list
    
4. Select the Azure DevOps MCP server tools
    

That's it! You're now ready to interact with Azure DevOps directly through GitHub Copilot.

## How to Use Azure DevOps MCP with GitHub Copilot

### Managing Work Items

**View your assigned work items:**

This will give you a list of all the assigned work items with your name.

```plaintext
Show me my assigned work items in Azure DevOps
```

But you can make it more advanced or specific:

```plaintext
Show me my assigned work items in Azure DevOps with the title's based on priority
```

**Create new work items:**

Adding new work items has never been easier! Just use a prompt like this, and it will create it for you.

```plaintext
Create a new user story titled "Implement user authentication" with description "As a user, I want to log in securely so that I can access my account"
```

Or if you want to create a task that belongs to a work item:

```plaintext
Create a set of tasks for work item 875342.
- Implement new auth method
- Update exisiting unit tests
- Create new unit tests
```

**Update work item status:**

Updating existing is also very handy! This saves us so much context switching!

```plaintext
Update work item 12345 to "In Progress" and add a comment that I've started working on it
```

### Project and Repository Operations

**List your projects:**

If you have multiple projects you work on, you can list them easily.

```plaintext
List my Azure DevOps projects and show me the teams for my main project
```

**Repository information:**

```plaintext
Show me the repositories in this project and list the recent branches
```

**Pull request management:**

You are not just tied to one thing per prompt. Just combine multiple requests to do it.

```plaintext
I just created a PR for my authentication feature. Update work item 12345 to reference this PR and change the status to Code Review
```

### Build and Test Management

**Check build status:**

```plaintext
Show me the status of recent builds for this project
```

**Test plan information:**

```plaintext
List test plans for this project and show me recent test results
```

---

## Why Azure DevOps MCP in GitHub Copilot is So Powerful

### 1\. No More Context Switching 💪

The biggest productivity killer in development is context switching. Research shows it takes an average of 23 minutes to fully refocus after an interruption. With Azure DevOps MCP, you can:

* Check work item details without opening a browser
    
* Update task status while reviewing code
    
* Create follow-up tasks immediately after solving bugs
    
* Query project information within your coding context
    

### 2\. Natural Conversation with Your Project Data 💬

Instead of clicking through Azure DevOps UI menus, you can have natural conversations:

```plaintext
Show me work items in the current iteration for the Development Team, then create a new task for implementing API authentication
```

This conversational approach makes project management feel less like administrative overhead and more like a natural part of development.

### 3\. Intelligent Task Updates After Development 🤖

After you create a pull request, you can immediately:

* Link the PR to the relevant work item
    
* Update the work item status to "Code Review"
    
* Add implementation details as comments
    
* Create follow-up tasks for testing or documentation
    

All without leaving VS Code.

### 4\. Rich Context Understanding 🧠

GitHub Copilot with MCP access understands the relationship between your code and Azure DevOps work items. It can:

* Help create better commit messages based on work item descriptions
    
* Suggest relevant test cases from the user story acceptance criteria
    
* Help decompose large user stories into smaller, manageable tasks
    
* Provide context about requirements when you're coding
    

---

## Real-World Example: Complete Development Workflow

Here's how a typical development session looks like that I have with Azure DevOps MCP:

1. **Start the day:**
    
    ```plaintext
    Show me my assigned work items for this sprint
    ```
    
2. **Begin working on a task:**
    
    ```plaintext
    Update work item 12345 to "In Progress" and add a comment that I'm starting the implementation
    ```
    
3. **Need clarification on requirements:**
    
    ```plaintext
    Show me the full description and acceptance criteria for work item 12345
    ```
    
4. **After creating a PR:**
    
    ```plaintext
    Update work item 12345 to reference PR #67 and change status to "Code Review"
    ```
    
5. **Create follow-up tasks:**
    
    ```plaintext
    Create a new task for writing documentation for the authentication feature, link it to user story 12345
    ```
    

All of this happens without ever opening a browser tab or losing focus from your code.

---

## Troubleshooting Common Issues

**MCP Server Not Starting:**

* Ensure you're authenticated with Azure CLI (`az login`)
    
* Check that your Azure DevOps organization name is correct
    
* Verify Node.js 20+ is installed
    

**Permission Issues:**

* Make sure your Azure account has appropriate permissions in Azure DevOps
    
* Check that you're a member of the project you're trying to access
    
* If it says you don’t have sufficient authorization, but you know you have. Visit Azure DevOps in the browser, sometimes this will fix it for me.
    

**Connection Problems:**

* Restart VS Code after configuration changes
    
* Verify the MCP configuration file syntax is correct
    
* Check your internet connection and Azure DevOps service status
    

---

## The Future of AI-Powered Development

This Azure DevOps MCP integration represents a fundamental shift in interacting with development tools. We're moving away from tool-hopping toward a unified experience where natural language becomes the interface to our entire development ecosystem.

The Model Context Protocol (MCP) is the key enabler here - it's like USB-C for AI integrations. Once a service has an MCP server, any MCP-compatible AI agent can use it without custom development work.

---

## Get Started Today

The Azure DevOps MCP server is open source and available on GitHub at: [https://github.com/microsoft/azure-devops-mcp](https://github.com/microsoft/azure-devops-mcp)

Setting up takes less than 10 minutes, but the productivity gains compound over time. You'll spend less time navigating tools and more time solving actual problems.

---

## What's Your Experience?

Have you tried integrating MCP servers into your development workflow? What other tools would you love to see with MCP support?

I'd love to hear about your experience! Connect with me on [X/Twitter](https://x.com/devbyrayray) or [LinkedIn](https://linkedin.com/raym0ns) and let's discuss how AI is transforming our development workflows.
