# Azure MCP Server

Talk to Azure in plain English. This MCP server connects your AI assistant (Claude Code, Cursor, VS Code Copilot) directly to Azure, letting you manage infrastructure through conversation instead of clicking through the Azure Portal or memorizing CLI commands.

**25 modules. 202 tools. Every Azure service you need. Zero portal clicks.**

---

## Why This Exists

Managing Azure at scale means dozens of teams, hundreds of resource groups, and thousands of resources across multiple subscriptions. Every persona — developer, DevOps engineer, architect, FinOps analyst, IT admin, security engineer — needs Azure access, but the learning curve is steep and the portal is slow.

This MCP server eliminates that friction. Instead of:
- Clicking through 8 portal blades to create a VM
- Memorizing `az` CLI flags for AKS cluster creation
- Writing ARM/Bicep templates for one-off resources
- Manually cross-referencing pricing pages before provisioning
- Hunting through Log Analytics for why something broke

You just **ask your AI assistant** — and it does it, using your own Azure permissions, with org standards enforced automatically.

---

## What Makes This Valuable

### For Developers
- **Spin up infrastructure in seconds.** "Create a PostgreSQL server in westeurope for the payments team dev environment" — it validates naming conventions, applies required tags, checks approved SKUs, and creates the resource.
- **Debug without context switching.** "Why is my VM unreachable?" — the agent checks NSG rules, NIC config, VM status, activity logs, and metrics in one flow.
- **Get cost estimates before you provision.** Every create operation can check Azure Retail Prices first, so you know what you're committing to.

### For DevOps / Platform Engineers
- **Manage AKS clusters conversationally.** Scale node pools, rotate credentials, check cluster health — without `kubectl` or portal gymnastics.
- **Compare environments.** "Show me the differences between rg-payments-dev and rg-payments-prod" — instant resource-by-resource diff.
- **Track long-running operations.** VM creation, AKS provisioning, database migrations — all tracked in the background with status polling.

### For FinOps
- **Cost breakdowns on demand.** "What's our spend this month by resource group?" or "Which service is costing us the most?" — instant answers from Cost Management APIs.
- **Budget management.** Create and monitor budgets with alert thresholds, all through conversation.
- **Find waste.** The optimization scanner finds idle VMs, unattached disks, and oversized resources automatically.

### For Security Engineers
- **Security posture at a glance.** Secure Score, Defender recommendations, active security alerts, and policy compliance — all in one conversation.
- **Audit NSG rules.** Instantly find overly permissive rules (0.0.0.0/0 on SSH/RDP) across your entire subscription.
- **Policy compliance.** List non-compliant resources and understand what's failing and why.

### For IT Admins
- **Manage VDI environments.** Azure Virtual Desktop host pools, session hosts, drain mode, user sessions — full lifecycle management.
- **App registrations without the portal maze.** Create Entra ID app registrations, add client secrets, manage service principals — all through conversation.
- **Role assignments.** Grant and revoke access, list who has what permissions, manage managed identities.

### For Architects
- **Export existing infrastructure as templates.** Export any resource group as an ARM template for IaC adoption.
- **What-if deployment analysis.** Test what a template deployment would change before committing.
- **Architecture reviews.** The guided workflow checks tagging, redundancy, security, networking, and cost across an entire resource group.

---

## Real-Life Examples

### "I need a new dev environment for the identity team"

```
You: Create a resource group for the identity team's dev environment in westeurope

Agent: [Checks org naming conventions: must be rg-{team}-{env}-{region}]
       [Checks required tags: team, environment, cost-center]
       Creating rg-identity-dev-westeurope with tags:
         team: identity
         environment: dev
         cost-center: CC-1234
       Done. Resource group created.

You: Now add a PostgreSQL Flexible Server there, Standard_B1ms, version 16

Agent: [Validates SKU against approved list]
       [Checks naming conventions]
       Creating PostgreSQL server... This is a long-running operation.
       Server 'pg-identity-dev-westeurope' creation started. Estimated: ~5 minutes.
       Use list_active_operations to check progress.
```

