Complete Azure Storage MCP Demo: Real-World Examples

# Global installation
npm install -g @ignitionai/azure-storage-mcp

# Or direct usage with npx
npx @ignitionai/azure-storage-mcp

{
  "mcpServers": {
    "azure-storage": {
      "command": "npx",
      "args": ["-y", "@ignitionai/azure-storage-mcp"],
      "env": {
        "AZURE_STORAGE_CONNECTION_STRING": "your-connection-string",
        "AZURE_STORAGE_ACCOUNT_NAME": "your-storage-account"
      }
    }
  }
}

"Can you list all available Azure tables and blob containers?"

Claude: "I can see the following Azure Storage resources:

Tables:
- Customers (423 entities)
- Orders (1,247 entities)
- Products (89 entities)
- Analytics (10,453 entities)

Blob Containers:
- documents (156 blobs)
- images (342 blobs)
- backups (28 blobs)
- reports (67 blobs)

What would you like to work with?"

You: "Analyze the structure of the Customers table"

{
  "tool": "inspect-azure-table-schema",
  "arguments": {
    "tableName": "Customers",
    "sampleSize": 50
  }
}

Claude: "I've analyzed the Customers table structure:

📊 Schema Analysis:
- Total Properties: 12
- Required Fields (>80% presence):
  • customerID (string) - Always present
  • name (string) - Always present
  • email (string) - Always present
  • registrationDate (string) - Always present
  • tier (string) - Values: 'bronze', 'silver', 'gold'
  • active (boolean) - Always present

- Optional Fields:
  • phone (string) - 67% presence
  • address (object) - 45% presence
  • preferences (object) - 34% presence
  • lastOrderDate (string) - 78% presence
  • totalSpent (number) - 89% presence
  • notes (string) - 23% presence

Partition Strategy: By 'tier' (bronze/silver/gold)
Row Key Pattern: 'CUST_' + numeric ID"

You: "Add a new gold tier customer: John Smith, john@techcorp.com"

{
  "tool": "create-azure-table-entity",
  "arguments": {
    "tableName": "Customers",
    "partitionKey": "gold",
    "rowKey": "CUST_00424",
    "entity": {
      "customerID": "CUST_00424",
      "name": "John Smith",
      "email": "john@techcorp.com",
      "registrationDate": "2024-01-15T10:30:00Z",
      "tier": "gold",
      "active": true,
      "totalSpent": 0,
      "preferences": {
        "newsletter": true,
        "notifications": "email"
      }
    }
  }
}

You: "Import these 5 new customers from our sales team"

{
  "tool": "batch-create-azure-table-entities",
  "arguments": {
    "tableName": "Customers",
    "entities": [
      {
        "partitionKey": "silver",
        "rowKey": "CUST_00425",
        "entity": {
          "name": "Alice Johnson",
          "email": "alice@startup.io",
          "tier": "silver",
          "active": true
        }
      },
      {
        "partitionKey": "bronze",
        "rowKey": "CUST_00426",
        "entity": {
          "name": "Bob Wilson",
          "email": "bob@smallbiz.com",
          "tier": "bronze",
          "active": true
        }
      }
      // ... more customers
    ]
  }
}

You: "Show me all gold tier customers who spent over $10,000 last month"

{
  "tool": "query-azure-table-advanced",
  "arguments": {
    "tableName": "Customers",
    "filter": "PartitionKey eq 'gold' and totalSpent gt 10000",
    "select": ["name", "email", "totalSpent", "lastOrderDate"],
    "orderBy": ["totalSpent desc"],
    "top": 20
  }
}

Claude: "Here are your top gold tier customers:

1. TechCorp Industries - $45,230 (Last order: 3 days ago)
2. Innovation Labs - $38,450 (Last order: Yesterday)
3. Digital Solutions Inc - $28,900 (Last order: 1 week ago)
...

Would you like me to:
- Export this list to a report?
- Send personalized offers to these customers?
- Analyze their purchasing patterns?"

