@ivannxbt/ai-config 0.1.0

package/.agents/skills/microsoft-foundry/quota/quota.md

@@ -0,0 +1,186 @@
+# Microsoft Foundry Quota Management
+
+Quota and capacity management for Microsoft Foundry. Quotas are **subscription + region** level.
+
+> ⚠️ **Important:** This is the **authoritative skill** for all Foundry quota operations. When a user asks about quota, capacity, TPM, PTU, quota errors, or deployment limits, **always invoke this skill** rather than using MCP tools (azure-quota, azure-documentation, azure-foundry) directly. This skill provides structured workflows and error handling that direct tool calls lack.
+
+> **Important:** All quota operations are **control plane (management)** operations. Use **Azure CLI commands** as the primary method. MCP tools are optional convenience wrappers around the same control plane APIs.
+
+## Quota Types
+
+| Type | Description |
+|------|-------------|
+| **TPM** | Tokens Per Minute, pay-per-token, subject to rate limits |
+| **PTU** | Provisioned Throughput Units, monthly commitment, no rate limits |
+| **Region** | Max capacity per region, shared across subscription |
+| **Slots** | 10-20 deployment slots per resource |
+
+**When to use PTU:** Consistent high-volume production workloads where monthly commitment is cost-effective.
+
+---
+
+Use this sub-skill when the user needs to:
+
+- **View quota usage** — check current TPM/PTU allocation and available capacity
+- **Check quota limits** — show quota limits for a subscription, region, or model
+- **Find optimal regions** — compare quota availability across regions for deployment
+- **Plan deployments** — verify sufficient quota before deploying models
+- **Request quota increases** — navigate quota increase process through Azure Portal
+- **Troubleshoot deployment failures** — diagnose QuotaExceeded, InsufficientQuota, DeploymentLimitReached, 429 rate limit errors
+- **Optimize allocation** — monitor and consolidate quota across deployments
+- **Monitor quota across deployments** — track capacity by model and region
+- **Explain quota concepts** — explain TPM, PTU, capacity units, regional quotas
+- **Free up quota** — identify and delete unused deployments
+
+**Key Points:**
+1. Isolated by region (East US ≠ West US)
+2. Regional capacity varies by model
+3. Multi-region enables failover and load distribution
+4. Quota requests specify target region
+
+See [detailed guide](./references/workflows.md#regional-quota).
+
+---
+
+## Core Workflows
+
+### 1. Check Regional Quota
+
+```bash
+subId=$(az account show --query id -o tsv)
+az rest --method get \
+  --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/eastus/usages?api-version=2023-05-01" \
+  --query "value[?contains(name.value,'OpenAI')].{Model:name.value, Used:currentValue, Limit:limit}" -o table
+```
+
+**Output interpretation:**
+- **Used**: Current TPM consumed (10000 = 10K TPM)
+- **Limit**: Maximum TPM quota (15000 = 15K TPM)
+- **Available**: Limit - Used (5K TPM available)
+
+Change region: `eastus`, `eastus2`, `westus`, `westus2`, `swedencentral`, `uksouth`.
+
+---
+
+### 2. Find Best Region for Deployment
+
+Check specific regions for available quota:
+
+```bash
+subId=$(az account show --query id -o tsv)
+region="eastus"
+az rest --method get \
+  --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/$region/usages?api-version=2023-05-01" \
+  --query "value[?name.value=='OpenAI.Standard.gpt-4o'].{Model:name.value, Used:currentValue, Limit:limit, Available:(limit-currentValue)}" -o table
+```
+
+See [workflows reference](./references/workflows.md#multi-region-check) for multi-region comparison.
+
+---
+
+### 3. Check Quota Before Deployment
+
+Verify available quota for your target model:
+
+```bash
+subId=$(az account show --query id -o tsv)
+region="eastus"
+model="OpenAI.Standard.gpt-4o"
+
+az rest --method get \
+  --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/$region/usages?api-version=2023-05-01" \
+  --query "value[?name.value=='$model'].{Model:name.value, Used:currentValue, Limit:limit, Available:(limit-currentValue)}" -o table
+```
+
+- **Available > 0**: Yes, you have quota
+- **Available = 0**: Delete unused deployments or try different region
+
+---
+
+### 4. Monitor Quota by Model
+
+Show quota allocation grouped by model:
+
+```bash
+subId=$(az account show --query id -o tsv)
+region="eastus"
+az rest --method get \
+  --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/$region/usages?api-version=2023-05-01" \
+  --query "value[?contains(name.value,'OpenAI')].{Model:name.value, Used:currentValue, Limit:limit, Available:(limit-currentValue)}" -o table
+```
+
+Shows aggregate usage across ALL deployments by model type.
+
+**Optional:** List individual deployments:
+```bash
+az cognitiveservices account list --query "[?kind=='AIServices'].{Name:name,RG:resourceGroup}" -o table
+
+az cognitiveservices account deployment list --name <resource> --resource-group <rg> \
+  --query "[].{Name:name,Model:properties.model.name,Capacity:sku.capacity}" -o table
+```
+
+---
+
+### 5. Delete Deployment (Free Quota)
+
+```bash
+az cognitiveservices account deployment delete --name <resource> --resource-group <rg> \
+  --deployment-name <deployment>
+```
+
+Quota freed **immediately**. Re-run Workflow #1 to verify.
+
+---
+
+### 6. Request Quota Increase
+
+**Azure Portal Process:**
+1. Navigate to [Azure Portal - All Resources](https://portal.azure.com/#view/HubsExtension/BrowseAll) → Filter "AI Services" → Click resource
+2. Select **Quotas** in left navigation
+3. Click **Request quota increase**
+4. Fill form: Model, Current Limit, Requested Limit, Region, **Business Justification**
+5. Wait for approval: **3-5 business days typically, up to 10 business days** ([source](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/quota))
+
+**Justification template:**
+```
+Production [workload type] using [model] in [region].
+Expected traffic: [X requests/day] with [Y tokens/request].
+Requires [Z TPM] capacity. Current [N TPM] insufficient.
+Request increase to [M TPM]. Deployment target: [date].
+```
+
+See [detailed quota request guide](./references/workflows.md#request-quota-increase) for complete steps.
+
+---
+
+## Quick Troubleshooting
+
+| Error | Quick Fix | Detailed Guide |
+|-------|-----------|----------------|
+| `QuotaExceeded` | Delete unused deployments or request increase | [Error Resolution](./references/error-resolution.md#quotaexceeded) |
+| `InsufficientQuota` | Reduce capacity or try different region | [Error Resolution](./references/error-resolution.md#insufficientquota) |
+| `DeploymentLimitReached` | Delete unused deployments (10-20 slot limit) | [Error Resolution](./references/error-resolution.md#deploymentlimitreached) |
+| `429 Rate Limit` | Increase TPM or migrate to PTU | [Error Resolution](./references/error-resolution.md#429-errors) |
+
+---
+
+## References
+
+**Detailed Guides:**
+- [Error Resolution Workflows](./references/error-resolution.md) - Detailed workflows for quota exhausted, 429 errors, insufficient quota, deployment limits
+- [Troubleshooting Guide](./references/troubleshooting.md) - Quick error fixes and diagnostic commands
+- [Quota Optimization Strategies](./references/optimization.md) - 5 strategies for freeing quota and reducing costs
+- [Capacity Planning Guide](./references/capacity-planning.md) - TPM vs PTU comparison, model selection, workload calculations
+- [Workflows Reference](./references/workflows.md) - Complete workflow steps and multi-region checks
+- [PTU Guide](./references/ptu-guide.md) - Provisioned throughput capacity planning
+
+**Official Microsoft Documentation:**
+- [Azure OpenAI Service Pricing](https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/) - Official pay-per-token rates
+- [PTU Costs and Billing](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/provisioned-throughput-onboarding) - PTU hourly rates
+- [Azure OpenAI Models](https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models) - Model capabilities and regions
+- [Quota Management Guide](https://learn.microsoft.com/azure/ai-services/openai/how-to/quota) - Official quota procedures
+- [Quotas and Limits](https://learn.microsoft.com/azure/ai-services/openai/quotas-limits) - Rate limits and quota details
+
+**Calculators:**
+- [Azure Pricing Calculator](https://azure.microsoft.com/pricing/calculator/) - Official pricing estimator
+- Azure AI Foundry PTU calculator (Microsoft Foundry → Operate → Quota → Provisioned Throughput Unit tab) - PTU capacity sizing

package/.agents/skills/microsoft-foundry/quota/references/capacity-planning.md

@@ -0,0 +1,124 @@
+# Capacity Planning Guide
+
+Comprehensive guide for planning Azure AI Foundry capacity, including cost analysis, model selection, and workload calculations.
+
+## Cost Comparison: TPM vs PTU
+
+> **Official Pricing Sources:**
+> - [Azure OpenAI Service Pricing](https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/) - Official pay-per-token rates
+> - [PTU Costs and Billing Guide](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/provisioned-throughput-onboarding) - PTU hourly rates and capacity planning
+
+**TPM (Standard) Pricing:**
+- Pay-per-token for input/output
+- No upfront commitment
+- **Rates**: See [Azure OpenAI Pricing](https://azure.microsoft.com/en-us/pricing/details/cognitive-services/openai-service/)
+  - GPT-4o: ~$0.0025-$0.01/1K tokens
+  - GPT-4 Turbo: ~$0.01-$0.03/1K
+  - GPT-3.5 Turbo: ~$0.0005-$0.0015/1K
+- **Best for**: Variable workloads, unpredictable traffic
+
+**PTU (Provisioned) Pricing:**
+- Hourly billing: `$/PTU/hr × PTUs × 730 hrs/month`
+- Monthly commitment with Reservations discounts
+- **Rates**: See [PTU Billing Guide](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/provisioned-throughput-onboarding)
+- Use PTU calculator to determine requirements (Microsoft Foundry → Operate → Quota → Provisioned Throughput Unit tab)
+- **Best for**: High-volume (>1M tokens/day), predictable traffic, guaranteed throughput
+
+**Cost Decision Framework** (Analytical Guidance):
+
+```
+Step 1: Calculate monthly TPM cost
+  Monthly TPM cost = (Daily tokens × 30 days × $price per 1K tokens) / 1000
+
+Step 2: Calculate monthly PTU cost
+  Monthly PTU cost = Required PTUs × 730 hours/month × $PTU-hour rate
+  (Get Required PTUs from Azure AI Foundry portal: Microsoft Foundry → Operate → Quota → Provisioned Throughput Unit tab)
+
+Step 3: Compare
+  Use PTU when: Monthly PTU cost < (Monthly TPM cost × 0.7)
+  (Use 70% threshold to account for commitment risk)
+```
+
+**Example Calculation** (Analytical):
+
+Scenario: 1M requests/day, average 1,000 tokens per request
+
+- **Daily tokens**: 1,000,000 × 1,000 = 1B tokens/day
+- **TPM Cost** (using GPT-4o at $0.005/1K avg): (1B × 30 × $0.005) / 1000 = ~$150,000/month
+- **PTU Cost** (estimated 100 PTU at ~$5/PTU-hour): 100 PTU × 730 hours × $5 = ~$365,000/month
+- **Decision**: Use TPM (significantly lower cost for this workload)
+
+> **Important**: Always use the official [Azure Pricing Calculator](https://azure.microsoft.com/pricing/calculator/) and Azure AI Foundry portal PTU calculator (Microsoft Foundry → Operate → Quota → Provisioned Throughput Unit tab) for exact pricing by model, region, and workload. Prices vary by region and are subject to change.
+
+---
+
+## Production Workload Examples
+
+Real-world production scenarios with capacity calculations for gpt-4, version 0613 (from Azure Foundry Portal calculator):
+
+| Workload Type | Calls/Min | Prompt Tokens | Response Tokens | Cache Hit % | Total Tokens/Min | PTU Required | TPM Equivalent |
+|---------------|-----------|---------------|-----------------|-------------|------------------|--------------|----------------|
+| **RAG Chat** | 10 | 3,500 | 300 | 20% | 38,000 | 100 | 38K TPM |
+| **Basic Chat** | 10 | 500 | 100 | 20% | 6,000 | 100 | 6K TPM |
+| **Summarization** | 10 | 5,000 | 300 | 20% | 53,000 | 100 | 53K TPM |
+| **Classification** | 10 | 3,800 | 10 | 20% | 38,100 | 100 | 38K TPM |
+
+**How to Calculate Your Needs:**
+
+1. **Determine your peak calls per minute**: Monitor or estimate maximum concurrent requests
+2. **Measure token usage**: Average prompt size + response size
+3. **Account for cache hits**: Prompt caching can reduce effective token count by 20-50%
+4. **Calculate total tokens/min**: (Calls/min × (Prompt tokens + Response tokens)) × (1 - Cache %)
+5. **Choose deployment type**:
+   - **TPM (Standard)**: Allocate 1.5-2× your calculated tokens/min for headroom
+   - **PTU (Provisioned)**: Use Azure AI Foundry portal PTU calculator for exact PTU count (Microsoft Foundry → Operate → Quota → Provisioned Throughput Unit tab)
+
+**Example Calculation (RAG Chat Production):**
+- Peak: 10 calls/min
+- Prompt: 3,500 tokens (context + question)
+- Response: 300 tokens (answer)
+- Cache: 20% hit rate (reduces prompt tokens by 20%)
+- **Total TPM needed**: (10 × (3,500 × 0.8 + 300)) = 31,000 TPM
+- **With 50% headroom**: 46,500 TPM → Round to **50K TPM deployment**
+
+**PTU Recommendation:**
+For the combined workload (40 calls/min, 135K tokens/min total), use **200 PTU** (from calculator above).
+
+---
+
+## Model Selection and Deployment Type Guidance
+
+> **Official Documentation:**
+> - [Choose the Right AI Model for Your Workload](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/choose-ai-model) - Microsoft Architecture Center
+> - [Azure OpenAI Models](https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models) - Model capabilities, regions, and quotas
+> - [Understanding Deployment Types](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-models/concepts/deployment-types) - Standard vs Provisioned guidance
+
+**Model Characteristics** (from [official Azure OpenAI documentation](https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models)):
+
+| Model | Key Characteristics | Best For |
+|-------|---------------------|----------|
+| **GPT-4o** | Matches GPT-4 Turbo performance in English text/coding, superior in non-English and vision tasks. Cheaper and faster than GPT-4 Turbo. | Multimodal tasks, cost-effective general purpose, high-volume production workloads |
+| **GPT-4 Turbo** | Superior reasoning capabilities, larger context window (128K tokens) | Complex reasoning tasks, long-context analysis |
+| **GPT-3.5 Turbo** | Most cost-effective, optimized for chat and completions, fast response time | Simple tasks, customer service, high-volume low-cost scenarios |
+| **GPT-4o mini** | Fastest response time, low latency | Latency-sensitive applications requiring immediate responses |
+| **text-embedding-3-large** | Purpose-built for vector embeddings | RAG applications, semantic search, document similarity |
+
+**Deployment Type Selection** (from [official deployment types guide](https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-models/concepts/deployment-types)):
+
+| Traffic Pattern | Recommended Deployment Type | Reason |
+|-----------------|---------------------------|---------|
+| **Variable, bursty traffic** | Standard or Global Standard (pay-per-token) | No commitment, pay only for usage |
+| **Consistent high volume** | Provisioned types (PTU) | Reserved capacity, predictable costs |
+| **Large batch jobs (non-time-sensitive)** | Global Batch or DataZone Batch | 50% cost savings vs Standard |
+| **Low latency variance required** | Provisioned types | Guaranteed throughput, no rate limits |
+| **No regional restrictions** | Global Standard or Global Provisioned | Access to best available capacity |
+
+**Capacity Planning Approach** (from [PTU onboarding guide](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/provisioned-throughput-onboarding)):
+
+1. **Understand your TPM requirements**: Calculate expected tokens per minute based on workload
+2. **Use the built-in capacity planner**: Available in Azure AI Foundry portal (Microsoft Foundry → Operate → Quota → Provisioned Throughput Unit tab)
+3. **Input your metrics**: Enter input TPM and output TPM based on your workload characteristics
+4. **Get PTU recommendation**: The calculator provides PTU allocation recommendation
+5. **Compare costs**: Evaluate Standard (TPM) vs Provisioned (PTU) using the official pricing calculator
+
+> **Note**: Microsoft does not publish specific "X requests/day = Y TPM" recommendations as capacity requirements vary significantly based on prompt size, response length, cache hit rates, and model choice. Use the built-in capacity planner with your actual workload characteristics.

package/.agents/skills/microsoft-foundry/quota/references/error-resolution.md

@@ -0,0 +1,143 @@
+# Error Resolution Workflows
+
+## Workflow 7: Quota Exhausted Recovery
+
+**A. Deploy to Different Region**
+```bash
+subId=$(az account show --query id -o tsv)
+for region in eastus westus eastus2 westus2 swedencentral uksouth; do
+  az rest --method get --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/$region/usages?api-version=2023-05-01" \
+    --query "value[?name.value=='OpenAI.Standard.gpt-4o'].{Model:name.value, Used:currentValue, Limit:limit, Available:(limit-currentValue)}" -o table &
+done; wait
+```
+
+**B. Delete Unused Deployments**
+```bash
+az cognitiveservices account deployment delete --name <resource> --resource-group <rg> --deployment-name <deployment>
+```
+
+**C. Request Quota Increase (3-5 days)**
+
+**D. Migrate to PTU** - See capacity-planning.md
+
+---
+
+## Workflow 8: Resolve 429 Rate Limit Errors
+
+**Identify Deployment:**
+```bash
+az cognitiveservices account deployment list --name <resource> --resource-group <rg> \
+  --query "[].{Name:name,Model:properties.model.name,TPM:sku.capacity*1000}" -o table
+```
+
+**Solutions:**
+
+**A. Increase Capacity**
+```bash
+az cognitiveservices account deployment update --name <resource> --resource-group <rg> --deployment-name <deployment> --sku-capacity 100
+```
+
+**B. Add Retry Logic** - Exponential backoff in code
+
+**C. Load Balance**
+```bash
+az cognitiveservices account deployment create --name <resource> --resource-group <rg> --deployment-name gpt-4o-2 \
+  --model-name gpt-4o --model-version "2024-05-13" --model-format OpenAI --sku-name Standard --sku-capacity 100
+```
+
+**D. Migrate to PTU** - No rate limits
+
+---
+
+## Workflow 9: Resolve DeploymentLimitReached
+
+**Root Cause:** 10-20 slots per resource.
+
+**Check Count:**
+```bash
+deployment_count=$(az cognitiveservices account deployment list --name <resource> --resource-group <rg> --query "length(@)")
+echo "Deployments: $deployment_count / ~20 slots"
+```
+
+**Find Test Deployments:**
+```bash
+az cognitiveservices account deployment list --name <resource> --resource-group <rg> \
+  --query "[?contains(name,'test') || contains(name,'demo')].{Name:name}" -o table
+```
+
+**Delete:**
+```bash
+az cognitiveservices account deployment delete --name <resource> --resource-group <rg> --deployment-name <deployment>
+```
+
+**Or Create New Resource (fresh 10-20 slots):**
+```bash
+az cognitiveservices account create --name "my-foundry-2" --resource-group <rg> --location eastus --kind AIServices --sku S0 --yes
+```
+
+---
+
+## Workflow 10: Resolve InsufficientQuota
+
+**Root Cause:** Requested capacity exceeds available quota.
+
+**Check Quota:**
+```bash
+subId=$(az account show --query id -o tsv)
+az rest --method get --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/eastus/usages?api-version=2023-05-01" \
+  --query "value[?contains(name.value,'OpenAI')].{Model:name.value, Used:currentValue, Limit:limit, Available:(limit-currentValue)}" -o table
+```
+
+**Solutions:**
+
+**A. Reduce Capacity**
+```bash
+az cognitiveservices account deployment create --name <resource> --resource-group <rg> --deployment-name gpt-4o \
+  --model-name gpt-4o --model-version "2024-05-13" --model-format OpenAI --sku-name Standard --sku-capacity 20
+```
+
+**B. Delete Unused Deployments**
+```bash
+az cognitiveservices account deployment delete --name <resource> --resource-group <rg> --deployment-name <unused>
+```
+
+**C. Different Region** - Check quota with multi-region script (Workflow 7)
+
+**D. Request Increase (3-5 days)**
+
+---
+
+## Workflow 11: Resolve QuotaExceeded
+
+**Root Cause:** Deployment exceeds regional quota.
+
+**Check Quota:**
+```bash
+subId=$(az account show --query id -o tsv)
+az rest --method get --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/eastus/usages?api-version=2023-05-01" \
+  --query "value[?contains(name.value,'OpenAI')]" -o table
+```
+
+**Multi-Region Check:** (Use Workflow 7 script)
+
+**Solutions:**
+
+**A. Delete Unused Deployments**
+```bash
+az cognitiveservices account deployment delete --name <resource> --resource-group <rg> --deployment-name <unused>
+```
+
+**B. Different Region**
+```bash
+az cognitiveservices account deployment create --name <resource> --resource-group <rg> --deployment-name gpt-4o \
+  --model-name gpt-4o --model-version "2024-05-13" --model-format OpenAI --sku-name Standard --sku-capacity 50
+```
+
+**C. Request Increase (3-5 days)**
+
+**D. Reduce Capacity**
+
+**Decision:** Available < 10% → Different region; 10-50% → Delete/reduce; > 50% → Delete one deployment
+
+---
+

package/.agents/skills/microsoft-foundry/quota/references/optimization.md

@@ -0,0 +1,166 @@
+# Quota Optimization Strategies
+
+Comprehensive strategies for optimizing Azure AI Foundry quota allocation and reducing costs.
+
+## 1. Identify and Delete Unused Deployments
+
+**Step 1: Discovery with Quota Context**
+
+Get quota limits FIRST to understand how close you are to capacity:
+
+```bash
+# Check current quota usage vs limits (run this FIRST)
+subId=$(az account show --query id -o tsv)
+region="eastus"  # Change to your region
+az rest --method get \
+  --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/$region/usages?api-version=2023-05-01" \
+  --query "value[?contains(name.value,'OpenAI')].{Model:name.value, Used:currentValue, Limit:limit, Available:'(Limit - Used)'}" -o table
+```
+
+**Step 2: Parallel Deployment Enumeration**
+
+List all deployments across resources efficiently:
+
+```bash
+# Get all Foundry resources
+resources=$(az cognitiveservices account list --query "[?kind=='AIServices'].{name:name,rg:resourceGroup}" -o json)
+
+# Parallel deployment enumeration (faster than sequential)
+echo "$resources" | jq -r '.[] | "\(.name) \(.rg)"' | while read name rg; do
+  echo "=== $name ($rg) ==="
+  az cognitiveservices account deployment list --name "$name" --resource-group "$rg" \
+    --query "[].{Deployment:name,Model:properties.model.name,Capacity:sku.capacity,Created:systemData.createdAt}" -o table &
+done
+wait  # Wait for all background jobs to complete
+```
+
+**Step 3: Identify Stale Deployments**
+
+Criteria for deletion candidates:
+
+- **Test/temporary naming**: Contains "test", "demo", "temp", "dev" in deployment name
+- **Old timestamps**: Created >90 days ago with timestamp-based naming (e.g., "gpt4-20231015")
+- **High capacity consumers**: Deployments with >100K TPM capacity that haven't been referenced in recent logs
+- **Duplicate models**: Multiple deployments of same model/version in same region
+
+**Example pattern matching for stale deployments:**
+```bash
+# Find deployments with test/temp naming
+az cognitiveservices account deployment list --name <resource> --resource-group <rg> \
+  --query "[?contains(name,'test') || contains(name,'demo') || contains(name,'temp')].{Name:name,Capacity:sku.capacity}" -o table
+```
+
+**Step 4: Delete and Verify Quota Recovery**
+
+```bash
+# Delete unused deployment (quota freed IMMEDIATELY)
+az cognitiveservices account deployment delete --name <resource> --resource-group <rg> --deployment-name <deployment>
+
+# Verify quota freed (re-run Step 1 quota check)
+# You should see "Used" decrease by the deployment's capacity
+```
+
+**Cost Impact Analysis:**
+
+| Deployment Type | Capacity (TPM) | Quota Freed | Cost Impact (TPM) | Cost Impact (PTU) |
+|-----------------|----------------|-------------|-------------------|-------------------|
+| Test deployment | 10K TPM | 10K TPM | $0 (pay-per-use) | N/A |
+| Unused production | 100K TPM | 100K TPM | $0 (pay-per-use) | N/A |
+| Abandoned PTU deployment | 100 PTU | ~40K TPM equivalent | $0 TPM | **$3,650/month saved** (100 PTU × 730h × $0.05/h) |
+| High-capacity test | 450K TPM | 450K TPM | $0 (pay-per-use) | N/A |
+
+**Key Insight:** For TPM (Standard) deployments, deletion frees quota but has no direct cost impact (you pay per token used). For PTU (Provisioned) deployments, deletion **immediately stops hourly charges** and can save thousands per month.
+
+---
+
+## 2. Right-Size Over-Provisioned Deployments
+
+**Identify over-provisioned deployments:**
+- Check Azure Monitor metrics for actual token usage
+- Compare allocated TPM vs. peak usage
+- Look for deployments with <50% utilization
+
+**Right-sizing example:**
+```bash
+# Update deployment to lower capacity
+az cognitiveservices account deployment update --name <resource> --resource-group <rg> \
+  --deployment-name <deployment> --sku-capacity 30  # Reduce from 50K to 30K TPM
+```
+
+**Cost Optimization:**
+- **TPM (Standard)**: Reduces regional quota consumption (no direct cost savings, pay-per-token)
+- **PTU (Provisioned)**: Direct cost reduction (40% capacity reduction = 40% cost reduction)
+
+---
+
+## 3. Consolidate Multiple Small Deployments
+
+**Pattern:** Multiple 10K TPM deployments → One 30-50K TPM deployment
+
+**Benefits:**
+- Fewer deployment slots consumed
+- Simpler management
+- Same total capacity, better utilization
+
+**Example:**
+- **Before**: 3 deployments @ 10K TPM each = 30K TPM total, 3 slots used
+- **After**: 1 deployment @ 30K TPM = 30K TPM total, 1 slot used
+- **Savings**: 2 deployment slots freed for other models
+
+---
+
+## 4. Cost Optimization Strategies
+
+> **Official Documentation**: [Plan to manage costs for Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/manage-costs) and [Fine-tuning cost management](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/fine-tuning-cost-management)
+
+**A. Use Fine-Tuned Smaller Models** (from [Microsoft Transparency Note](https://learn.microsoft.com/en-us/azure/ai-foundry/responsible-ai/openai/transparency-note)):
+
+You can reduce costs or latency by swapping a fine-tuned version of a smaller/faster model (e.g., fine-tuned GPT-3.5-Turbo) for a more general-purpose model (e.g., GPT-4).
+
+```bash
+# Deploy fine-tuned GPT-3.5 Turbo as cost-effective alternative to GPT-4
+az cognitiveservices account deployment create --name <resource> --resource-group <rg> \
+  --deployment-name gpt-35-tuned --model-name <your-fine-tuned-model> \
+  --model-format OpenAI --sku-name Standard --sku-capacity 10
+```
+
+**B. Remove Unused Fine-Tuned Deployments** (from [Fine-tuning cost management](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/fine-tuning-cost-management)):
+
+Fine-tuned model deployments incur **hourly hosting costs** even when not in use. Remove unused deployments promptly to control costs.
+
+- Inactive deployments unused for **15 consecutive days** are automatically deleted
+- Proactively delete unused fine-tuned deployments to avoid hourly charges
+
+```bash
+# Delete unused fine-tuned deployment
+az cognitiveservices account deployment delete --name <resource> --resource-group <rg> \
+  --deployment-name <unused-fine-tuned-deployment>
+```
+
+**C. Batch Multiple Requests** (from [Cost optimization Q&A](https://learn.microsoft.com/en-us/answers/questions/1689253/how-to-optimize-costs-per-request-azure-openai-gpt)):
+
+Batch multiple requests together to reduce the total number of API calls and lower overall costs.
+
+**D. Use Commitment Tiers for Predictable Costs** (from [Managing costs guide](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/manage-costs)):
+
+- **Pay-as-you-go**: Bills according to usage (variable costs)
+- **Commitment tiers**: Commit to using service features for a fixed fee (predictable costs, potential savings for consistent usage)
+
+---
+
+## 5. Regional Quota Rebalancing
+
+If you have quota spread across multiple regions but only use some:
+
+```bash
+# Check quota across regions
+for region in eastus westus uksouth; do
+  echo "=== $region ==="
+  subId=$(az account show --query id -o tsv)
+  az rest --method get \
+    --url "https://management.azure.com/subscriptions/$subId/providers/Microsoft.CognitiveServices/locations/$region/usages?api-version=2023-05-01" \
+    --query "value[?contains(name.value,'OpenAI')].{Model:name.value, Used:currentValue, Limit:limit}" -o table
+done
+```
+
+**Optimization:** Concentrate deployments in fewer regions to maximize quota utilization per region.