### "Our staging app is returning 503 errors"

```
You: /troubleshoot — our App Service 'payments-staging' is returning 503s

Agent: Let me investigate step by step.

       1. App status: RUNNING (no obvious crash)
       2. Recent activity log: App restarted 3 times in the last hour
       3. Metrics: CPU at 95%, memory at 88% — resource exhaustion
       4. App settings: WEBSITE_NODE_DEFAULT_VERSION = 14 (outdated)
       5. No security alerts.

       Findings:
       - The app is CPU/memory constrained and restarting repeatedly
       - Node.js 14 is EOL — upgrade recommended

       Suggested fixes:
       1. Scale up the App Service Plan (currently B1 — consider S1 or P1v2)
       2. Update Node.js runtime to 18-lts or 20-lts
       3. Check for memory leaks in the application code
```

### "How much are we spending and where can we save?"

```
You: /cost-analysis for this month

Agent: [Fetches cost summary, by-resource-group, by-service breakdowns]

       Monthly spend so far: $47,230
       Top resource groups:
         rg-data-prod-westeurope:    $12,400 (26%)
         rg-payments-prod-eastus:     $8,900 (19%)
         rg-identity-staging-westeu:  $3,200 (7%)

       Top services:
         Virtual Machines:  $18,500 (39%)
         Azure Cosmos DB:   $11,200 (24%)
         AKS:                $6,800 (14%)

       Running optimization scan...
       Found 7 suggestions:
       [HIGH] NSG 'nsg-legacy' allows 0.0.0.0/0 on port 22
       [MEDIUM] VM 'vm-test-loadgen-01' deallocated for 30+ days — delete?
       [MEDIUM] 4 resources missing required tags
       [LOW] 3 unattached managed disks (12 GB total) — $2.40/month waste
```

### "Set up a new AKS cluster for the media team"

```
You: Create an AKS cluster for the media team in westeurope, 3 nodes, Standard_D4s_v5

Agent: [Validates VM SKU against approved list: Standard_D4s_v5 is approved]
       [Checks naming conventions]
       [Estimates cost: ~$438/month for 3x D4s_v5 nodes]

       Before I create this, here's the summary:
       - Name: aks-media-dev-westeurope
       - Region: westeurope
       - Nodes: 3x Standard_D4s_v5 (System pool)
       - Network: Azure CNI
       - Identity: System-assigned managed identity
       - Estimated cost: ~$438/month

       Shall I proceed?

You: Yes, go ahead

Agent: AKS cluster creation started. This takes ~8-15 minutes.
       Tracking ID: op-a1b2c3d4

You: (later) What's the status?

Agent: [Checks operation status]
       AKS cluster 'aks-media-dev-westeurope' is now running.
       FQDN: aks-media-dev-westeurope-dns-abc123.hcp.westeurope.azmk8s.io
```

### "Register a new app for the billing service"

```
You: Create an Entra ID app registration for the billing service API,
     single-tenant, and generate a client secret

Agent: [Creates app registration via Microsoft Graph]
       App created:
         Display name: billing-service-api
         App ID: 12345678-abcd-...
         Object ID: 87654321-dcba-...
         Sign-in audience: AzureADMyOrg

       [Generates client secret]
       Secret created:
         Key ID: secret-key-id-...
         Value: aBcDeFgH...xYz
         Expires: 2027-03-31

       IMPORTANT: Save this secret now — it cannot be retrieved again.

       Next steps:
       - Use create_service_principal to create the enterprise app
       - Use create_role_assignment to grant it access to Azure resources
```

### "Put session hosts in drain mode for patching"

```
You: List session hosts in the 'hp-engineering' host pool and put the first two in drain mode

Agent: [Lists session hosts]
       Session hosts in hp-engineering:
       1. sh-eng-01 — Available, 3 active sessions
       2. sh-eng-02 — Available, 1 active session
       3. sh-eng-03 — Available, 5 active sessions

       [Toggles drain mode]
       sh-eng-01 is now in drain mode (no new sessions)
       sh-eng-02 is now in drain mode (no new sessions)

       Existing sessions on these hosts will continue until users log off.
       When ready to patch, use disconnect_user_sessions to gracefully disconnect remaining users.
```

### "Review the security posture of our subscription"

```
You: /security-review

Agent: [Fetches Secure Score, recommendations, alerts, compliance]

       Secure Score: 72/100 (72%)

       Top recommendations (by severity):
       [HIGH] Enable MFA for all Azure management accounts (3 accounts without MFA)
       [HIGH] Restrict SSH access — 5 NSGs allow 0.0.0.0/0 on port 22
       [MEDIUM] Enable diagnostic logging on 12 storage accounts
       [MEDIUM] Enable Azure Defender for SQL on 3 servers

       Active alerts: 1
       - Suspicious login attempt from unusual location (medium severity)

       Policy compliance: 89% compliant
       - 23 resources non-compliant (mainly missing diagnostic settings)

       Priority actions:
       1. Restrict SSH NSG rules immediately (security risk)
       2. Enable MFA on management accounts
       3. Enable Defender for SQL (data protection)
```

---

## Quick Start

### Prerequisites

- **Node.js** 20+
- **Azure CLI** (`az`) for the default `az-cli` auth mode:
  - macOS: `brew install azure-cli` · Windows: `winget install --id Microsoft.AzureCLI` · Linux: see [Install the Azure CLI](https://aka.ms/install-az)
- An **Azure / Entra ID account** with RBAC access to the subscriptions you want to manage. Your own role assignments govern what the server can do.

```bash
# 1. Clone and build
git clone https://github.com/nickmeron/Azure-MCP-Server.git
cd Azure-MCP-Server
npm install && npm run build

# 2. Add to your MCP client config (see below) — that's it!
#    No need to run `az login` or edit config files manually.
#    The server handles authentication and setup interactively.
```

With Claude Code you can register it in one command:

```bash
claude mcp add azure -- node /full/path/to/Azure-MCP-Server/dist/index.js
```

### First Run Experience

When you first use the server, just ask your AI assistant anything about Azure. If you're not authenticated yet, the `setup` tool will:

1. **Automatically open your browser** for Azure login (via `az login`) — no credentials in chat
2. **Discover your tenants** — if you have one, it auto-selects it; if multiple, it asks you to pick
3. **Discover your subscriptions** — same: auto-select if one, ask if multiple
4. **Save everything to `config.yaml`** — next time you restart, it just works

```
You: List my Azure resource groups

Agent: No subscription configured yet. Let me run setup.
       [Calls setup tool]
       Opening browser for Azure login...
       Authenticated successfully.
       Auto-selected tenant: Contoso (abc-123-...)
       Found 3 subscriptions:
         - Contoso Production: sub-111
         - Contoso Staging: sub-222
         - Contoso Dev: sub-333
       Which subscription should I use as default?

You: Use Contoso Dev

Agent: [Calls setup with subscriptionId: "sub-333"]
       Default subscription set to: Contoso Dev (sub-333) — saved to config.yaml
       Setup complete! Now let me get those resource groups...
```

After setup, you can switch tenants anytime with `switch_tenant` or subscriptions with `set_subscription`. All changes are saved automatically.

## MCP Client Configuration

### Claude Code (`~/.claude.json` or project `.mcp.json`)

```json
{
  "mcpServers": {
    "azure": {
      "command": "node",
      "args": ["/path/to/Azure-MCP-Server/dist/index.js"]
    }
  }
}
```

### VS Code (Copilot MCP)

```json
{
  "mcp": {
    "servers": {
      "azure": {
        "command": "node",
        "args": ["/path/to/Azure-MCP-Server/dist/index.js"]
      }
    }
  }
}
```

### Cursor

```json
{
  "mcpServers": {
    "azure": {
      "command": "node",
      "args": ["/path/to/Azure-MCP-Server/dist/index.js"]
    }
  }
}
```

---

## How It Works

### Dynamic Tool Loading

With 202 tools across 25 modules, loading everything at once would eat the LLM's context window. Instead, the server uses a two-tier system:

**Tier 1 (always loaded, ~19 tools):** Core navigation and discovery — setup, auth, subscriptions, list resources, Resource Graph queries, tool discovery, LRO tracking.

**Tier 2 (loaded on demand, ~183 tools across 23 modules):** Service-specific tools that the agent loads only when needed.

The agent calls `discover_tools` to browse what's available, then `get_module_tools("compute")` to load a specific module. This keeps context usage at ~30K tokens instead of ~200K.

### Authentication — Fully Interactive

Authentication is seamless. The `setup` tool detects whether you have an active Azure session and, if not, automatically opens your browser for Azure login. No credentials ever pass through the chat — authentication happens directly between your browser and Azure's login page.

| Mode | How | Best For |
|------|-----|----------|
| `az-cli` (default) | Auto-detects `az login` session, opens browser if needed | Everyone (recommended) |
| `browser` | Opens browser for Entra ID login directly | Alternative to az-cli |
| `device-code` | Prints code for aka.ms/devicelogin | SSH/remote sessions |
| `managed-identity` | Azure-assigned identity | Container Apps deployment |
| `service-principal` | Client ID + secret | CI/CD pipelines |

Tokens are cached and encrypted via the OS keychain. After first login, you won't be prompted again for weeks. Tenant and subscription selections are saved to `config.yaml` automatically.

### RBAC — Zero Custom Authorization

We never implement our own authorization. Your Entra ID identity carries your Azure RBAC assignments. If you don't have permission, Azure returns 403 and we surface a helpful message telling you which role you need.

### Long-Running Operations

Azure operations like VM creation or AKS provisioning can take minutes. The server tracks these in the background:
1. Starts the operation, returns immediately with a tracking ID
2. Polls Azure in the background every 15 seconds
3. Agent can check status anytime via `list_active_operations` or `get_operation_status`
4. Operations can be cancelled via `cancel_operation`

### Org Knowledge & Guardrails

The server enforces your organization's standards automatically. They live in `knowledge/*.yaml` — the shipped files are examples, so edit them to match your own conventions (or point `orgKnowledge` in `config.yaml` at your own files):
- **Naming conventions:** Resource groups must match `rg-{team}-{env}-{region}`, VMs must match `vm-{team}-{purpose}-{env}-{index}`, etc.
- **Required tags:** Every resource must have `team`, `environment`, and `cost-center` tags.
- **Approved SKUs:** Only pre-approved VM sizes and storage SKUs can be used for creation.
- **Destructive operation confirmation:** Deletes, role assignments, and other dangerous operations require explicit confirmation.
- **Production protection:** Resources tagged `env=production` cannot be deleted even with confirmation.

---

## Complete Feature Reference

### Infrastructure Management

| Capability | Tools | What You Can Do |
|-----------|-------|-----------------|
| **Subscriptions & Resource Groups** | `list_subscriptions`, `list_resource_groups`, `create_resource_group`, `delete_resource_group`, `apply_tags`, `set_subscription` | Navigate your Azure estate, create resource groups with enforced naming and tagging, switch between subscriptions |
| **Generic ARM** | `arm_list_resources`, `arm_get_resource`, `arm_create_or_update_resource`, `arm_delete_resource`, `arm_invoke_action`, `query_resource_graph` | CRUD any Azure resource by ARM ID, run Resource Graph KQL queries across all subscriptions |
| **Virtual Machines** | `list_vms`, `get_vm`, `create_vm`, `start_vm`, `stop_vm`, `restart_vm`, `deallocate_vm`, `delete_vm`, `resize_vm`, `get_vm_status`, `list_vm_sizes` | Full VM lifecycle — create with SKU validation and cost estimation, power operations, resize, instance view |
| **Storage** | `list_storage_accounts`, `create_storage_account`, `get_storage_account`, `list_containers`, `create_container`, `list_blobs`, `delete_storage_account` | Storage accounts (name validation, HTTPS-only, TLS 1.2), blob containers |
| **Networking** | `list_vnets`, `get_vnet`, `create_vnet`, `list_subnets`, `create_subnet`, `list_nsgs`, `get_nsg`, `create_nsg`, `add_nsg_rule`, `list_public_ips`, `create_public_ip`, `list_nics`, `create_nic`, `list_vnet_peerings`, `create_vnet_peering`, `list_private_endpoints`, `list_private_dns_zones`, `create_private_dns_zone`, `link_private_dns_to_vnet` | VNets, subnets, NSGs with security rules, public IPs, NICs, VNet peering, private endpoints, private DNS zones with VNet linking |

### Platform Services

| Capability | Tools | What You Can Do |
|-----------|-------|-----------------|
| **Kubernetes (AKS)** | `list_aks_clusters`, `get_aks_cluster`, `create_aks_cluster`, `delete_aks_cluster`, `list_aks_nodepools`, `scale_aks_nodepool`, `get_aks_credentials` | Create clusters with networking config, scale node pools, download kubeconfig |
| **Containers (ACI/ACR)** | `list_aci_groups`, `create_aci_group`, `list_acr_registries`, `create_acr`, `list_acr_repositories` | Run containers on ACI, manage container registries, list image repositories |
| **App Service** | `list_app_services`, `get_app_service`, `create_web_app`, `create_function_app`, `restart_app`, `stop_app`, `start_app`, `delete_app`, `get_app_settings`, `update_app_settings`, `list_deployment_slots`, `swap_slots` | Web apps, function apps, power operations, app settings management (sensitive values masked), deployment slot swaps |
| **Databases** | `list_sql_servers`, `get_sql_server`, `create_sql_server`, `list_sql_databases`, `create_sql_database`, `list_postgres_servers`, `create_postgres_server`, `list_cosmos_accounts`, `create_cosmos_account`, `list_cosmos_databases` | Azure SQL, PostgreSQL Flexible Server, Cosmos DB — full server and database lifecycle |
| **Key Vault** | `list_vaults`, `get_vault`, `create_vault`, `delete_vault`, `list_vault_secrets`, `set_vault_secret`, `list_vault_keys` | Vault management, secret CRUD (values shown only on create), key listing |
| **Service Bus** | `list_servicebus_namespaces`, `create_servicebus_namespace`, `list_servicebus_queues`, `create_servicebus_queue`, `list_servicebus_topics`, `create_servicebus_topic`, `list_servicebus_subscriptions`, `create_servicebus_subscription` | Messaging namespaces, queues, topics, and subscriptions |
| **API Management** | `list_apim_services`, `get_apim_service`, `list_apim_apis`, `list_apim_products`, `list_apim_subscriptions` | APIM instances, APIs, products, subscription keys |
| **CDN / Front Door** | `list_cdn_profiles`, `get_cdn_profile`, `list_cdn_endpoints`, `purge_cdn_endpoint` | CDN and Front Door profiles, endpoints, cache purging |
| **AI Services** | `list_cognitive_accounts`, `get_cognitive_account`, `create_cognitive_account`, `list_ai_deployments`, `create_ai_deployment`, `list_ai_models` | Azure OpenAI and Cognitive Services accounts, GPT/embedding model deployments |

### Identity & Security

| Capability | Tools | What You Can Do |
|-----------|-------|-----------------|
| **IAM (Role Assignments)** | `list_role_assignments`, `create_role_assignment`, `delete_role_assignment`, `list_role_definitions` | View and manage who has access to what, browse built-in and custom roles |
| **Managed Identities** | `list_managed_identities`, `create_managed_identity`, `add_federated_credential`, `list_federated_credentials`, `toggle_system_identity` | User-assigned identities, workload identity federation (GitHub Actions, AKS), enable/disable system-assigned identity on any resource |
| **App Registrations (Entra ID)** | `list_app_registrations`, `get_app_registration`, `create_app_registration`, `delete_app_registration`, `add_client_secret`, `list_service_principals`, `get_service_principal`, `create_service_principal` | Full app registration lifecycle via Microsoft Graph — create apps, generate secrets, manage service principals |
| **Entra ID (Directory & Sign-ins)** | `get_user`, `list_users`, `resolve_principal`, `list_groups`, `get_group_members`, `get_user_group_memberships`, `list_signin_logs`, `list_conditional_access_policies`, `get_conditional_access_policy` | Look up users and groups (including transitive memberships), resolve object IDs from role assignments, read sign-in logs and Conditional Access policies via Microsoft Graph |
| **Security (Defender)** | `get_secure_score`, `list_security_recommendations`, `list_security_alerts` | Defender for Cloud Secure Score, security recommendations by severity, active security alerts |
| **Policy & Compliance** | `list_policy_assignments`, `get_compliance_state`, `list_non_compliant_resources` | Azure Policy assignments, compliance summaries, non-compliant resource details |

### Observability & FinOps

| Capability | Tools | What You Can Do |
|-----------|-------|-----------------|
| **Monitoring** | `query_log_analytics`, `list_log_analytics_workspaces`, `list_app_insights`, `get_app_insights`, `query_app_insights`, `list_metric_definitions`, `get_metrics`, `list_metric_alerts`, `list_log_alerts`, `list_alerts`, `get_diagnostic_settings`, `list_action_groups`, `list_activity_log` | Run KQL against Log Analytics and Application Insights, discover and query resource metrics, list metric/log alert rules and action groups, inspect diagnostic settings, view who-did-what in activity logs |
| **Cost Management** | `get_cost_summary`, `get_cost_by_resource_group`, `get_cost_by_service`, `list_budgets`, `create_budget` | Cost breakdowns by resource group and service, budget creation with email alert thresholds |
| **Pricing & Research** | `get_azure_pricing`, `estimate_vm_cost`, `get_azure_service_limits`, `research_azure_topic` | Look up retail prices for any Azure service/SKU/region, estimate VM monthly costs, check quota usage, find Microsoft Learn guidance on any Azure topic |

### VDI & Specialized Services

| Capability | Tools | What You Can Do |
|-----------|-------|-----------------|
| **Azure Virtual Desktop** | `list_host_pools`, `get_host_pool`, `create_host_pool`, `delete_host_pool`, `list_session_hosts`, `get_session_host`, `toggle_drain_mode`, `disconnect_user_sessions`, `list_app_groups`, `create_app_group`, `list_avd_workspaces`, `create_avd_workspace`, `get_registration_token` | Full AVD lifecycle — host pools (personal/pooled), session host management with drain mode, app groups (Desktop/RemoteApp), workspaces, registration tokens for joining new hosts |
| **Backup & Recovery** | `list_recovery_vaults`, `get_recovery_vault`, `create_recovery_vault`, `list_backup_items`, `list_recovery_points` | Recovery Services vaults, protected items inventory, recovery point browsing |
| **Automation** | `list_automation_accounts`, `list_runbooks`, `start_runbook`, `list_automation_jobs`, `get_job_output` | Automation accounts, runbook execution with parameters, job status and output |

### Advanced Capabilities

| Capability | Tools | What You Can Do |
|-----------|-------|-----------------|
| **Template Export** | `export_resource_template` | Export any resource group as an ARM template for IaC adoption |
| **What-If Analysis** | `what_if_deployment` | Preview what an ARM template deployment would create, modify, or delete — without actually deploying |
| **Environment Comparison** | `compare_environments` | Side-by-side diff of two resource groups — find resource type mismatches, missing resources, configuration drift between dev/staging/prod |
| **Optimization Scanner** | `get_optimization_suggestions` | Automated scan for idle VMs, unattached disks, overly permissive NSG rules, missing required tags |
| **Org Standards** | `get_org_standards` | Query your org's naming conventions, approved SKUs, and required tags (from `knowledge/*.yaml`) |

### Guided Workflows (MCP Prompts)

| Prompt | What It Does |
|--------|-------------|
| `deploy-resource` | Step-by-step guided deployment: checks org standards, estimates costs, validates SKUs, creates the resource, verifies success |
| `troubleshoot` | Systematic debugging: checks resource status, activity logs, metrics, NSGs, security alerts, then suggests fixes |
| `cost-analysis` | FinOps deep-dive: total spend, breakdown by resource group and service, budget status, optimization opportunities |
| `security-review` | Security posture review: Secure Score, Defender recommendations, active alerts, policy compliance, non-compliant resources |
| `diagnose-access-blocked` | Diagnose AADSTS sign-in errors (e.g. Conditional Access blocks, MFA required): checks the user, sign-in logs, CA policies, group memberships, and role assignments, then pinpoints the fix |
| `architecture-review` | Well-Architected Framework assessment: tags, redundancy, security config, networking, backup, cost efficiency |

---

## Configuration

Edit `config.yaml` in the project root:

```yaml
server:
  transport: stdio        # stdio (local) or http (shared server)
  logLevel: info

auth:
  mode: az-cli            # browser | az-cli | device-code | managed-identity | service-principal
  tenantId: "your-tenant-id"

azure:
  defaultSubscriptionId: "your-sub-id"
  allowedSubscriptionIds: []      # empty = all subscriptions the user has access to
  blockedResourceGroups:          # prevent accidental ops on shared infra
    - "rg-production-core"
    - "rg-networking-hub"

modules:
  enabled: []                     # empty = all modules available
  disabled: []                    # explicitly disable specific modules

guardrails:
  requireConfirmationFor:
    - "delete_*"
    - "arm_delete_resource"
    - "create_role_assignment"
  blockDestructiveOnProduction: true
  maxResultsDefault: 50

orgKnowledge:
  namingConventions: "./knowledge/naming-conventions.yaml"
  approvedSkus: "./knowledge/approved-skus.yaml"
  requiredTags: "./knowledge/required-tags.yaml"

audit:
  enabled: true
  destination: console            # console | file | both
```

Environment variables override config.yaml: `AZURE_TENANT_ID`, `AZURE_SUBSCRIPTION_ID`, `AUTH_MODE`, `TRANSPORT`, `LOG_LEVEL`. See [`.env.example`](.env.example) for the full list.

> `setup`, `switch_tenant`, and `set_subscription` write your tenant and subscription IDs into `config.yaml`. If you fork this repo, avoid committing those local values.

## MCP Resources (Read-Only Data)

| URI | Description |
|-----|-------------|
| `azure-mcp://org-standards` | Org naming conventions, approved SKUs, required tags |
| `azure-mcp://server-config` | Current server configuration (non-sensitive) |
| `azure-mcp://module-catalog` | Full module and tool catalog with load status |

## Development

```bash
npm run build      # Compile TypeScript
npm run dev        # Watch mode
npm test           # Run tests
npm run typecheck  # Type check without building
```

See [docs/ADDING_MODULES.md](docs/ADDING_MODULES.md) for how to add new Azure service modules.

## Security Model

- **Authentication:** All auth via `@azure/identity` credential chain — no hardcoded credentials anywhere. Tokens cached and encrypted via OS keychain.
- **Authorization:** Azure RBAC enforced natively. We never implement custom authorization. If you don't have permission, Azure returns 403 and we tell you which role you need.
- **Audit logging:** Every tool invocation logged with timestamp, tool name, parameters (secrets masked), subscription ID, duration, and status. Sensitive fields (`password`, `secret`, `key`, `connectionString`, `token`) are automatically redacted.
- **Guardrails:** Destructive operations require explicit confirmation. Production resource groups (tagged `env=production`) are protected from deletion. Subscription allowlisting prevents cross-tenant accidents.
- **Org standards enforcement:** Naming conventions, required tags, and approved SKUs are validated on every create operation. Non-compliant requests are rejected with clear guidance.

## License

[MIT](LICENSE)