You: "Create a new order for customer CUST_00424"

{
  "tool": "check-azure-table-entity-exists",
  "arguments": {
    "tableName": "Customers",
    "partitionKey": "gold",
    "rowKey": "CUST_00424"
  }
}

{
  "tool": "create-azure-table-entity",
  "arguments": {
    "tableName": "Orders",
    "partitionKey": "2024-01",
    "rowKey": "ORD_2024_0156",
    "entity": {
      "orderID": "ORD_2024_0156",
      "customerID": "CUST_00424",
      "orderDate": "2024-01-15T14:30:00Z",
      "items": [
        {
          "productID": "PROD_101",
          "quantity": 2,
          "unitPrice": 299.99
        }
      ],
      "total": 599.98,
      "status": "pending"
    }
  }
}

You: "Analyze January 2024 orders by customer tier"

{
  "tool": "read-azure-table",
  "arguments": {
    "tableName": "Orders",
    "filter": "PartitionKey eq '2024-01'",
    "maxResults": 1000
  }
}

Claude: "📊 January 2024 Order Analysis by Customer Tier:

Gold Tier (28% of customers):
- Orders: 452 (45% of total)
- Revenue: $125,340 (62% of total)
- Avg Order Value: $277.30
- Top Product Category: Enterprise Solutions

Silver Tier (35% of customers):
- Orders: 389 (38% of total)
- Revenue: $56,230 (28% of total)
- Avg Order Value: $144.55
- Top Product Category: Professional Tools

Bronze Tier (37% of customers):
- Orders: 178 (17% of total)
- Revenue: $20,150 (10% of total)
- Avg Order Value: $113.20
- Top Product Category: Basic Packages

Key Insights:
✨ Gold customers generate 2.2x more revenue per customer
📈 Silver tier shows highest growth potential
🎯 Bronze tier has low engagement - consider upgrade campaigns"

You: "Set up a new document structure for Q1 2024 reports"

{
  "tool": "create-azure-blob-container",
  "arguments": {
    "containerName": "reports-2024-q1",
    "metadata": {
      "purpose": "Quarterly Reports Q1 2024",
      "department": "Analytics",
      "access_level": "internal"
    }
  }
}

You: "Upload the sales report I just created"

{
  "tool": "upload-azure-blob",
  "arguments": {
    "containerName": "reports-2024-q1",
    "blobName": "sales-analysis-january-2024.pdf",
    "content": "[base64 encoded content]",
    "contentType": "application/pdf",
    "metadata": {
      "author": "Analytics Team",
      "created": "2024-01-15",
      "department": "Sales",
      "confidentiality": "internal"
    }
  }
}

You: "Find all reports related to customer acquisition from last quarter"

{
  "tool": "list-azure-blobs",
  "arguments": {
    "containerName": "reports-2023-q4",
    "prefix": "acquisition"
  }
}

Claude: "I found 7 customer acquisition reports from Q4 2023:

📄 acquisition-analysis-october-2023.pdf (2.3 MB)
   Created: Oct 31, 2023 | Author: Marketing Team

📄 acquisition-costs-breakdown-q4.xlsx (456 KB)
   Created: Dec 15, 2023 | Author: Finance Team

📄 acquisition-channels-performance.pdf (1.8 MB)
   Created: Dec 28, 2023 | Author: Analytics Team

Would you like me to:
- Download any of these reports?
- Create a summary from all reports?
- Compare with current quarter performance?"

You: "Upload these 20 product images to our catalog"

// Claude automatically:
// 1. Validates image formats
// 2. Generates appropriate names
// 3. Adds metadata
// 4. Organizes by category

for (const image of images) {
  await uploadBlob({
    containerName: "product-images",
    blobName: `products/${category}/${productId}-${index}.jpg`,
    content: imageContent,
    contentType: "image/jpeg",
    metadata: {
      productId: productId,
      category: category,
      uploadDate: new Date().toISOString(),
      dimensions: `${width}x${height}`,
      fileSize: size
    }
  });
}

You: "Show me all images for electronics products"

Claude: "📸 Electronics Product Images:

Category: Laptops (45 images)
├── PROD_101-main.jpg (1.2 MB, 1920x1080)
├── PROD_101-side.jpg (980 KB, 1920x1080)
├── PROD_101-keyboard.jpg (750 KB, 1920x1080)
└── ... 42 more

Category: Smartphones (67 images)
├── PROD_201-front.jpg (890 KB, 1080x1920)
├── PROD_201-back.jpg (920 KB, 1080x1920)
└── ... 65 more

Total: 112 images (143 MB)

Options:
- Generate a product catalog PDF
- Create thumbnail versions
- Export to marketing team"

You: "Migrate all customer data from the old 'Users' table to the new 'Customers' table with data enrichment"

// Step 1: Analyze source schema
const sourceSchema = await inspectTableSchema("Users");

// Step 2: Read all source data with pagination
let allUsers = [];
let continuationToken = null;
do {
  const batch = await queryTableAdvanced({
    tableName: "Users",
    top: 100,
    continuationToken: continuationToken
  });
  allUsers.push(...batch.entities);
  continuationToken = batch.continuationToken;
} while (continuationToken);

// Step 3: Transform and enrich data
const enrichedCustomers = allUsers.map(user => ({
  partitionKey: determineTier(user),
  rowKey: `CUST_${user.id}`,
  entity: {
    ...transformUserData(user),
    migrationDate: new Date().toISOString(),
    dataSource: "legacy_migration",
    enriched: true
  }
}));

// Step 4: Batch insert with progress tracking
const chunks = chunkArray(enrichedCustomers, 100);
for (let i = 0; i < chunks.length; i++) {
  await batchCreateEntities({
    tableName: "Customers",
    entities: chunks[i]
  });

  console.log(`Progress: ${(i + 1) * 100} / ${allUsers.length} customers migrated`);
}

// Step 5: Validation
const validation = await validateMigration("Users", "Customers");

Claude: "✅ Migration completed successfully!

📊 Migration Summary:
- Total Records: 1,247
- Successfully Migrated: 1,247 (100%)
- Data Enrichments Applied: 1,089
- Tier Distribution:
  • Gold: 234 customers
  • Silver: 456 customers  
  • Bronze: 557 customers

🔍 Validation Results:
- All IDs mapped correctly ✓
- No data loss detected ✓
- Enrichment rules applied consistently ✓

📝 Next Steps:
1. Review 158 customers with incomplete profiles
2. Update application connection strings
3. Schedule old table deletion (recommended: after 30 days)

Would you like me to generate a detailed migration report?"

You: "Create a complete backup of all critical tables and generate a restore script"

// Step 1: Identify critical tables
const criticalTables = ["Customers", "Orders", "Products", "Inventory"];

// Step 2: Create backup container with timestamp
const backupContainer = `backup-${new Date().toISOString().split('T')[0]}`;
await createBlobContainer({
  containerName: backupContainer,
  metadata: {
    type: "full_backup",
    timestamp: new Date().toISOString(),
    tables: criticalTables.join(",")
  }
});

// Step 3: Export each table
for (const table of criticalTables) {
  // Get all data
  const data = await exportTableData(table);

  // Create backup blob
  await uploadBlob({
    containerName: backupContainer,
    blobName: `${table}-backup.json`,
    content: JSON.stringify(data, null, 2),
    contentType: "application/json",
    metadata: {
      recordCount: data.length,
      backupDate: new Date().toISOString(),
      tableName: table
    }
  });
}

// Step 4: Generate restore script
const restoreScript = generateRestoreScript(backupContainer, criticalTables);
await uploadBlob({
  containerName: backupContainer,
  blobName: "restore-script.ps1",
  content: restoreScript,
  contentType: "text/plain"
});

Claude: "🔒 Backup completed successfully!

📦 Backup Details:
- Container: backup-2024-01-15
- Total Size: 48.3 MB
- Tables Backed Up:
  • Customers: 1,247 records (2.1 MB)
  • Orders: 4,532 records (15.6 MB)
  • Products: 892 records (28.4 MB)
  • Inventory: 3,201 records (2.2 MB)

📄 Generated Files:
- Customers-backup.json
- Orders-backup.json
- Products-backup.json
- Inventory-backup.json
- restore-script.ps1

🔧 Restore Command:
./restore-script.ps1 -Container "backup-2024-01-15" -TargetAccount "your-storage"

⏰ Automated Backup Schedule:
- Daily incremental: 2 AM UTC
- Weekly full: Sunday 3 AM UTC
- Retention: 30 days

The backup is verified and ready for disaster recovery scenarios."

You: "Create a real-time analytics view of today's business metrics"

// Gather data from multiple tables
const metrics = {
  orders: await getOrderMetrics("today"),
  customers: await getCustomerMetrics("today"),
  inventory: await getInventoryStatus(),
  performance: await getSystemPerformance()
};

// Generate comprehensive dashboard
const dashboard = {
  timestamp: new Date().toISOString(),
  kpi: {
    revenue: metrics.orders.totalRevenue,
    orderCount: metrics.orders.count,
    averageOrderValue: metrics.orders.avgValue,
    newCustomers: metrics.customers.newToday,
    conversionRate: metrics.customers.conversionRate
  },
  alerts: detectAnomalies(metrics),
  trends: calculateTrends(metrics)
};

Claude: "📊 Real-Time Business Dashboard (Jan 15, 2024 - 2:30 PM)

💰 Revenue Metrics:
- Today's Revenue: $32,450 (↑ 12% vs yesterday)
- Orders: 156 (↑ 8%)
- Average Order: $208.01 (↑ 4%)
- Conversion Rate: 3.2% (→ stable)

👥 Customer Activity:
- New Registrations: 23 (↑ 15%)
- Active Users: 1,247
- Gold Tier Activity: 67% (high engagement)

📦 Inventory Status:
- Low Stock Alerts: 3 products
- Out of Stock: 0 products
- Reorder Required: 7 products

🚨 Alerts:
⚠ Unusual order volume from IP range 192.168.x.x
⚠ Product SKU-1234 selling 3x faster than usual
✅ All systems operational

📈 Hourly Trend:
Peak hours: 10-11 AM (45 orders)
Current hour: 23 orders (on track)

Would you like me to:
- Investigate the unusual order patterns?
- Generate detailed product performance report?
- Set up automated alerts for these metrics?"

You: "Set up automated onboarding for new enterprise customers"

async function onboardEnterpriseCustomer(customerData) {
  // Step 1: Create customer record
  const customer = await createCustomerRecord({
    ...customerData,
    tier: "gold",
    onboardingStatus: "in_progress"
  });

  // Step 2: Generate welcome package
  const welcomeDocs = await generateWelcomeDocuments(customer);

  // Step 3: Upload documents
  await uploadBlob({
    containerName: "customer-documents",
    blobName: `${customer.id}/welcome-package.pdf`,
    content: welcomeDocs.pdf,
    metadata: { customerId: customer.id }
  });

  // Step 4: Create initial configuration
  await createTableEntity({
    tableName: "Configurations",
    partitionKey: customer.id,
    rowKey: "default",
    entity: {
      apiLimits: { requests: 10000, storage: "100GB" },
      features: ["analytics", "api", "support"],
      setupComplete: false
    }
  });

  // Step 5: Set up monitoring
  await createTableEntity({
    tableName: "Monitoring",
    partitionKey: customer.id,
    rowKey: "alerts",
    entity: {
      email: customerData.email,
      thresholds: { api: 9000, storage: 90 }
    }
  });

  // Step 6: Update status
  await updateTableEntity({
    tableName: "Customers",
    partitionKey: "gold",
    rowKey: customer.rowKey,
    entity: { onboardingStatus: "complete" }
  });

  return {
    customerId: customer.id,
    documentsUrl: `https://portal.company.com/docs/${customer.id}`,
    apiKey: generateApiKey(customer.id),
    nextSteps: ["Schedule onboarding call", "Technical integration"]
  };
}

You: "Generate the complete monthly report for December 2023"

async function generateMonthlyReport(year, month) {
  // Step 1: Collect all data
  const data = {
    revenue: await getRevenueData(year, month),
    customers: await getCustomerMetrics(year, month),
    products: await getProductPerformance(year, month),
    operations: await getOperationalMetrics(year, month)
  };

  // Step 2: Generate visualizations
  const charts = await generateCharts(data);

  // Step 3: Create report sections
  const report = {
    executive_summary: generateExecutiveSummary(data),
    revenue_analysis: generateRevenueAnalysis(data.revenue),
    customer_insights: generateCustomerInsights(data.customers),
    product_performance: generateProductAnalysis(data.products),
    operational_metrics: generateOperationalReport(data.operations),
    recommendations: generateRecommendations(data)
  };

  // Step 4: Compile PDF
  const pdfReport = await compilePdfReport(report, charts);

  // Step 5: Store report
  await uploadBlob({
    containerName: "reports",
    blobName: `monthly/${year}/${month}/complete-report.pdf`,
    content: pdfReport,
    metadata: {
      type: "monthly_report",
      period: `${year}-${month}`,
      generated: new Date().toISOString()
    }
  });

  // Step 6: Create summary data
  await createTableEntity({
    tableName: "ReportSummaries",
    partitionKey: year.toString(),
    rowKey: `${year}-${month}`,
    entity: {
      revenue: data.revenue.total,
      growth: data.revenue.growthRate,
      newCustomers: data.customers.new,
      topProduct: data.products.top.name,
      reportUrl: `reports/monthly/${year}/${month}/complete-report.pdf`
    }
  });

  return {
    reportUrl: `https://storage.company.com/reports/monthly/${year}/${month}/complete-report.pdf`,
    keyMetrics: {
      revenue: `$${data.revenue.total.toLocaleString()}`,
      growth: `${data.revenue.growthRate}%`,
      customerSatisfaction: `${data.customers.satisfaction}/5`
    }
  };
}

Claude: "✅ December 2023 Monthly Report Generated!

📊 Key Highlights:
- Revenue: $1,245,320 (↑ 18% YoY)
- New Customers: 156 (↑ 23% vs November)
- Customer Satisfaction: 4.7/5
- Top Product: Enterprise Suite Pro

📈 Report Sections:
1. Executive Summary (2 pages)
2. Revenue Analysis (5 pages)
3. Customer Insights (4 pages)
4. Product Performance (6 pages)
5. Operational Metrics (3 pages)
6. Strategic Recommendations (2 pages)

📎 Report Available at:
https://storage.company.com/reports/monthly/2023/12/complete-report.pdf

📧 Distribution:
- Automatically sent to executive team
- Archived in reports container
- Summary added to analytics dashboard

Next monthly report scheduled for: January 31, 2024"

// ❌ Inefficient: Multiple single queries
for (const id of customerIds) {
  const customer = await getCustomer(id);
  // Process...
}

// ✅ Efficient: Batch query with filter
const customers = await queryTableAdvanced({
  tableName: "Customers",
  filter: `RowKey in (${customerIds.map(id => `'${id}'`).join(',')})`,
  top: 1000
});

// ✅ Good partition key strategies:
// By time period for time-series data
partitionKey: "2024-01"

// By category for lookups
partitionKey: "electronics"

// By tenant for multi-tenant apps
partitionKey: "tenant-123"

// ✅ Use metadata for searchability
await uploadBlob({
  containerName: "documents",
  blobName: "contract-123.pdf",
  content: pdfContent,
  metadata: {
    client: "ACME Corp",
    type: "service_agreement",
    expires: "2024-12-31",
    value: "50000",
    tags: "legal,active,priority"
  }
});