After my previous blog posts about AI LLM Agents and Agentic AI with CrewAI, I continued exploring ways AI agents can help solve real-world challenges. One challenge that consistently came up in my work with Azure infrastructure deployments was discovering and understanding Azure Verified Modules (AVM).
As someone who regularly works with Azure Bicep templates, I found myself constantly searching through documentation, trying to find the right AVM module for my use case, and then diving deep into GitHub repositories to understand the module parameters. While Microsoft provides excellent documentation, the process of discovery and exploration could be more streamlined, especially when working with AI assistants like GitHub Copilot or Claude.
That’s why I created the Azure Verified Modules MCP Server - a Model Context Protocol (MCP) server that enables AI agents to intelligently search, discover, and retrieve detailed information about Azure Verified Modules. In this blog post, I’ll introduce the AVM MCP Server, explain how it works, and show you how you can use it to simplify your Azure infrastructure development workflow.
The Azure Verified Modules (AVM) MCP Server is a specialized tool that connects AI agents to the Azure Verified Modules ecosystem through the Model Context Protocol (MCP). It enables AI assistants to:
For those unfamiliar with Azure Verified Modules (AVM), they are a collection of standardized, validated, and well-documented Infrastructure as Code (IaC) modules for deploying Azure resources using Bicep. These modules follow best practices and are maintained by Microsoft and the community, ensuring consistency and reliability across Azure deployments.
The Model Context Protocol (MCP) is an open protocol that standardizes how AI applications provide context to Large Language Models (LLMs). Think of it as a universal connector that allows AI assistants like Claude Desktop, GitHub Copilot, or custom AI agents to access external data sources and tools in a standardized way.
Working with Azure Verified Modules presents several challenges:
Discovery Challenge: With hundreds of AVM modules available in the Bicep Public Registry, finding the right module for your specific use case requires searching through extensive documentation. You might need a storage account module, but should you use avm/res/storage/storage-account or are there other alternatives?
Parameter Complexity: Each AVM module has numerous parameters with specific requirements, defaults, and constraints. Understanding which parameters are required, what types they accept, and how they interact with each other often requires reading through lengthy README files on GitHub.
Version Management: Keeping track of module versions and understanding what’s available across the registry can be time-consuming, especially when you want to ensure you’re using the latest stable version.
Documentation Access: While AVM documentation is comprehensive, it’s scattered across GitHub repositories. Finding usage examples, understanding resource types, and exploring parameter details requires navigating multiple pages and repositories.
The AVM MCP Server solves these challenges by:
The AVM MCP Server is built using Python and leverages the Model Context Protocol SDK. It acts as a bridge between AI assistants and two primary data sources:
Microsoft Container Registry (MCR): The server queries MCR’s catalog and tags endpoints to discover available AVM modules and their versions. All AVM modules are published to MCR with the prefix bicep/avm/, making them easy to identify and filter.
GitHub Repository: The server fetches README.md files from the bicep-registry-modules repository to extract detailed documentation, including parameter tables, resource types, and usage examples.
Here’s the workflow:
User Query → AI Assistant → MCP Server → MCR/GitHub → Structured Response → AI Assistant → User
For example, when you ask “Find storage account modules”, the server:
mcr.microsoft.com/v2/_catalog)When you request module details, the server:
The AVM MCP Server provides several powerful features that make working with Azure Verified Modules more efficient:
Intelligent Search: Supports multiple query formats and variations. Whether you search for “key vault”, “key-vault”, or “keyvault”, the server understands your intent and returns relevant results.
Direct Registry Access: Connects directly to Microsoft Container Registry for real-time module information, ensuring you always get the latest available versions.
Deep Documentation Extraction: Goes beyond basic metadata to extract complete parameter references, resource types, and usage examples with large parameter sets.
Fast Filtering: Optimized search that quickly narrows down results from thousands of repositories, providing instant feedback.
Structured Responses: Returns data in well-structured JSON format that AI assistants can easily parse and present to users in a helpful way.
Microsoft provides an official Bicep MCP Server that includes a ListAvmMetadata tool. You might wonder why I created a separate server when Microsoft already provides one. Here’s a detailed comparison:
| Feature | Microsoft Bicep MCP Server | AVM MCP Server |
|---|---|---|
| Primary Focus | Bicep language tools & Azure resource schemas | AVM module discovery & documentation |
| AVM Module Search | Lists all modules (no filtering) | Intelligent search with multiple query formats |
| Module Details | Basic metadata (name, description, versions) | Deep documentation extraction (parameters, resource types, examples) |
| Installation | Requires .NET runtime & Bicep CLI | Lightweight Python with minimal dependencies |
| Response Format | Newline-separated text summary | Structured JSON with rich metadata |
| Documentation Access | External links only | Extracted and formatted markdown from README files |
Use the Microsoft Bicep MCP Server when:
Use the AVM MCP Server when:
Use both together for a complete Bicep + AVM development experience! They complement each other perfectly - use the Bicep MCP Server for template authoring and the AVM MCP Server for module discovery and documentation.
Let me walk you through some practical scenarios where the AVM MCP Server can significantly improve your workflow.
Imagine you’re starting a new Azure project that requires a Key Vault. Instead of manually browsing through the Bicep Public Registry or searching GitHub, you can simply ask your AI assistant:
“Find all AVM modules for Key Vault”
The AVM MCP Server searches the registry and returns all relevant modules with their versions and documentation links. Your AI assistant can then present these options and help you choose the right one based on your requirements.
Once you’ve found the right module, you need to understand its parameters. Instead of navigating to GitHub and scrolling through lengthy README files, you can ask:
“Show me the parameters for the storage account AVM module”
The AVM MCP Server extracts the parameter documentation, including:
Your AI assistant can then explain these parameters in plain language, highlight the required ones, and even help you construct a proper Bicep module reference.
For DevOps teams working with CI/CD pipelines, the AVM MCP Server can be integrated into automated workflows. AI agents can:
This is similar to the Azure Subnet Copilot approach I shared in a previous blog post, where automation simplifies complex infrastructure decisions.
Let me show you how to set up and start using the AVM MCP Server.
Before you begin, make sure you have the following installed:
For Windows users, install UV using PowerShell:
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
For macOS/Linux users:
curl -LsSf https://astral.sh/uv/install.sh | sh
The AVM MCP Server offers two installation approaches:
Option 1: Direct from GitHub (Recommended)
This approach requires no local installation. Simply run:
uvx --from git+https://github.com/stefanstranger/avm-mcp-server avm-mcp-server
This method:
Option 2: Local Installation
If you prefer to run from a local clone:
# Clone the repository
git clone https://github.com/stefanstranger/avm-mcp-server
cd avm-mcp-server
# Create and activate virtual environment
uv venv
.venv\Scripts\Activate.ps1
# Install dependencies
uv pip install -e .
Then run the server:
uv run .\server.py
To use the AVM MCP Server with Claude Desktop, add the following configuration to your claude_desktop_config.json file:
Using uvx (recommended):
{
"mcpServers": {
"avm-mcp-server": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/stefanstranger/avm-mcp-server",
"avm-mcp-server"
]
}
}
}
Using local installation:
{
"mcpServers": {
"avm-mcp-server": {
"command": "uv",
"args": [
"--directory",
"c:/github/avm-mcp-server",
"run",
"server.py"
]
}
}
}
After adding the configuration, restart Claude Desktop and you’ll see the AVM MCP Server tools available in your conversations.
The AVM MCP Server provides two powerful tools that AI assistants can use:
This tool searches and lists Azure Verified Modules from the Bicep Public Registry.
Parameters:
modulename (optional): Module name to filter bySupported query formats:
"storage-account""storage account""storage""keyvault"Returns: A JSON array with module information including:
Example queries:
This tool fetches detailed information from an AVM module’s README documentation.
Parameters:
url (required): GitHub URL of the AVM module repository
https://github.com/Azure/bicep-registry-modules/tree/main/avm/res/storage/storage-accountReturns: Formatted markdown containing:
Example queries:
Here are some practical examples of how you can interact with the AVM MCP Server through an AI assistant:
Search for modules:
“Find all AVM modules for storage”
“List Azure Verified Modules for Key Vault”
“Show me networking modules”
Get module versions:
“What versions are available for the storage account module?”
“List all versions of the AVM key vault module”
Explore module details:
“Show me the parameters for bicep/avm/res/storage/storage-account”
“What resources does the virtual network module deploy?”
“Get usage examples for the key vault module”
Combined workflows:
“Find the storage account AVM module and show me its parameters”
“I need to deploy a key vault - find the module and explain its parameters”
“Search for virtual network modules and show me usage examples”
The AI assistant will use the AVM MCP Server tools to fetch the information and present it in a clear, conversational format.
The Azure Verified Modules MCP Server represents a significant step forward in simplifying Azure infrastructure development. By enabling AI assistants to intelligently discover and understand AVM modules, we can reduce the time spent searching documentation and increase the time spent building robust Azure solutions.
Whether you’re a DevOps engineer looking to streamline your Bicep development workflow, a platform engineer building infrastructure standards, or a developer new to Azure infrastructure, the AVM MCP Server can help you find and understand the right modules faster.
The server is lightweight, easy to install, and integrates seamlessly with AI assistants like Claude Desktop. It complements Microsoft’s official Bicep MCP Server by focusing specifically on module discovery and documentation extraction, providing a complete toolkit for Bicep and AVM development.
I encourage you to give it a try and see how it can enhance your Azure development experience! All the code is open source and available on GitHub. If you encounter any issues, have suggestions for improvements, or want to contribute, please visit the GitHub repository and submit an issue or pull request. Your feedback is greatly appreciated!