Microsoft's Azure MCP Server - where MCP stands for Model Context Protocol - is a new tool in public preview that bridges AI agents with Azure services. Announced in April 2025, Azure MCP Server brings the power of Azure into your development workflow by allowing AI agents (like GitHub Copilot's chat agent) to access Azure resources via natural language prompts.
In practice, this means you can ask an AI assistant in Visual Studio Code (or another client/host) to perform cloud operations (query databases, check logs, run CLI commands, etc.) without manually writing scripts or switching to the Azure Portal.
This article provides an overview of Azure MCP Server's features and use cases, a step-by-step guide to configuring it in VS Code, predictions for its future, and a look at current limitations.
If you are not familiar with MCP yet, I recommend starting with my article MCP Explained: Empower your AI.
What is the Azure MCP Server?
The Azure MCP Server is Microsoft's implementation of this protocol for Azure - essentially a local server that exposes Azure services and developer tools to any AI agent that supports MCP. By running the Azure MCP Server, an AI system can execute Azure operations on your behalf in a controlled way. Instead of writing code or running commands yourself, you give natural-language instructions and the agent (using MCP) translates them into Azure API calls or CLI commands.
Why is this important?
It enables "context-aware" AI interactions with cloud resources. For example, an agent using Azure MCP can query a Cosmos DB database using a plain English question, read or write a blob in Azure Storage, or fetch application logs from Azure Monitor - all while understanding the context of your Azure environment.
This opens up new possibilities for developers to manage and troubleshoot cloud resources conversationally. Particularly for developers building Azure-backed applications, it means common tasks (checking a database entry, reviewing config settings, deploying infrastructure) can be handled by simply asking your AI assistant, without leaving VS Code or writing a script.
Open Source and Extensibility
The Azure MCP Server is open source (available on GitHub), and any AI agent following the MCP protocol can use it. GitHub Copilot's new Agent mode is one such client, but you could also integrate it with other hosts and clients (such as Claude Desktop). In short, Azure MCP Server acts as a translator between AI and Azure - you don't program the MCP server directly; you run it and let AI-driven tools call into it.
Core Features and Supported Azure Capabilities
Azure MCP Server's core functionality is to expose a set of Azure services and developer tools that the AI can interact with. In its initial public preview (MVP) release, it supports a range of Azure resource operations and CLI commands:
- Azure Cosmos DB (NoSQL) - List Cosmos DB accounts, list/query databases, manage containers and items, and execute SQL queries on containers (this means you could ask the AI to "show documents in my Cosmos DB collection" and get results without writing a query by hand).
- Azure Storage - List Storage accounts, manage blob containers and blobs, list/query Azure Table storage, and fetch container properties/metadata. Example prompt: "List my Azure Storage accounts and containers".
- Azure Monitor (Log Analytics) - List Log Analytics workspaces and tables, run log queries using Kusto Query Language (KQL), and configure monitoring settings. This allows you to ask things like "Query my application logs for errors in the last 24 hours" and have the agent run the KQL query for you.
- Azure App Configuration - List App Config stores, manage key-value pairs (including labeled configurations), and lock or unlock settings. For instance, "What are the feature flags in my App Configuration store?"
- Azure Resource Groups - List your Azure resource groups and perform basic management operations on them (e.g. show details, possibly creation/deletion). Example: "List all resource groups in my subscription".
- Azure CLI - Execute any Azure CLI command with full functionality, returning output (in JSON) back to the AI. This essentially wraps the
az CLI tool, so the agent can perform any Azure operation that your CLI credentials allow (for example, az webapp list or az vm start). The output is formatted in a way the AI can understand and present.
- Azure Developer CLI (
azd) - Run Azure Developer CLI commands for project scaffolding and deployment, such as finding templates, initializing projects, provisioning resources, and deploying applications. This is handy for higher-level operations like "Set up an Azure Functions project in my directory" or "Deploy my app to Azure using azd".
Behind the scenes, Azure MCP Server handles the translation of natural language prompts into the appropriate Azure SDK calls or CLI commands, and returns results in a structured JSON format that the AI agent can parse. Some noteworthy aspects of its design:
- Natural language to Azure operations: you issue commands in everyday language, and Azure MCP figures out the intents (e.g. listing storage containers or querying logs) and executes them on Azure.
- Smart output formatting: results are returned as JSON or friendly text the agent can interpret. For example, if you ask for a list of VMs, it might return a JSON array of VM names and statuses that the AI can then present or summarize.
- Parameter suggestion and auto-completion: the server can assist in filling in details. If your prompt is incomplete (say "show me logs from workspace X"), the tool can prompt for missing parameters or try to infer sensible defaults.
- Consistent error handling: errors (like missing permissions or wrong resource names) are caught and returned in a consistent format, so the AI can explain what went wrong in simple terms.
The Azure MCP server, combined with AI model knowledge, RAG, and NLP, delivers an excellent user experience - often helping you achieve your desired results by providing tips or even step-by-step guidance.
In essence, the Azure MCP Server provides a toolkit of Azure-aware actions that an AI assistant can perform. For .NET developers, this means tasks that typically involve writing Azure SDK code or running CLI commands can be delegated to Copilot (or another agent) through chat prompts. Instead of coding a quick console app to query a database or using the Azure Portal UI, you can get the information or perform the action by asking your AI assistant.
3 prime scenarios
- Resource exploration - ask: "Show the items in my UserProfiles Cosmos DB container". MCP queries Cosmos DB or Storage and returns the data inline - no portal, no code.
- Troubleshooting & diagnostics - ask: "Find all exceptions in Application Insights from the last hour". MCP runs the KQL in Log Analytics and surfaces the results so you can debug inside the editor.
- Infrastructure management - ask: "Create a test-rg resource group" or "Deploy this project with azd". Copilot translates the request to Azure CLI /
azd commands and runs them, streamlining dev/test provisioning.
Key takeaways
- Prompt-driven workflow: you converse; MCP executes. No extra code required.
- Developer in control: you can explicitly tell Copilot to use MCP or let Agent mode choose the best tool.
- Shift in mindset: from manual scripts to conversational cloud ops - without leaving VS Code.
Configuring the Azure MCP Server in Visual Studio Code
Setting up the Azure MCP Server in VS Code involves installing the right extensions, authenticating Azure, and launching the MCP server so that Copilot (or another agent) can use it. Below is a detailed step-by-step guide:
Prerequisites
Before configuration, ensure you have the following in place:
- Node.js (latest LTS recommended) installed on your machine. The Azure MCP Server is distributed as an NPM package and requires Node.js to run.
- Visual Studio Code (latest stable release or Insiders) installed.
- GitHub Copilot extension and GitHub Copilot Chat extension installed in VS Code. Copilot Chat (with Agent mode) is what will interface with the MCP server. Ensure you have an active Copilot subscription or access.
- (Optional but recommended) GitHub Copilot for Azure VS Code extension. This extension isn't required for MCP, but it enriches Copilot with Azure-specific knowledge (documentation lookups, best practices, etc.), complementing the MCP server's capabilities.
- Azure CLI installed (optional). Many Azure operations can be performed via REST/SDK, but the MCP server can leverage Azure CLI commands. Having the Azure CLI (
az) installed and available in your PATH ensures full CLI functionality.
- Azure Account: you should be logged into an Azure account with sufficient permissions (at least reader access for exploration tasks, and contributor if you want to create or modify resources). You can authenticate by running
az login in a terminal (if using Azure CLI) or by using the Azure Account extension in VS Code to sign in. The Azure MCP Server will use your local credentials (for example, the credentials from Azure CLI or VS Code's login) to execute commands on your behalf. Make sure you're signed in to the correct Azure tenant/subscription before proceeding.
Installation Steps
Once the prerequisites are ready, follow these steps to set up and connect the Azure MCP Server in VS Code:
1. Open an empty workspace in VS Code
It's often best to start in a new folder or workspace when testing the MCP server, to avoid any unintended interference with your project files (you can later use it in any workspace, but for initial setup a blank workspace is fine).
2. Install Azure MCP Server integration
The easiest way to configure VS Code to use the Azure MCP Server is via the "one-click" install provided by Microsoft. Visit the Azure MCP Server GitHub repository and click the button labeled "Install Azure MCP Server". This will trigger VS Code to install/enable the MCP server for your workspace. Under the hood, this action creates a configuration file and prepares the command to launch the server.
3. Start the Azure MCP Server
If you used the one-click install, the server might start automatically. If not, or if you did the manual config, open a VS Code terminal and run the command yourself: npx -y @azure/mcp@latest server start. This will launch the Azure MCP Server process. It will by default listen on a local port (5008) and communicate with the VS Code agent via standard I/O or server-sent events. Once running, the server will register itself as an available "tool" for Copilot Agent.
4. Enable GitHub Copilot Agent Mode
Open the GitHub Copilot Chat view in VS Code. By default, Copilot might be in normal "Chat" mode (where it just answers questions). Look for a toggle or dropdown to switch to Agent mode. Agent mode allows Copilot to use tools like the MCP server to act on your behalf, rather than just providing code or answers.
If you're not sure how to enable it, refer to the official VS Code documentation on Copilot Agent mode: Agent mode: available to all users and supports MCP
5. Authenticate the MCP server (if prompted)
In many cases, if you're already logged in via Azure CLI or Azure account extension (as noted in prerequisites), the MCP server will automatically use those credentials. The first time you try to access an Azure resource through it, you might be prompted to log in or grant permission if something isn't set. Follow any prompts to authenticate.
This step will vary depending on your environment's auth setup; in an ideal case, no prompt appears because your Azure session is already active.
6. Test an Azure prompt in Copilot Chat
Now you're ready to use AI to interact with Azure. In the Copilot chat (Agent mode), type a request that involves Azure. For example, try: "List my Azure Storage containers".
This prompt explicitly asks the agent to use the Azure MCP tool to fetch your storage containers. Copilot should recognize that this task requires using the Azure MCP Server (since it's now an available tool) and execute the necessary Azure API calls via MCP. Within moments, you should see a response - the AI might list your Azure Storage accounts and their blob containers in the chat.
7. Stay in control
In Agent mode, Copilot might sometimes suggest using a tool on its own if your query implies it (thanks to MCP, it can reason "this question is about Azure, I should use the Azure tool"). You always have the option to approve or guide the actions. If a destructive action is suggested (like deleting resources), the extension will typically ask for confirmation before executing an actual az command. This allows you to experiment safely.
Current Limitations and Considerations (MVP Caveats)
- Limited service coverage - not all of the resources are wired up.
- Preview quality - expect breaking changes and rough edges; config files, commands, or JSON shapes can shift between drops.
- Stability & performance - MCP is a local Node.js process. Large log queries may lag; network hiccups can stall chat; console logs are noisy. This will improve, but don't expect portal-level polish yet.
- Auth & permissions - the server reuses whatever Azure credentials VS Code/CLI finds. It can do anything your account can - no extra sandboxing - so test in non-prod subscriptions.
- Prompt misinterpretation - LLMs can misconstrue fuzzy asks ("clean my storage" ≠ "delete everything"… or maybe it does 😁). Review Copilot's plan / confirmation screens before letting it run commands.
Azure MCP Server is a powerful preview of conversational cloud ops - great for experiments, not for mission-critical workflows yet. Treat it like a helpful assistant: impressive, but still learning.
Future Outlook: what's Next for Azure MCP Server
Microsoft has clear plans to expand its capabilities. According to the team's roadmap, developers can expect several enhancements as the product matures:
- More Azure Services Integrations: today's MCP server covers a handful of services (DB, storage, logs, etc.). In the future, expect support for a broader range of Azure services.
- Deeper Microsoft Product Integrations - beyond VS Code and Copilot, the MCP server might integrate with other Microsoft offerings. For example, we might see Azure MCP integration with Azure DevOps or GitHub Actions for CI/CD agents, or even integration into the Azure Portal or Azure CLI/Cloud Shell as an AI assistant mode. The goal is to make AI agents a natural part of the Azure ecosystem, so integrations with services like Azure AI Agent Service (which is a managed service for running agents) are likely on the horizon.
- In-Depth Samples and Documentation: Microsoft plans to provide more sample projects and tutorials demonstrating how to build agents with Azure MCP Server. This will help developers (especially those in the .NET community) understand patterns for using MCP in real scenarios. For instance, sample C# agents using the MCP .NET SDK or Semantic Kernel could be published, showing how to incorporate Azure MCP Server into custom applications.
- Improved User Experience: as the tool evolves, we anticipate a smoother setup and more features in the VS Code extension. Perhaps one-click install will be built into an extension, or Agent mode will become enabled by default for Azure scenarios. Features like more interactive prompt suggestions, or higher-level "task planning" by the AI (where it can break down complex requests into multiple Azure operations), may improve as the underlying AI models and MCP spec improve.
- Additional Features and Performance: the public preview is an early cut - performance optimizations (faster responses, caching of results where applicable) and robust error handling are areas likely to be enhanced. Security features might be added (for example, allowing developers to set policies on what the agent is allowed to do on Azure, to prevent accidents). As feedback comes in, the team will iterate with new features.
It's also worth noting that Azure MCP Server is part of a broader trend of cloud providers enabling AI agent access to their platforms. This indicates that the concept of AI-assisted development and DevOps will grow. We can expect Azure MCP Server to evolve in tandem with the MCP specification and possibly become more standardized.
In a future scenario, a .NET developer might use a single AI agent that seamlessly interacts with Azure, GitHub, databases, and other environments, thanks to a variety of MCP servers working together.
Conclusion
The Azure MCP Server represents an exciting step towards more intelligent and natural cloud development workflows. By leveraging the Model Context Protocol, it allows AI agents like GitHub Copilot to interface directly with Azure services - enabling you as a developer to query, manage, and deploy Azure resources through conversational prompts.
We've explored how the MCP server works, its current features, and how you can set it up in Visual Studio Code to start experimenting with AI-driven Azure interactions. This means your familiar Azure components (Cosmos DB, Storage, App Config, etc.) can be queried or manipulated without leaving your coding session, accelerating tasks like troubleshooting and configuration.
It's clear that this is just the beginning. Microsoft intends to deepen the integration, adding more services and refining the developer experience. We can anticipate a future where our development environments come with an AI cloud assistant by default - one that not only writes code but also understands and operates the cloud infrastructure our code runs on.
For now, the Azure MCP Server is in preview with some limitations, so approach it as a learning and productivity aid, and share your feedback with the Azure SDK team to help shape its evolution.
Start with simple, read-only queries (listing resources, fetching data) to get comfortable with how the AI responds. Experiment with more complex tasks as you gain confidence. And keep an eye on the official Azure SDK blog and GitHub repo for updates. Happy coding, and enjoy having an AI copilot for your Azure adventures!
Useful resources: