Authorization: Bearer your_api_key_here

# Linux/macOS
export AICORTEX_API_KEY="your_api_key_here"

# Windows
set AICORTEX_API_KEY=your_api_key_here

https://api.aicortex.in/v1

Authorization: Bearer your_api_key_here
Content-Type: application/json

{
  "error": {
    "code": "INVALID_MODEL_ID",
    "message": "The specified model ID 'invalid-model' does not exist",
    "details": {
      "model_id": "invalid-model",
      "available_models": [
        "resnet50-imagenet",
        "gpt-3.5-turbo",
        "whisper-large-v3"
      ]
    },
    "request_id": "req_error_123"
  }
}

# Install the SDK
pip install aicortex

# Or install with optional dependencies
pip install aicortex[full]  # Includes visualization, async, and dev tools

# Install specific extras
pip install aicortex[async]  # Async support
pip install aicortex[viz]    # Visualization tools
pip install aicortex[dev]    # Development utilities

from aicortex.types import (
    Model, Deployment, TrainingJob, 
    PredictionResult, DeploymentConfig
)
from typing import List, Optional

# Fully typed responses
def deploy_model(model_id: str, config: DeploymentConfig) -> Deployment:
    deployment = client.models.deploy(
        model_id=model_id,
        name=f"deployment-{model_id}",
        config=config
    )
    return deployment

# IDE autocomplete and type checking
def get_models_by_category(category: str) -> List[Model]:
    models: List[Model] = client.models.list(category=category)
    return [model for model in models if model.accuracy > 0.9]

# Optional parameters with defaults
def predict_with_options(
    deployment_name: str,
    inputs: dict,
    temperature: Optional[float] = None,
    max_tokens: Optional[int] = None
) -> PredictionResult:
    return client.models.predict(
        deployment_name=deployment_name,
        inputs=inputs,
        temperature=temperature,
        max_tokens=max_tokens
    )

from aicortex.exceptions import (
    AICortexError, AuthenticationError, RateLimitError,
    ModelNotFoundError, DeploymentError, ValidationError
)
import time
import random

# Comprehensive error handling
def robust_prediction(deployment_name: str, inputs: dict, max_retries: int = 3):
    for attempt in range(max_retries):
        try:
            result = client.models.predict(
                deployment_name=deployment_name,
                inputs=inputs
            )
            return result
            
        except RateLimitError as e:
            if attempt < max_retries - 1:
                # Exponential backoff with jitter
                delay = (2 ** attempt) + random.uniform(0, 1)
                print(f"Rate limited. Retrying in {delay:.1f}s...")
                time.sleep(delay)
                continue
            raise
            
        except ModelNotFoundError:
            print(f"Model {deployment_name} not found")
            raise
            
        except DeploymentError as e:
            print(f"Deployment error: {e.message}")
            if e.is_retryable and attempt < max_retries - 1:
                time.sleep(5)
                continue
            raise
            
        except ValidationError as e:
            print(f"Input validation failed: {e.details}")
            raise  # Don't retry validation errors
            
        except AICortexError as e:
            print(f"API error: {e.message} (Code: {e.error_code})")
            raise

# Context manager for automatic cleanup
from aicortex.context import deployment_context

with deployment_context("temp-model", auto_cleanup=True) as deployment:
    # Deployment is automatically cleaned up on exit
    result = client.models.predict(
        deployment_name=deployment.name,
        inputs={"text": "Hello world"}
    )
    print(result.predictions[0].label)
# Deployment automatically deleted here

# Batch predictions
batch_inputs = [
    {"text": "I love this product!"},
    {"text": "This is terrible."},
    {"text": "It's okay, nothing special."}
]

# Process batch with progress tracking
results = client.models.predict_batch(
    deployment_name="sentiment-analyzer",
    inputs=batch_inputs,
    batch_size=10,
    show_progress=True
)

for i, result in enumerate(results):
    print(f"Input {i+1}: {result.predictions[0].label}")

# Streaming predictions for real-time processing
def process_stream():
    for data in client.data_streams.stream("real-time-data"):
        try:
            result = client.models.predict(
                deployment_name="real-time-classifier",
                inputs=data
            )
            
            # Process result
            yield {
                "input_id": data.get("id"),
                "prediction": result.predictions[0].label,
                "confidence": result.predictions[0].confidence,
                "timestamp": time.time()
            }
            
        except Exception as e:
            print(f"Error processing {data.get('id')}: {e}")
            continue

# Consume streaming results
for prediction in process_stream():
    print(f"Processed {prediction['input_id']}: {prediction['prediction']}")

# Built-in utilities
from aicortex.utils import (
    format_size, estimate_cost, validate_inputs,
    benchmark_model, optimize_batch_size
)

# Format and display information
model = client.models.get("large-language-model")
print(f"Model size: {format_size(model.size_bytes)}")
print(f"Parameters: {model.parameters:,}")

# Cost estimation
estimated_cost = estimate_cost(
    model_id="gpt-3.5-turbo",
    input_tokens=1000,
    output_tokens=500,
    requests_per_day=10000
)
print(f"Estimated monthly cost: ${estimated_cost:.2f}")

# Input validation
validation_result = validate_inputs(
    model_id="image-classifier",
    inputs={"image": "path/to/image.jpg"}
)
if not validation_result.is_valid:
    print(f"Validation errors: {validation_result.errors}")

# Benchmark model performance
benchmark_results = benchmark_model(
    deployment_name="my-model",
    test_data=test_dataset,
    metrics=["accuracy", "latency", "throughput"]
)
print(f"Accuracy: {benchmark_results.accuracy:.2%}")
print(f"Avg latency: {benchmark_results.avg_latency}ms")

# Optimize batch size for throughput
optimal_batch_size = optimize_batch_size(
    deployment_name="my-model",
    sample_inputs=sample_data,
    target_latency="2s",
    max_batch_size=64
)
print(f"Optimal batch size: {optimal_batch_size}")

# Install with npm
npm install @aicortex/client

# Install with yarn
yarn add @aicortex/client

# Install with pnpm
pnpm add @aicortex/client

# Install with TypeScript support (included by default)
npm install @aicortex/client @types/node

// Streaming predictions
async function streamingInference() {
  const stream = client.models.predictStream({
    deploymentName: 'text-generator',
    inputs: {
      prompt: 'Write a story about',
      maxTokens: 500,
      stream: true
    }
  });

  console.log('Streaming response:');
  for await (const chunk of stream) {
    process.stdout.write(chunk.text);
  }
  console.log('\nStream completed');
}

// Server-Sent Events for real-time updates
function monitorDeployment(deploymentName) {
  const eventSource = client.deployments.createEventStream(deploymentName);
  
  eventSource.addEventListener('status_change', (event) => {
    console.log('Status update:', JSON.parse(event.data));
  });
  
  eventSource.addEventListener('metric_update', (event) => {
    const metrics = JSON.parse(event.data);
    console.log(`CPU: ${metrics.cpu}%, Memory: ${metrics.memory}%`);
  });
  
  eventSource.addEventListener('error', (event) => {
    console.error('Deployment error:', event.data);
  });
  
  // Clean up after 1 hour
  setTimeout(() => {
    eventSource.close();
  }, 3600000);
}

// WebSocket connection for bi-directional communication
async function setupWebSocketConnection() {
  const ws = await client.createWebSocket({
    protocols: ['inference', 'monitoring'],
    heartbeat: true
  });

  ws.on('open', () => {
    console.log('WebSocket connected');
    
    // Send inference request
    ws.send({
      type: 'predict',
      deployment: 'real-time-model',
      data: { text: 'Hello world' }
    });
  });

  ws.on('message', (data) => {
    const message = JSON.parse(data);
    
    switch (message.type) {
      case 'prediction':
        console.log('Prediction:', message.result);
        break;
      case 'status':
        console.log('Status:', message.status);
        break;
      case 'error':
        console.error('Error:', message.error);
        break;
    }
  });

  ws.on('close', () => {
    console.log('WebSocket disconnected');
  });

  return ws;
}

const fs = require('fs');
const path = require('path');

// Upload large files with progress tracking
async function uploadLargeFile(filePath, onProgress) {
  const fileSize = fs.statSync(filePath).size;
  const stream = fs.createReadStream(filePath);
  
  const uploadResult = await client.files.upload({
    stream,
    filename: path.basename(filePath),
    size: fileSize,
    onProgress: (uploaded, total) => {
      const percentage = (uploaded / total) * 100;
      onProgress(`Upload progress: ${percentage.toFixed(1)}%`);
    }
  });
  
  console.log(`File uploaded: ${uploadResult.fileId}`);
  return uploadResult;
}

// Batch file processing
async function processBatchFiles(fileUrls) {
  const batchSize = 10;
  const results = [];
  
  for (let i = 0; i < fileUrls.length; i += batchSize) {
    const batch = fileUrls.slice(i, i + batchSize);
    
    const batchPromises = batch.map(async (url, index) => {
      try {
        const result = await client.models.predict({
          deploymentName: 'document-processor',
          inputs: { document: url }
        });
        
        console.log(`Processed file ${i + index + 1}/${fileUrls.length}`);
        return { url, result: result.predictions[0], success: true };
        
      } catch (error) {
        console.error(`Failed to process ${url}:`, error.message);
        return { url, error: error.message, success: false };
      }
    });
    
    const batchResults = await Promise.allSettled(batchPromises);
    results.push(...batchResults.map(r => r.value || r.reason));
    
    // Small delay between batches to avoid rate limiting
    if (i + batchSize < fileUrls.length) {
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
  
  return results;
}

// Multipart upload for very large files
async function uploadVeryLargeFile(filePath) {
  const fileSize = fs.statSync(filePath).size;
  const chunkSize = 10 * 1024 * 1024; // 10MB chunks
  
  // Initialize multipart upload
  const upload = await client.files.createMultipartUpload({
    filename: path.basename(filePath),
    size: fileSize,
    chunkSize
  });
  
  const chunks = Math.ceil(fileSize / chunkSize);
  const uploadPromises = [];
  
  for (let i = 0; i < chunks; i++) {
    const start = i * chunkSize;
    const end = Math.min(start + chunkSize, fileSize);
    const chunk = fs.createReadStream(filePath, { start, end: end - 1 });
    
    uploadPromises.push(
      client.files.uploadChunk({
        uploadId: upload.uploadId,
        chunkNumber: i + 1,
        data: chunk
      })
    );
  }
  
  // Upload chunks in parallel (with concurrency limit)
  const chunkResults = await Promise.all(uploadPromises);
  
  // Complete multipart upload
  const finalResult = await client.files.completeMultipartUpload({
    uploadId: upload.uploadId,
    chunks: chunkResults
  });
  
  console.log(`Large file uploaded successfully: ${finalResult.fileId}`);
  return finalResult;
}

# List all webhooks
webhooks = client.webhooks.list()
for webhook in webhooks:
    print(f"Webhook {webhook.id}: {webhook.url}")
    print(f"  Events: {', '.join(webhook.events)}")
    print(f"  Active: {webhook.active}")
    print(f"  Success rate: {webhook.success_rate:.1%}")

# Get webhook delivery logs
deliveries = client.webhooks.get_deliveries(webhook_id, limit=50)
for delivery in deliveries:
    print(f"[{delivery.timestamp}] {delivery.event_type}")
    print(f"  Status: {delivery.status_code} - {delivery.status}")
    print(f"  Response time: {delivery.response_time}ms")

# Retry failed deliveries
failed_deliveries = [d for d in deliveries if d.status != 'success']
for delivery in failed_deliveries:
    retry_result = client.webhooks.retry_delivery(delivery.id)
    print(f"Retried delivery {delivery.id}: {retry_result.status}")

# Pause webhook temporarily
client.webhooks.pause(webhook_id)
print("Webhook paused")

# Resume webhook
client.webhooks.resume(webhook_id)
print("Webhook resumed")

# Delete webhook
client.webhooks.delete(webhook_id)
print("Webhook deleted")

# Configure SSO settings
client.auth.configure_sso({
    "provider": "azure_ad",
    "domain": "yourcompany.com",
    "client_id": "your_azure_client_id",
    "tenant_id": "your_azure_tenant_id",
    "auto_provision": True,
    "default_role": "user",
    "group_mappings": {
        "ai-team": "admin",
        "data-scientists": "user"
    }
})

# Test SSO configuration
test_result = client.auth.test_sso_config()
print(f"SSO Test: {test_result.status}")

# Configure auto-scaling for a deployment
scaling_config = {
    "min_instances": 1,
    "max_instances": 10,
    "target_metrics": {
        "gpu_utilization": 70,
        "queue_depth": 5,
        "response_time": "2s"
    },
    "scale_up_policy": {
        "cooldown": "2m",
        "step_size": 2
    },
    "scale_down_policy": {
        "cooldown": "5m", 
        "step_size": 1
    }
}

client.instances.configure_autoscaling("my-deployment", scaling_config)

# Monitor scaling events
events = client.instances.get_scaling_events("my-deployment")
for event in events:
    print(f"{event.timestamp}: {event.action} - {event.reason}")

# ZeroCore notebook with AICortex integration
import aicortex.zerocore as zc

# Access data streams directly in notebook
data = zc.load_stream("training-data-stream")
print(f"Loaded {len(data)} samples")

# Use pre-trained models
model = zc.load_model("resnet50-imagenet")
predictions = model.predict(data[:10])

# Visualize results with automatic plotting
zc.plot.confusion_matrix(predictions, labels)
zc.plot.feature_importance(model, data.columns)

# Save work to Model Hub
zc.save_notebook("image-classifier-experiment-v1")

# Deploy directly from notebook
deployment = zc.deploy_model(
    model=model,
    name="notebook-classifier",
    instance_type="gpu.small"
)

print(f"Model deployed: {deployment.endpoint_url}")

# Create API endpoint from notebook function
@zc.api_endpoint(
    method="POST",
    path="/predict-sentiment",
    description="Analyze sentiment of input text"
)
def analyze_sentiment(text: str) -> dict:
    """Analyze sentiment using pre-trained model"""
    model = zc.load_model("sentiment-analyzer")
    
    result = model.predict(text)
    
    return {
        "text": text,
        "sentiment": result.label,
        "confidence": result.confidence,
        "timestamp": datetime.now().isoformat()
    }

# Publish endpoint
endpoint = zc.publish_endpoint("analyze_sentiment")
print(f"API URL: {endpoint.url}")

# Test endpoint
response = requests.post(endpoint.url, json={"text": "I love this product!"})
print(response.json())

# Monitor endpoint usage
metrics = zc.get_endpoint_metrics("analyze_sentiment")
print(f"Requests today: {metrics.requests_count}")
print(f"Average latency: {metrics.avg_latency}ms")

# Search models by category and requirements
models = client.model_hub.search(
    categories=["computer_vision"],
    tasks=["image_classification"],
    frameworks=["pytorch"],
    max_parameters=100_000_000,  # Under 100M parameters
    min_accuracy=0.85,
    license="commercial"
)

for model in models:
    print(f"{model.name} - {model.accuracy:.2%} accuracy")
    print(f"  Parameters: {model.parameters:,}")
    print(f"  Framework: {model.framework}")
    print(f"  License: {model.license}")

# Get model details
model_info = client.model_hub.get("resnet50-imagenet")
print(f"Description: {model_info.description}")
print(f"Input shape: {model_info.input_shape}")
print(f"Classes: {len(model_info.classes)}")

# Check model benchmarks
benchmarks = client.model_hub.get_benchmarks("resnet50-imagenet")
for benchmark in benchmarks:
    print(f"Dataset: {benchmark.dataset}")
    print(f"Accuracy: {benchmark.accuracy:.2%}")
    print(f"Inference time: {benchmark.inference_time}ms")

# Create new model version
new_version = client.model_hub.create_version(
    model_id="custom-classifier",
    version="2.0.0",
    model_files={"model.bin": "updated_model.bin"},
    changelog="Improved accuracy by 3% with additional training data",
    tags=["production", "improved"]
)

# List all versions
versions = client.model_hub.list_versions("custom-classifier")
for version in versions:
    print(f"v{version.version} - {version.created_at} - {version.status}")

# Deploy specific version
deployment = client.models.deploy(
    model_id="custom-classifier:1.5.0",  # Deploy specific version
    name="classifier-stable"
)

# A/B test between versions
client.deployments.setup_ab_test(
    name="classifier-ab-test",
    variants={
        "version_1": {"model": "custom-classifier:1.5.0", "traffic": 50},
        "version_2": {"model": "custom-classifier:2.0.0", "traffic": 50}
    },
    metrics=["accuracy", "latency", "user_satisfaction"]
)

# Monitor A/B test results
ab_results = client.deployments.get_ab_results("classifier-ab-test")
print(f"Version 1 accuracy: {ab_results.variants['version_1'].accuracy:.2%}")
print(f"Version 2 accuracy: {ab_results.variants['version_2'].accuracy:.2%}")

# Configure distributed training job
training_job = client.cortexflow.create_training_job({
    "name": "large-model-training",
    "model_config": {
        "architecture": "transformer",
        "layers": 24,
        "hidden_size": 1024,
        "attention_heads": 16,
        "vocab_size": 50000
    },
    "data_config": {
        "training_data": "s3://my-bucket/training-data/",
        "validation_data": "s3://my-bucket/validation-data/",
        "batch_size": 32,
        "sequence_length": 512
    },
    "distributed_config": {
        "strategy": "data_parallel",  # or "model_parallel", "pipeline_parallel"
        "num_nodes": 4,
        "gpus_per_node": 8,
        "communication_backend": "nccl"
    },
    "training_config": {
        "optimizer": "adamw",
        "learning_rate": 1e-4,
        "warmup_steps": 1000,
        "max_steps": 100000,
        "gradient_accumulation_steps": 4,
        "mixed_precision": True
    }
})

print(f"Training job created: {training_job.id}")

# Monitor distributed training
while training_job.status == "running":
    metrics = training_job.get_metrics()
    print(f"Step {metrics.step}: Loss={metrics.loss:.4f}")
    print(f"  GPU Utilization: {metrics.gpu_utilization:.1f}%")
    print(f"  Throughput: {metrics.samples_per_second:.1f} samples/sec")
    time.sleep(60)

# Set up real-time monitoring
monitor = client.cortexflow.create_monitor({
    "training_job_id": "job_123",
    "metrics": [
        "loss", "accuracy", "learning_rate", "gradient_norm",
        "gpu_utilization", "memory_usage", "throughput"
    ],
    "alerts": [
        {
            "metric": "loss",
            "condition": "not_decreasing",
            "threshold": 10,  # 10 epochs without improvement
            "action": "email"
        },
        {
            "metric": "gpu_utilization", 
            "condition": "below",
            "threshold": 0.7,  # GPU utilization below 70%
            "action": "slack"
        }
    ]
})

# Get real-time metrics
metrics_stream = client.cortexflow.stream_metrics("job_123")
for metric_update in metrics_stream:
    print(f"Step {metric_update.step}:")
    print(f"  Loss: {metric_update.loss:.4f}")
    print(f"  Accuracy: {metric_update.accuracy:.2%}")
    print(f"  GPU: {metric_update.gpu_utilization:.1f}%")
    
    # Custom logic based on metrics
    if metric_update.loss > 10.0:
        print("  ⚠️  High loss detected!")
        client.cortexflow.pause_training("job_123")
        break

# Query logs with advanced filtering
logs = client.cortexlogs.query({
    "time_range": {
        "start": "2024-01-20T00:00:00Z",
        "end": "2024-01-20T23:59:59Z"
    },
    "services": ["cortexflow", "model_hub", "instances"],
    "log_levels": ["ERROR", "WARN"],
    "search_query": "GPU memory",
    "filters": {
        "user_id": "user_123",
        "deployment_name": "production-classifier",
        "instance_type": "gpu.medium"
    },
    "limit": 1000,
    "sort": "timestamp_desc"
})

for log in logs:
    print(f"[{log.timestamp}] {log.service}.{log.level}: {log.message}")
    if log.metadata:
        print(f"  Metadata: {log.metadata}")

# Search specific error patterns
error_logs = client.cortexlogs.search(
    query="ERROR AND (timeout OR connection)",
    time_range="last_24h",
    group_by="service"
)

for service, errors in error_logs.items():
    print(f"{service}: {len(errors)} errors")
    
# Get log statistics
stats = client.cortexlogs.get_statistics(
    time_range="last_week",
    group_by=["service", "log_level"]
)

print("Log volume by service:")
for service, data in stats.items():
    print(f"  {service}: {data.total_logs} logs, {data.error_rate:.1%} error rate")

# Configure comprehensive alerting
alert_rules = [
    {
        "name": "High Error Rate",
        "description": "Alert when error rate exceeds threshold",
        "query": "level:ERROR",
        "condition": {
            "type": "threshold",
            "operator": "greater_than",
            "value": 50,  # 50 errors
            "time_window": "5m",
            "evaluation_interval": "1m"
        },
        "notifications": [
            {
                "type": "email",
                "recipients": ["admin@company.com", "oncall@company.com"]
            },
            {
                "type": "slack",
                "channel": "#ai-alerts",
                "mention": "@channel"
            }
        ],
        "severity": "critical"
    },
    {
        "name": "GPU Utilization Low",
        "description": "Alert when GPU utilization is consistently low",
        "query": "metric:gpu_utilization",
        "condition": {
            "type": "threshold",
            "operator": "less_than",
            "value": 30,  # 30% utilization
            "time_window": "15m",
            "evaluation_interval": "5m"
        },
        "notifications": [
            {
                "type": "webhook",
                "url": "https://hooks.company.com/cost-optimization",
                "headers": {"Authorization": "Bearer token"}
            }
        ],
        "severity": "warning"
    },
    {
        "name": "Training Job Stalled",
        "description": "Alert when training loss stops decreasing",
        "query": "service:cortexflow AND event:training_metrics",
        "condition": {
            "type": "anomaly",
            "metric": "training_loss",
            "algorithm": "isolation_forest",
            "sensitivity": "medium",
            "time_window": "30m"
        },
        "notifications": [
            {
                "type": "pagerduty",
                "integration_key": "your_pagerduty_key",
                "severity": "error"
            }
        ],
        "severity": "high"
    }
]

# Create alert rules
for rule in alert_rules:
    alert = client.cortexlogs.create_alert_rule(rule)
    print(f"Alert rule created: {alert.id}")

# Test alert rule
test_result = client.cortexlogs.test_alert_rule(alert.id)
print(f"Alert test: {test_result.status}")
if test_result.would_trigger:
    print(f"Alert would trigger with current data")

# Get alert history
alert_history = client.cortexlogs.get_alert_history(
    time_range="last_week",
    severity=["critical", "high"]
)

for alert_event in alert_history:
    print(f"[{alert_event.timestamp}] {alert_event.rule_name}")
    print(f"  Status: {alert_event.status}")
    print(f"  Duration: {alert_event.duration}")

# Get detailed cost analytics
cost_analysis = client.cortexlogs.get_cost_analytics({
    "time_range": "last_month",
    "group_by": ["service", "instance_type", "user"],
    "include_recommendations": True
})

print("Cost breakdown by service:")
for service, cost_data in cost_analysis.by_service.items():
    print(f"  {service}: ${cost_data.total:.2f}")
    print(f"    GPU hours: {cost_data.gpu_hours:.1f}")
    print(f"    Storage: ${cost_data.storage_cost:.2f}")
    print(f"    API calls: {cost_data.api_calls:,}")

print("\nTop cost drivers:")
for driver in cost_analysis.top_drivers:
    print(f"  {driver.resource}: ${driver.cost:.2f} ({driver.percentage:.1f}%)")

print("\nOptimization recommendations:")
for rec in cost_analysis.recommendations:
    print(f"  💡 {rec.title}")
    print(f"     {rec.description}")
    print(f"     Potential savings: ${rec.estimated_savings:.2f}/month")
    
    if rec.type == "right_sizing":
        print(f"     Suggested instance: {rec.suggested_instance_type}")
    elif rec.type == "auto_scaling":
        print(f"     Suggested config: {rec.scaling_config}")

# Set up cost alerts
cost_alert = client.cortexlogs.create_cost_alert({
    "name": "Monthly Budget Alert",
    "budget": 5000,  # $5000/month
    "alert_thresholds": [50, 80, 90, 100],  # Alert at 50%, 80%, 90%, 100%
    "scope": {
        "services": ["cortexflow", "model_hub"],
        "users": ["team:data-science"]
    },
    "notifications": [
        {"type": "email", "recipients": ["finance@company.com"]},
        {"type": "slack", "channel": "#budget-alerts"}
    ]
})

# Get real-time cost tracking
current_spend = client.cortexlogs.get_current_spend()
print(f"Current month spend: ${current_spend.total:.2f}")
print(f"Projected month-end: ${current_spend.projected:.2f}")
print(f"Budget utilization: {current_spend.budget_utilization:.1%}")

{
  "auto_scaling": {
    "min_instances": 1,
    "max_instances": 20,
    "target_utilization": 70,
    "scale_up_cooldown": "2m",
    "scale_down_cooldown": "5m",
    "metrics": {
      "cpu_utilization": {
        "target": 70,
        "weight": 0.3
      },
      "memory_utilization": {
        "target": 80,
        "weight": 0.2
      },
      "request_rate": {
        "target": 100,
        "weight": 0.5
      }
    }
  }
}

{
  "health_check": {
    "enabled": true,
    "endpoint": "/health",
    "interval": "30s",
    "timeout": "10s",
    "unhealthy_threshold": 3,
    "healthy_threshold": 2
  },
  "monitoring": {
    "metrics_enabled": true,
    "log_level": "INFO",
    "alerts": {
      "high_error_rate": {
        "threshold": 5,
        "window": "5m"
      },
      "high_latency": {
        "threshold": "2s",
        "window": "5m"
      }
    }
  }
}

# Deploy new version (green)
new_deployment = client.models.deploy(
    model_id="my-model:v2.0",
    name="my-model-green",
    config={"instance_type": "gpu.medium"}
)

# Wait for deployment to be ready
new_deployment.wait_until_ready()

# Test the new deployment
test_result = client.models.predict(
    deployment_name="my-model-green",
    inputs=test_data
)

# If tests pass, switch traffic
client.deployments.switch_traffic(
    from_deployment="my-model-blue",
    to_deployment="my-model-green",
    percentage=100
)

# Clean up old deployment
client.deployments.delete("my-model-blue")

# Deploy canary version
canary_deployment = client.models.deploy(
    model_id="my-model:v2.0",
    name="my-model-canary",
    config={"instance_type": "gpu.medium"}
)

# Route 10% of traffic to canary
client.deployments.set_traffic_split({
    "my-model-production": 90,
    "my-model-canary": 10
})

# Monitor metrics and gradually increase
import time
time.sleep(300)  # Wait 5 minutes

# If metrics look good, increase to 50%
client.deployments.set_traffic_split({
    "my-model-production": 50,
    "my-model-canary": 50
})

# Eventually promote canary to production
client.deployments.promote_canary("my-model-canary")

# S3 batch processing with automatic triggering
s3_config = {
    "bucket": "ml-training-data",
    "prefix": "datasets/images/",
    "trigger": {
        "type": "s3_event",  # Trigger on new files
        "events": ["s3:ObjectCreated:*"]
    },
    "processing": {
        "batch_size": 1000,
        "format": "pytorch_dataset",
        "transformations": [
            {"type": "resize", "params": {"size": [224, 224]}},
            {"type": "normalize", "params": {"mean": [0.485, 0.456, 0.406]}},
            {"type": "augment", "params": {"rotation": 15, "flip": True}}
        ]
    }
}

# Create data pipeline
pipeline = client.data_streams.create_pipeline({
    "name": "image-training-pipeline",
    "source": {"type": "s3", "config": s3_config},
    "destination": {"type": "cortexflow", "target": "training_job_123"},
    "schedule": "0 2 * * *",  # Daily at 2 AM
    "validation": {
        "schema": "image_dataset_schema",
        "quality_checks": ["format", "size", "corruption"]
    }
})

# Monitor pipeline execution
status = client.data_streams.get_pipeline_status(pipeline.id)
print(f"Pipeline status: {status.state}")
print(f"Last run: {status.last_execution}")
print(f"Files processed: {status.files_processed}")

# Kafka streaming for real-time inference
kafka_config = {
    "bootstrap_servers": ["kafka1:9092", "kafka2:9092"],
    "topics": ["user_events", "sensor_data"],
    "consumer_group": "aicortex_inference",
    "processing": {
        "batch_size": 100,
        "max_latency": "1s",
        "format": "json",
        "schema_registry": "http://schema-registry:8081"
    },
    "security": {
        "protocol": "SASL_SSL",
        "mechanism": "PLAIN",
        "username": "kafka_user",
        "password": "kafka_password"
    }
}

# Create streaming pipeline
stream = client.data_streams.create_stream({
    "name": "real-time-inference-stream",
    "source": {"type": "kafka", "config": kafka_config},
    "processors": [
        {
            "type": "filter",
            "config": {"condition": "event_type == 'prediction_request'"}
        },
        {
            "type": "enrich",
            "config": {"user_lookup": "user_service_api"}
        },
        {
            "type": "predict",
            "config": {"deployment": "real-time-classifier"}
        }
    ],
    "output": {
        "type": "kafka",
        "topic": "prediction_results",
        "format": "avro"
    }
})

# Start stream processing
client.data_streams.start_stream(stream.id)
print(f"Stream {stream.name} started")

# Monitor stream health
metrics = client.data_streams.get_stream_metrics(stream.id)
print(f"Messages/sec: {metrics.throughput}")
print(f"Latency p99: {metrics.latency_p99}ms")
print(f"Error rate: {metrics.error_rate:.2%}")

# Comprehensive data quality framework
data_quality_config = {
    "schema_validation": {
        "enforce_schema": True,
        "schema_file": "data_schema.json",
        "allow_missing_columns": False,
        "allow_extra_columns": True
    },
    "quality_checks": [
        {
            "type": "completeness",
            "columns": ["user_id", "timestamp", "event_type"],
            "threshold": 0.95  # 95% completeness required
        },
        {
            "type": "uniqueness",
            "columns": ["user_id", "timestamp"],
            "threshold": 1.0   # Must be unique
        },
        {
            "type": "range",
            "column": "age",
            "min": 13,
            "max": 120
        },
        {
            "type": "pattern",
            "column": "email",
            "pattern": r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
        },
        {
            "type": "distribution",
            "column": "revenue",
            "check": "no_outliers",
            "method": "iqr",
            "threshold": 3.0
        }
    ],
    "anomaly_detection": {
        "enabled": True,
        "methods": ["isolation_forest", "local_outlier_factor"],
        "contamination": 0.1,
        "features": ["numerical_columns"]
    },
    "drift_detection": {
        "enabled": True,
        "reference_period": "last_week",
        "methods": ["ks_test", "chi2_test"],
        "threshold": 0.05
    }
}

# Apply quality checks to data pipeline
quality_pipeline = client.data_streams.create_quality_pipeline({
    "name": "user-data-quality",
    "source": "user-events-stream",
    "config": data_quality_config,
    "actions": {
        "on_failure": ["quarantine", "alert"],
        "on_anomaly": ["flag", "notify"],
        "on_drift": ["retrain_trigger", "alert"]
    },
    "notifications": {
        "email": ["data-team@company.com"],
        "slack": "#data-quality-alerts",
        "webhook": "https://monitoring.company.com/webhooks/data-quality"
    }
})

# Monitor data quality metrics
quality_report = client.data_streams.get_quality_report(
    pipeline_id=quality_pipeline.id,
    time_range="last_24h"
)

print("Data Quality Report:")
print(f"Overall score: {quality_report.overall_score:.2%}")
print(f"Records processed: {quality_report.records_processed:,}")
print(f"Records failed: {quality_report.records_failed:,}")
print(f"Quality issues detected: {len(quality_report.issues)}")

for issue in quality_report.issues:
    print(f"  - {issue.type}: {issue.description}")
    print(f"    Affected records: {issue.affected_count}")
    print(f"    Severity: {issue.severity}")

# Set up automated remediation
remediation_rules = [
    {
        "condition": "completeness < 0.9",
        "action": "backfill_missing_data",
        "config": {"method": "forward_fill", "max_gap": 5}
    },
    {
        "condition": "drift_detected == True",
        "action": "trigger_retraining",
        "config": {"model": "user-classifier", "priority": "high"}
    },
    {
        "condition": "anomaly_rate > 0.05",
        "action": "quarantine_data",
        "config": {"quarantine_bucket": "s3://quarantine-data/"}
    }
]

client.data_streams.configure_auto_remediation(
    pipeline_id=quality_pipeline.id,
    rules=remediation_rules
)

print("Auto-remediation rules configured")

# Set up comprehensive model monitoring
model_monitor = client.cortexlogs.create_model_monitor({
    "deployment_name": "production-classifier",
    "monitoring_config": {
        "performance_tracking": {
            "enabled": True,
            "metrics": ["accuracy", "precision", "recall", "f1_score"],
            "ground_truth_source": "s3://labels/production-labels/",
            "evaluation_frequency": "daily",
            "min_samples": 1000
        },
        "drift_detection": {
            "enabled": True,
            "input_drift": {
                "method": "ks_test",
                "threshold": 0.05,
                "features": "all"
            },
            "output_drift": {
                "method": "psi",  # Population Stability Index
                "threshold": 0.1,
                "bins": 10
            },
            "concept_drift": {
                "method": "ddm",  # Drift Detection Method
                "warning_threshold": 2.0,
                "drift_threshold": 3.0
            }
        },
        "bias_monitoring": {
            "enabled": True,
            "protected_attributes": ["gender", "age_group", "ethnicity"],
            "fairness_metrics": ["demographic_parity", "equalized_odds"],
            "threshold": 0.1
        },
        "explainability": {
            "enabled": True,
            "method": "shap",
            "sample_rate": 0.1,  # Explain 10% of predictions
            "features_to_track": ["top_10"]
        }
    },
    "alerting": {
        "accuracy_drop": {
            "threshold": 0.05,  # 5% drop
            "severity": "critical"
        },
        "drift_detected": {
            "severity": "warning"
        },
        "bias_detected": {
            "severity": "high"
        }
    }
})

# Track model performance over time
performance_metrics = client.cortexlogs.get_model_performance(
    deployment_name="production-classifier",
    time_range="last_30_days",
    group_by="day"
)

print("Model Performance Trend:")
for day_metric in performance_metrics:
    print(f"Date: {day_metric.date}")
    print(f"  Accuracy: {day_metric.accuracy:.3f}")
    print(f"  Drift Score: {day_metric.drift_score:.3f}")
    print(f"  Prediction Volume: {day_metric.prediction_count:,}")

# Generate model performance report
report = client.cortexlogs.generate_model_report({
    "deployment_name": "production-classifier",
    "time_range": "last_week",
    "include_sections": [
        "performance_summary",
        "drift_analysis", 
        "bias_assessment",
        "feature_importance",
        "error_analysis"
    ],
    "format": "pdf",
    "recipients": ["ml-team@company.com"]
})

print(f"Model report generated: {report.download_url}")

# Business impact monitoring
business_monitor = client.cortexlogs.create_business_monitor({
    "name": "ai-business-impact",
    "metrics": {
        "revenue_impact": {
            "source": "analytics_db",
            "query": """
                SELECT 
                    DATE(timestamp) as date,
                    SUM(CASE WHEN ai_prediction_used = true THEN revenue ELSE 0 END) as ai_assisted_revenue,
                    SUM(revenue) as total_revenue
                FROM sales_transactions 
                WHERE timestamp >= CURRENT_DATE - INTERVAL '30 days'
                GROUP BY DATE(timestamp)
            """,
            "target": "increase_by_15_percent"
        },
        "customer_satisfaction": {
            "source": "support_system",
            "metric": "csat_score",
            "filter": "ai_interaction = true",
            "target": "> 4.5"
        },
        "operational_efficiency": {
            "metrics": [
                {"name": "processing_time", "target": "< 30s"},
                {"name": "manual_review_rate", "target": "< 10%"},
                {"name": "automation_rate", "target": "> 80%"}
            ]
        },
        "model_adoption": {
            "metrics": [
                {"name": "daily_active_users", "target": "growth > 5%"},
                {"name": "api_usage", "target": "growth > 10%"},
                {"name": "feature_adoption", "target": "> 60%"}
            ]
        }
    },
    "reporting": {
        "frequency": "weekly",
        "recipients": ["executives@company.com", "product@company.com"],
        "format": "executive_summary",
        "include_roi_analysis": True
    }
})

# Generate business impact report
business_report = client.cortexlogs.generate_business_report({
    "time_range": "last_quarter",
    "include_sections": [
        "executive_summary",
        "revenue_impact",
        "cost_savings",
        "efficiency_gains",
        "user_adoption",
        "roi_analysis",
        "recommendations"
    ],
    "benchmark_against": "previous_quarter"
})

print("Business Impact Summary:")
print(f"Revenue Impact: ${business_report.revenue_impact:.2f}")
print(f"Cost Savings: ${business_report.cost_savings:.2f}")
print(f"ROI: {business_report.roi:.1%}")
print(f"Efficiency Improvement: {business_report.efficiency_gain:.1%}")

# A/B testing for model impact
ab_test = client.cortexlogs.create_ab_test({
    "name": "recommendation_model_v2",
    "hypothesis": "New model improves click-through rate by 15%",
    "variants": {
        "control": {
            "model": "recommendation_v1",
            "traffic_percentage": 50
        },
        "treatment": {
            "model": "recommendation_v2", 
            "traffic_percentage": 50
        }
    },
    "success_metrics": [
        {"name": "click_through_rate", "target": "increase"},
        {"name": "conversion_rate", "target": "increase"},
        {"name": "revenue_per_user", "target": "increase"}
    ],
    "duration": "14_days",
    "min_sample_size": 10000,
    "statistical_power": 0.8
})

# Monitor A/B test results
ab_results = client.cortexlogs.get_ab_test_results(ab_test.id)
if ab_results.is_significant:
    print(f"A/B Test Results (Significant):")
    print(f"  Control CTR: {ab_results.control.click_through_rate:.2%}")
    print(f"  Treatment CTR: {ab_results.treatment.click_through_rate:.2%}")
    print(f"  Improvement: {ab_results.improvement:.1%}")
    print(f"  Confidence: {ab_results.confidence:.1%}")
    
    if ab_results.recommendation == "deploy_treatment":
        print("✅ Recommendation: Deploy new model to production")
else:
    print(f"A/B Test ongoing... Current sample size: {ab_results.sample_size}")

# Best practices for model training
class ModelTrainingBestPractices:
    
    def __init__(self, client):
        self.client = client
    
    def setup_experiment_tracking(self, experiment_name):
        """Set up comprehensive experiment tracking"""
        experiment = self.client.cortexflow.create_experiment({
            "name": experiment_name,
            "description": "Production model training with best practices",
            "tags": ["production", "v2.0", "baseline"],
            "metadata": {
                "dataset_version": "v1.2.3",
                "feature_set": "core_features_v1",
                "objective": "improve_accuracy_by_5_percent"
            }
        })
        
        # Track hyperparameters
        experiment.log_params({
            "learning_rate": 0.001,
            "batch_size": 32,
            "architecture": "resnet50",
            "optimizer": "adamw",
            "scheduler": "cosine_annealing"
        })
        
        return experiment
    
    def validate_data_quality(self, dataset_path):
        """Validate data before training"""
        validation_results = self.client.data_streams.validate_dataset({
            "dataset_path": dataset_path,
            "checks": [
                "completeness",
                "uniqueness", 
                "consistency",
                "distribution_drift",
                "label_balance"
            ],
            "reference_dataset": "production_baseline"
        })
        
        if not validation_results.passed:
            raise ValueError(f"Data validation failed: {validation_results.errors}")
        
        return validation_results
    
    def configure_training_with_best_practices(self, model_config):
        """Configure training job with recommended settings"""
        training_config = {
            "model_config": model_config,
            "training_settings": {
                # Reproducibility
                "random_seed": 42,
                "deterministic": True,
                
                # Optimization
                "mixed_precision": True,
                "gradient_clipping": 1.0,
                "weight_decay": 0.01,
                
                # Regularization
                "dropout": 0.1,
                "label_smoothing": 0.1,
                "data_augmentation": {
                    "enabled": True,
                    "strategy": "auto_augment"
                },
                
                # Early stopping
                "early_stopping": {
                    "patience": 10,
                    "min_delta": 0.001,
                    "restore_best_weights": True
                },
                
                # Checkpointing
                "checkpointing": {
                    "save_frequency": "epoch",
                    "keep_top_k": 3,
                    "metric": "val_accuracy"
                }
            },
            "validation": {
                "validation_split": 0.2,
                "cross_validation": {
                    "enabled": True,
                    "folds": 5,
                    "stratified": True
                }
            },
            "monitoring": {
                "log_frequency": 100,  # Every 100 steps
                "metrics": ["loss", "accuracy", "learning_rate", "gradient_norm"],
                "visualizations": ["confusion_matrix", "learning_curves"]
            }
        }
        
        return training_config
    
    def train_with_hyperparameter_optimization(self, base_config):
        """Train model with systematic hyperparameter optimization"""
        
        # Define search space based on best practices
        search_space = {
            "learning_rate": {
                "type": "log_uniform",
                "min": 1e-5,
                "max": 1e-2,
                "recommended_range": [1e-4, 1e-3]
            },
            "batch_size": {
                "type": "categorical",
                "choices": [16, 32, 64, 128],
                "recommended": 32
            },
            "optimizer": {
                "type": "categorical",
                "choices": ["adam", "adamw", "sgd"],
                "recommended": "adamw"
            },
            "weight_decay": {
                "type": "uniform",
                "min": 0.0,
                "max": 0.1,
                "recommended_range": [0.01, 0.05]
            }
        }
        
        # Use Bayesian optimization for efficient search
        hpo_job = self.client.cortexflow.create_hpo_job({
            "base_config": base_config,
            "search_space": search_space,
            "optimization_method": "bayesian",
            "objective": {
                "metric": "val_accuracy",
                "direction": "maximize"
            },
            "budget": {
                "max_trials": 30,
                "max_runtime": "12h",
                "early_stopping": {
                    "enabled": True,
                    "patience": 5
                }
            },
            "resource_allocation": {
                "parallel_trials": 4,
                "instance_type": "gpu.medium"
            }
        })
        
        return hpo_job
    
    def implement_model_validation(self, model_id):
        """Comprehensive model validation before deployment"""
        
        validation_suite = {
            "performance_tests": [
                {
                    "name": "accuracy_test",
                    "test_set": "holdout_test_set",
                    "min_accuracy": 0.85
                },
                {
                    "name": "robustness_test",
                    "test_set": "adversarial_examples",
                    "max_accuracy_drop": 0.1
                }
            ],
            "bias_tests": [
                {
                    "name": "demographic_parity",
                    "protected_attributes": ["gender", "age"],
                    "max_bias": 0.1
                },
                {
                    "name": "equalized_odds",
                    "protected_attributes": ["ethnicity"],
                    "max_bias": 0.15
                }
            ],
            "inference_tests": [
                {
                    "name": "latency_test",
                    "max_latency": "100ms",
                    "percentile": 95
                },
                {
                    "name": "throughput_test",
                    "min_throughput": "1000_requests_per_second"
                }
            ]
        }
        
        validation_results = self.client.models.validate({
            "model_id": model_id,
            "validation_suite": validation_suite,
            "generate_report": True
        })
        
        return validation_results

# Usage example
trainer = ModelTrainingBestPractices(client)

# 1. Set up experiment tracking
experiment = trainer.setup_experiment_tracking("production_classifier_v2")

# 2. Validate data quality
trainer.validate_data_quality("s3://training-data/v1.2.3/")

# 3. Configure training with best practices
model_config = {"architecture": "efficientnet_b3", "num_classes": 10}
training_config = trainer.configure_training_with_best_practices(model_config)

# 4. Run hyperparameter optimization
hpo_job = trainer.train_with_hyperparameter_optimization(training_config)

# 5. Validate best model
best_model = hpo_job.get_best_model()
validation_results = trainer.implement_model_validation(best_model.id)

if validation_results.passed:
    print("✅ Model ready for deployment")
else:
    print("❌ Model failed validation:", validation_results.issues)

# Production deployment best practices
class ProductionDeploymentBestPractices:
    
    def __init__(self, client):
        self.client = client
    
    def implement_blue_green_deployment(self, model_id, production_deployment):
        """Implement blue-green deployment pattern"""
        
        # Step 1: Deploy green version
        green_deployment = self.client.models.deploy({
            "model_id": model_id,
            "name": f"{production_deployment}-green",
            "config": {
                "instance_type": "gpu.medium",
                "auto_scaling": {
                    "min_instances": 1,
                    "max_instances": 5
                },
                "health_check": {
                    "enabled": True,
                    "endpoint": "/health",
                    "interval": "30s"
                }
            }
        })
        
        # Step 2: Wait for green to be ready
        green_deployment.wait_until_ready(timeout=600)
        
        # Step 3: Run smoke tests on green
        smoke_test_results = self.run_smoke_tests(green_deployment.name)
        
        if not smoke_test_results.passed:
            self.client.deployments.delete(green_deployment.id)
            raise Exception(f"Smoke tests failed: {smoke_test_results.errors}")
        
        # Step 4: Run load tests
        load_test_results = self.run_load_tests(green_deployment.name)
        
        if not load_test_results.passed:
            self.client.deployments.delete(green_deployment.id) 
            raise Exception(f"Load tests failed: {load_test_results.errors}")
        
        # Step 5: Gradually shift traffic
        self.gradual_traffic_shift(production_deployment, green_deployment.name)
        
        # Step 6: Monitor for issues
        monitoring_results = self.monitor_deployment_health(
            green_deployment.name, 
            duration="30m"
        )
        
        if monitoring_results.healthy:
            # Step 7: Complete cutover
            self.client.deployments.set_traffic_split({
                green_deployment.name: 100,
                production_deployment: 0
            })
            
            # Step 8: Clean up blue deployment
            self.client.deployments.delete(production_deployment)
            
            # Step 9: Rename green to production
            self.client.deployments.rename(
                green_deployment.id, 
                production_deployment
            )
            
            return green_deployment
        else:
            # Rollback on issues
            self.rollback_deployment(production_deployment, green_deployment.name)
            raise Exception("Deployment health check failed, rolled back")
    
    def implement_canary_deployment(self, model_id, production_deployment):
        """Implement canary deployment with gradual rollout"""
        
        # Deploy canary version
        canary_deployment = self.client.models.deploy({
            "model_id": model_id,
            "name": f"{production_deployment}-canary",
            "config": {
                "instance_type": "gpu.small",  # Start small
                "auto_scaling": {"min_instances": 1, "max_instances": 2}
            }
        })
        
        canary_deployment.wait_until_ready()
        
        # Canary rollout phases
        rollout_phases = [
            {"traffic_percent": 1, "duration": "10m", "success_criteria": {"error_rate": 0.01}},
            {"traffic_percent": 5, "duration": "20m", "success_criteria": {"error_rate": 0.005}},
            {"traffic_percent": 25, "duration": "30m", "success_criteria": {"latency_p95": "200ms"}},
            {"traffic_percent": 50, "duration": "1h", "success_criteria": {"accuracy": 0.85}},
            {"traffic_percent": 100, "duration": "ongoing", "success_criteria": {}}
        ]
        
        for phase in rollout_phases:
            print(f"Starting canary phase: {phase['traffic_percent']}% traffic")
            
            # Set traffic split
            self.client.deployments.set_traffic_split({
                production_deployment: 100 - phase["traffic_percent"],
                canary_deployment.name: phase["traffic_percent"]
            })
            
            # Monitor phase
            phase_results = self.monitor_canary_phase(
                canary_deployment.name,
                duration=phase["duration"],
                success_criteria=phase["success_criteria"]
            )
            
            if not phase_results.success:
                print(f"Canary phase failed: {phase_results.issues}")
                self.rollback_canary(production_deployment, canary_deployment.name)
                return False
            
            print(f"Canary phase {phase['traffic_percent']}% completed successfully")
        
        # Promote canary to production
        self.promote_canary_to_production(production_deployment, canary_deployment.name)
        return True
    
    def run_smoke_tests(self, deployment_name):
        """Run comprehensive smoke tests"""
        
        test_cases = [
            {
                "name": "health_check",
                "endpoint": "/health",
                "expected_status": 200
            },
            {
                "name": "prediction_test",
                "endpoint": "/predict",
                "input": {"text": "test input"},
                "expected_format": "prediction_response"
            },
            {
                "name": "batch_prediction_test",
                "endpoint": "/predict/batch",
                "input": [{"text": f"test {i}"} for i in range(10)],
                "expected_count": 10
            },
            {
                "name": "error_handling_test",
                "endpoint": "/predict",
                "input": {"invalid": "data"},
                "expected_status": 400
            }
        ]
        
        results = []
        for test in test_cases:
            try:
                result = self.client.deployments.test_endpoint(
                    deployment_name=deployment_name,
                    test_case=test
                )
                results.append({"test": test["name"], "passed": result.success})
            except Exception as e:
                results.append({"test": test["name"], "passed": False, "error": str(e)})
        
        passed = all(r["passed"] for r in results)
        return type('SmokeTestResults', (), {
            "passed": passed, 
            "results": results,
            "errors": [r.get("error") for r in results if not r["passed"]]
        })()
    
    def implement_feature_flags(self, deployment_name):
        """Implement feature flags for controlled rollouts"""
        
        feature_flags = {
            "new_model_enabled": {
                "description": "Enable new model version",
                "default_value": False,
                "rollout_strategy": {
                    "type": "percentage",
                    "initial_percentage": 0,
                    "target_percentage": 100,
                    "increment": 10,
                    "interval": "1h"
                },
                "targeting_rules": [
                    {
                        "condition": "user.tier == 'premium'",
                        "enabled": True
                    },
                    {
                        "condition": "user.beta_tester == True",
                        "enabled": True
                    }
                ]
            },
            "advanced_features": {
                "description": "Enable advanced model features",
                "default_value": False,
                "rollout_strategy": {
                    "type": "user_segments",
                    "segments": ["internal_users", "beta_testers", "premium_users"]
                }
            }
        }
        
        return self.client.deployments.configure_feature_flags({
            "deployment_name": deployment_name,
            "flags": feature_flags,
            "monitoring": {
                "track_usage": True,
                "track_performance": True,
                "alert_on_errors": True
            }
        })

    def setup_deployment_monitoring(self, deployment_name):
        """Set up comprehensive deployment monitoring"""
        
        monitoring_config = {
            "metrics": {
                "business_metrics": [
                    "prediction_accuracy",
                    "user_satisfaction", 
                    "conversion_rate",
                    "revenue_impact"
                ],
                "technical_metrics": [
                    "response_time",
                    "throughput",
                    "error_rate",
                    "cpu_utilization",
                    "memory_usage",
                    "gpu_utilization"
                ],
                "ml_metrics": [
                    "prediction_confidence",
                    "feature_drift",
                    "data_quality_score",
                    "model_staleness"
                ]
            },
            "alerts": [
                {
                    "name": "High Error Rate",
                    "condition": "error_rate > 0.01",
                    "severity": "critical",
                    "actions": ["auto_rollback", "page_oncall"]
                },
                {
                    "name": "Performance Degradation", 
                    "condition": "p95_latency > 500ms",
                    "severity": "warning",
                    "actions": ["scale_up", "notify_team"]
                },
                {
                    "name": "Accuracy Drop",
                    "condition": "accuracy < baseline - 0.05",
                    "severity": "high",
                    "actions": ["flag_for_review", "alert_ml_team"]
                }
            ],
            "dashboards": [
                {
                    "name": "Production Overview",
                    "widgets": ["error_rate", "latency", "throughput", "accuracy"]
                },
                {
                    "name": "Business Impact",
                    "widgets": ["conversion_rate", "revenue_impact", "user_satisfaction"]
                }
            ]
        }
        
        return self.client.cortexlogs.create_deployment_monitor({
            "deployment_name": deployment_name,
            "config": monitoring_config
        })

# Usage example
deployer = ProductionDeploymentBestPractices(client)

# Blue-green deployment
try:
    new_deployment = deployer.implement_blue_green_deployment(
        model_id="new_model_v2",
        production_deployment="production-classifier"
    )
    print("✅ Blue-green deployment completed successfully")
except Exception as e:
    print(f"❌ Deployment failed: {e}")

# Set up monitoring for new deployment
deployer.setup_deployment_monitoring(new_deployment.name)
print("✅ Monitoring configured")

# Data security best practices
class DataSecurityBestPractices:
    
    def __init__(self, client):
        self.client = client
    
    def implement_data_encryption(self):
        """Implement end-to-end data encryption"""
        
        encryption_config = {
            "data_at_rest": {
                "algorithm": "AES-256",
                "key_management": "customer_managed",
                "key_rotation": "automatic",
                "rotation_period": "90_days"
            },
            "data_in_transit": {
                "protocol": "TLS_1_3",
                "cipher_suites": ["TLS_AES_256_GCM_SHA384"],
                "certificate_validation": "strict"
            },
            "data_in_processing": {
                "memory_encryption": True,
                "secure_enclaves": True,
                "confidential_computing": True
            }
        }
        
        return self.client.security.configure_encryption(encryption_config)
    
    def setup_data_access_controls(self):
        """Configure fine-grained data access controls"""
        
        access_policies = {
            "data_classification": {
                "public": {"encryption": "optional", "access_logging": False},
                "internal": {"encryption": "required", "access_logging": True},
                "confidential": {"encryption": "required", "access_logging": True, "approval_required": True},
                "restricted": {"encryption": "required", "access_logging": True, "approval_required": True, "audit_trail": True}
            },
            "role_based_access": {
                "data_scientist": {
                    "permissions": ["read", "analyze"],
                    "data_types": ["public", "internal"],
                    "conditions": ["within_office_hours", "from_approved_locations"]
                },
                "ml_engineer": {
                    "permissions": ["read", "process", "deploy"],
                    "data_types": ["public", "internal", "confidential"],
                    "conditions": ["mfa_required"]
                },
                "admin": {
                    "permissions": ["all"],
                    "data_types": ["all"],
                    "conditions": ["dual_approval_required"]
                }
            },
            "data_lineage": {
                "track_access": True,
                "track_transformations": True,
                "track_sharing": True,
                "retention_period": "7_years"
            }
        }
        
        return self.client.security.configure_data_access(access_policies)
    
    def implement_privacy_protection(self):
        """Implement privacy protection measures"""
        
        privacy_config = {
            "data_minimization": {
                "collect_only_necessary": True,
                "auto_deletion": {
                    "enabled": True,
                    "retention_period": "2_years",
                    "deletion_method": "cryptographic_erasure"
                }
            },
            "anonymization": {
                "pii_detection": True,
                "automatic_masking": True,
                "techniques": ["k_anonymity", "differential_privacy"],
                "privacy_budget": 1.0
            },
            "consent_management": {
                "track_consent": True,
                "granular_permissions": True,
                "easy_withdrawal": True,
                "consent_proofs": True
            },
            "privacy_by_design": {
                "default_privacy_settings": "maximum",
                "purpose_limitation": True,
                "storage_limitation": True,
                "transparency": True
            }
        }
        
        return self.client.security.configure_privacy_protection(privacy_config)

# Usage
security = DataSecurityBestPractices(client)
security.implement_data_encryption()
security.setup_data_access_controls()
security.implement_privacy_protection()

# Model security best practices
class ModelSecurityBestPractices:
    
    def __init__(self, client):
        self.client = client
    
    def implement_model_protection(self, model_id):
        """Protect models from attacks and unauthorized access"""
        
        protection_config = {
            "adversarial_detection": {
                "enabled": True,
                "methods": ["statistical_distance", "feature_squeezing"],
                "threshold": 0.8,
                "action": "reject_and_log"
            },
            "input_validation": {
                "schema_validation": True,
                "range_checking": True,
                "format_validation": True,
                "sanitization": True
            },
            "output_filtering": {
                "confidence_threshold": 0.7,
                "bias_detection": True,
                "harmful_content_filter": True,
                "information_leakage_prevention": True
            },
            "model_watermarking": {
                "enabled": True,
                "technique": "digital_watermark",
                "verification_required": True
            }
        }
        
        return self.client.security.configure_model_protection({
            "model_id": model_id,
            "config": protection_config
        })
    
    def setup_model_integrity_monitoring(self, deployment_name):
        """Monitor model integrity and detect tampering"""
        
        integrity_config = {
            "model_verification": {
                "checksum_validation": True,
                "signature_verification": True,
                "hash_algorithm": "SHA-256"
            },
            "runtime_monitoring": {
                "behavior_analysis": True,
                "performance_baseline": True,
                "anomaly_detection": True,
                "drift_detection": True
            },
            "attack_detection": {
                "model_inversion": True,
                "membership_inference": True,
                "model_extraction": True,
                "backdoor_detection": True
            },
            "alerts": [
                {
                    "type": "integrity_violation",
                    "severity": "critical",
                    "action": "immediate_shutdown"
                },
                {
                    "type": "attack_detected",
                    "severity": "high", 
                    "action": "isolate_and_investigate"
                }
            ]
        }
        
        return self.client.security.configure_integrity_monitoring({
            "deployment_name": deployment_name,
            "config": integrity_config
        })
    
    def implement_secure_inference(self, deployment_name):
        """Implement secure inference practices"""
        
        secure_inference_config = {
            "request_authentication": {
                "api_key_required": True,
                "jwt_validation": True,
                "client_certificates": True
            },
            "rate_limiting": {
                "requests_per_minute": 1000,
                "burst_limit": 100,
                "per_user_limits": True
            },
            "request_logging": {
                "log_all_requests": True,
                "include_metadata": True,
                "exclude_sensitive_data": True,
                "retention_period": "1_year"
            },
            "response_security": {
                "strip_internal_info": True,
                "add_security_headers": True,
                "content_type_validation": True
            }
        }
        
        return self.client.security.configure_secure_inference({
            "deployment_name": deployment_name,
            "config": secure_inference_config
        })

# Usage
model_security = ModelSecurityBestPractices(client)
model_security.implement_model_protection("production_model")
model_security.setup_model_integrity_monitoring("production-classifier")
model_security.implement_secure_inference("production-classifier")

# Performance optimization best practices
class PerformanceOptimizationBestPractices:
    
    def __init__(self, client):
        self.client = client
    
    def optimize_model_for_inference(self, model_id):
        """Optimize model for production inference"""
        
        optimization_techniques = {
            "quantization": {
                "enabled": True,
                "precision": "int8",  # or "fp16", "int4"
                "calibration_dataset": "representative_sample",
                "accuracy_threshold": 0.02  # Max 2% accuracy loss
            },
            "pruning": {
                "enabled": True,
                "sparsity_level": 0.5,  # Remove 50% of weights
                "structured": True,
                "fine_tuning_epochs": 10
            },
            "distillation": {
                "enabled": True,
                "teacher_model": model_id,
                "student_architecture": "smaller_efficient_model",
                "temperature": 4.0,
                "alpha": 0.7
            },
            "graph_optimization": {
                "operator_fusion": True,
                "constant_folding": True,
                "dead_code_elimination": True,
                "layout_optimization": True
            },
            "compilation": {
                "framework": "tensorrt",  # or "onnx", "torchscript"
                "target_hardware": "gpu",
                "batch_size_optimization": True,
                "dynamic_shapes": False
            }
        }
        
        optimized_model = self.client.models.optimize({
            "model_id": model_id,
            "techniques": optimization_techniques,
            "validation": {
                "accuracy_test": True,
                "performance_benchmark": True,
                "memory_profiling": True
            }
        })
        
        return optimized_model
    
    def implement_caching_strategy(self, deployment_name):
        """Implement intelligent caching for improved performance"""
        
        caching_config = {
            "model_caching": {
                "enabled": True,
                "cache_size": "2GB",
                "eviction_policy": "LRU",
                "preload_models": True
            },
            "prediction_caching": {
                "enabled": True,
                "cache_duration": "1h",
                "similarity_threshold": 0.95,
                "cache_size": "500MB",
                "exclude_sensitive": True
            },
            "feature_caching": {
                "enabled": True,
                "cache_duration": "30m",
                "cache_size": "1GB",
                "update_strategy": "lazy"
            },
            "distributed_caching": {
                "enabled": True,
                "backend": "redis",
                "cluster_mode": True,
                "replication_factor": 2
            }
        }
        
        return self.client.deployments.configure_caching({
            "deployment_name": deployment_name,
            "config": caching_config
        })
    
    def optimize_batch_processing(self, deployment_name):
        """Optimize batch processing for throughput"""
        
        batch_config = {
            "dynamic_batching": {
                "enabled": True,
                "max_batch_size": 64,
                "max_delay": "50ms",
                "batch_timeout": "100ms"
            },
            "adaptive_batching": {
                "enabled": True,
                "target_latency": "200ms",
                "min_batch_size": 1,
                "max_batch_size": 128,
                "adjustment_interval": "1m"
            },
            "batch_optimization": {
                "padding_strategy": "minimal",
                "sort_by_length": True,
                "sequence_bucketing": True,
                "memory_efficient": True
            },
            "pipeline_parallelism": {
                "enabled": True,
                "stages": ["preprocessing", "inference", "postprocessing"],
                "overlap_computation": True
            }
        }
        
        return self.client.deployments.configure_batch_processing({
            "deployment_name": deployment_name,
            "config": batch_config
        })
    
    def implement_auto_scaling_optimization(self, deployment_name):
        """Implement intelligent auto-scaling"""
        
        scaling_config = {
            "metrics_based_scaling": {
                "cpu_utilization": {"target": 70, "weight": 0.3},
                "gpu_utilization": {"target": 80, "weight": 0.4},
                "queue_depth": {"target": 10, "weight": 0.3}
            },
            "predictive_scaling": {
                "enabled": True,
                "prediction_window": "30m",
                "confidence_threshold": 0.8,
                "scaling_buffer": 1.2
            },
            "scaling_policies": {
                "scale_up": {
                    "cooldown": "2m",
                    "step_size": 2,
                    "max_instances": 20
                },
                "scale_down": {
                    "cooldown": "5m",
                    "step_size": 1,
                    "min_instances": 1
                }
            },
            "cost_optimization": {
                "spot_instances": {
                    "enabled": True,
                    "percentage": 70,
                    "fallback_on_demand": True
                },
                "schedule_based": {
                    "business_hours_scaling": True,
                    "weekend_downscaling": True
                }
            }
        }
        
        return self.client.deployments.configure_auto_scaling({
            "deployment_name": deployment_name,
            "config": scaling_config
        })

# Usage
optimizer = PerformanceOptimizationBestPractices(client)

# Optimize model for production
optimized_model = optimizer.optimize_model_for_inference("base_model_v1")

# Deploy optimized model
deployment = client.models.deploy({
    "model_id": optimized_model.id,
    "name": "optimized-production-model",
    "config": {"instance_type": "gpu.medium"}
})

# Configure performance optimizations
optimizer.implement_caching_strategy(deployment.name)
optimizer.optimize_batch_processing(deployment.name)
optimizer.implement_auto_scaling_optimization(deployment.name)

print("✅ Performance optimizations configured")

# Cost optimization best practices
class CostOptimizationBestPractices:
    
    def __init__(self, client):
        self.client = client
    
    def implement_resource_optimization(self):
        """Implement comprehensive resource optimization"""
        
        optimization_strategies = {
            "right_sizing": {
                "enabled": True,
                "evaluation_period": "7d",
                "utilization_threshold": 60,
                "recommendation_engine": True,
                "auto_apply": False  # Require approval
            },
            "scheduling": {
                "dev_environment_shutdown": {
                    "enabled": True,
                    "schedule": "weekdays_18:00_to_08:00",
                    "weekends": "full_shutdown"
                },
                "training_job_scheduling": {
                    "off_peak_hours": True,
                    "priority_queuing": True,
                    "spot_instance_preference": True
                }
            },
            "resource_pooling": {
                "shared_dev_instances": True,
                "dynamic_allocation": True,
                "priority_based_preemption": True
            }
        }
        
        return self.client.cost_optimization.configure_strategies(optimization_strategies)
    
    def setup_budget_controls(self):
        """Set up budget controls and alerts"""
        
        budget_config = {
            "monthly_budgets": {
                "development": {"limit": 2000, "alert_thresholds": [75, 90]},
                "staging": {"limit": 1000, "alert_thresholds": [80, 95]},
                "production": {"limit": 10000, "alert_thresholds": [70, 85, 95]}
            },
            "project_budgets": {
                "nlp_project": {"limit": 5000, "period": "quarterly"},
                "vision_project": {"limit": 3000, "period": "monthly"}
            },
            "auto_actions": {
                "at_90_percent": ["pause_dev_training", "notify_teams"],
                "at_100_percent": ["pause_non_critical", "escalate_to_management"]
            },
            "cost_allocation": {
                "by_team": True,
                "by_project": True,
                "by_environment": True,
                "chargeback_enabled": True
            }
        }
        
        return self.client.cost_optimization.configure_budgets(budget_config)
    
    def implement_spot_instance_strategy(self):
        """Implement spot instance strategy for cost savings"""
        
        spot_config = {
            "workload_suitability": {
                "training_jobs": {
                    "spot_percentage": 80,
                    "fault_tolerance": "checkpoint_based",
                    "max_interruption_frequency": "low"
                },
                "batch_inference": {
                    "spot_percentage": 60,
                    "fallback_strategy": "on_demand"
                },
                "development": {
                    "spot_percentage": 90,
                    "data_persistence": "external_storage"
                }
            },
            "spot_fleet_config": {
                "diversification": True,
                "multiple_instance_types": True,
                "multiple_availability_zones": True,
                "target_capacity": "flexible"
            },
            "interruption_handling": {
                "graceful_shutdown": True,
                "checkpoint_frequency": "5m",
                "auto_resume": True,
                "notification_lead_time": "2m"
            }
        }
        
        return self.client.cost_optimization.configure_spot_instances(spot_config)
    
    def setup_cost_monitoring_and_reporting(self):
        """Set up comprehensive cost monitoring"""
        
        monitoring_config = {
            "real_time_tracking": {
                "granularity": "hourly",
                "cost_attribution": ["user", "project", "deployment"],
                "anomaly_detection": True
            },
            "reporting": {
                "daily_summaries": True,
                "weekly_detailed_reports": True,
                "monthly_trend_analysis": True,
                "recipients": ["finance@company.com", "engineering-leads@company.com"]
            },
            "cost_forecasting": {
                "enabled": True,
                "forecast_horizon": "3_months",
                "confidence_interval": 90,
                "scenario_analysis": True
            },
            "optimization_recommendations": {
                "automated_analysis": True,
                "savings_opportunities": True,
                "risk_assessment": True,
                "implementation_priority": True
            }
        }
        
        return self.client.cost_optimization.configure_monitoring(monitoring_config)

# Cost optimization implementation
cost_optimizer = CostOptimizationBestPractices(client)

# Set up resource optimization
cost_optimizer.implement_resource_optimization()
print("✅ Resource optimization configured")

# Configure budget controls
cost_optimizer.setup_budget_controls()
print("✅ Budget controls established")

# Implement spot instance strategy
cost_optimizer.implement_spot_instance_strategy()
print("✅ Spot instance strategy implemented")

# Set up monitoring and reporting
cost_optimizer.setup_cost_monitoring_and_reporting()
print("✅ Cost monitoring configured")

# Generate initial cost report
cost_report = client.cost_optimization.generate_report({
    "period": "current_month",
    "include_recommendations": True,
    "detail_level": "comprehensive"
})

print(f"Current month spend: ${cost_report.total_cost:.2f}")
print(f"Projected savings: ${cost_report.potential_savings:.2f}")
print(f"Top recommendation: {cost_report.top_recommendation}")

# Compliance and governance best practices
class ComplianceGovernanceBestPractices:
    
    def __init__(self, client):
        self.client = client
    
    def implement_gdpr_compliance(self):
        """Implement GDPR compliance measures"""
        
        gdpr_config = {
            "data_subject_rights": {
                "right_to_access": {
                    "enabled": True,
                    "response_time": "30_days",
                    "automated_reports": True
                },
                "right_to_rectification": {
                    "enabled": True,
                    "data_correction_workflow": True
                },
                "right_to_erasure": {
                    "enabled": True,
                    "deletion_verification": True,
                    "backup_deletion": True
                },
                "right_to_portability": {
                    "enabled": True,
                    "export_formats": ["json", "csv", "xml"]
                }
            },
            "consent_management": {
                "explicit_consent": True,
                "granular_permissions": True,
                "consent_withdrawal": True,
                "consent_records": "permanent_audit_trail"
            },
            "privacy_by_design": {
                "data_minimization": True,
                "purpose_limitation": True,
                "storage_limitation": True,
                "accuracy_principle": True
            },
            "dpo_requirements": {
                "dpo_contact": "dpo@company.com",
                "privacy_impact_assessments": True,
                "data_breach_notification": {
                    "internal_notification": "immediate",
                    "authority_notification": "72_hours",
                    "subject_notification": "without_undue_delay"
                }
            }
        }
        
        return self.client.compliance.configure_gdpr(gdpr_config)
    
    def implement_model_governance(self):
        """Implement comprehensive model governance"""
        
        governance_framework = {
            "model_lifecycle_management": {
                "development_standards": {
                    "code_review_required": True,
                    "testing_requirements": ["unit", "integration", "bias"],
                    "documentation_standards": "comprehensive",
                    "version_control": "mandatory"
                },
                "approval_workflow": {
                    "development_to_staging": ["technical_review", "security_scan"],
                    "staging_to_production": ["business_approval", "compliance_check", "performance_validation"],
                    "approver_matrix": {
                        "technical_review": "senior_ml_engineer",
                        "business_approval": "product_manager",
                        "compliance_check": "compliance_officer"
                    }
                }
            },
            "risk_management": {
                "risk_assessment": {
                    "required_for_production": True,
                    "update_frequency": "quarterly",
                    "risk_categories": ["technical", "business", "ethical", "legal"]
                },
                "bias_monitoring": {
                    "automated_testing": True,
                    "protected_attributes": ["gender", "race", "age"],
                    "fairness_metrics": ["demographic_parity", "equal_opportunity"],
                    "threshold_alerts": True
                },
                "explainability_requirements": {
                    "high_risk_decisions": "full_explanation",
                    "medium_risk_decisions": "summary_explanation",
                    "low_risk_decisions": "explanation_on_request"
                }
            },
            "audit_and_compliance": {
                "audit_trail": {
                    "model_decisions": True,
                    "data_access": True,
                    "configuration_changes": True,
                    "retention_period": "7_years"
                },
                "compliance_monitoring": {
                    "automated_checks": True,
                    "compliance_dashboard": True,
                    "violation_alerts": True,
                    "remediation_workflows": True
                }
            }
        }
        
        return self.client.governance.configure_framework(governance_framework)
    
    def setup_audit_logging(self):
        """Set up comprehensive audit logging"""
        
        audit_config = {
            "log_categories": {
                "access_logs": {
                    "user_authentication": True,
                    "api_access": True,
                    "data_access": True,
                    "admin_actions": True
                },
                "model_logs": {
                    "training_events": True,
                    "deployment_events": True,
                    "prediction_logs": True,
                    "model_updates": True
                },
                "system_logs": {
                    "configuration_changes": True,
                    "security_events": True,
                    "error_events": True,
                    "performance_events": False  # Too verbose
                }
            },
            "log_retention": {
                "security_logs": "10_years",
                "compliance_logs": "7_years",
                "operational_logs": "2_years",
                "debug_logs": "30_days"
            },
            "log_integrity": {
                "cryptographic_hashing": True,
                "tamper_detection": True,
                "secure_storage": True,
                "log_signing": True
            },
            "compliance_reporting": {
                "automated_reports": True,
                "report_schedules": {
                    "daily": ["security_summary"],
                    "weekly": ["access_report", "model_usage"],
                    "monthly": ["compliance_status", "audit_summary"],
                    "quarterly": ["risk_assessment", "governance_review"]
                }
            }
        }
        
        return self.client.compliance.configure_audit_logging(audit_config)

# Compliance implementation
compliance = ComplianceGovernanceBestPractices(client)

# Implement GDPR compliance
compliance.implement_gdpr_compliance()
print("✅ GDPR compliance configured")

# Set up model governance
compliance.implement_model_governance()
print("✅ Model governance framework established")

# Configure audit logging
compliance.setup_audit_logging()
print("✅ Audit logging configured")

# Generate compliance dashboard
dashboard = client.compliance.create_dashboard({
    "widgets": [
        "compliance_status_overview",
        "gdpr_requests_tracking", 
        "model_approval_pipeline",
        "audit_log_summary",
        "risk_assessment_status"
    ],
    "refresh_interval": "1h",
    "access_control": ["compliance_team", "legal_team", "executives"]
})

print(f"✅ Compliance dashboard created: {dashboard.url}")

import aicortex

client = aicortex.Client(api_key="your_api_key")

# Deploy GPT-3.5 Turbo
deployment = client.models.deploy(
    model_id="gpt-3.5-turbo",
    name="text-generator",
    config={
        "instance_type": "gpu.medium",
        "auto_scaling": {
            "min_instances": 1,
            "max_instances": 3
        }
    }
)

deployment.wait_until_ready()

# Generate text
def generate_text(prompt, max_tokens=100, temperature=0.7):
    result = client.models.predict(
        deployment_name="text-generator",
        inputs={
            "prompt": prompt,
            "max_tokens": max_tokens,
            "temperature": temperature
        }
    )
    return result.text

# Examples
prompts = [
    "Write a short story about a robot learning to paint:",
    "Explain quantum computing in simple terms:",
    "Create a recipe for chocolate chip cookies:"
]

for prompt in prompts:
    print(f"Prompt: {prompt}")
    response = generate_text(prompt, max_tokens=150)
    print(f"Response: {response}\n")
    print("-" * 50)

# Conversational chat
def chat_with_model():
    conversation = []
    
    print("Chat with AI (type 'quit' to exit)")
    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            break
            
        # Add context from conversation
        context = "\n".join([f"Human: {msg['human']}\nAI: {msg['ai']}" 
                           for msg in conversation[-3:]])  # Last 3 exchanges
        
        full_prompt = f"{context}\nHuman: {user_input}\nAI:"
        
        response = generate_text(full_prompt, max_tokens=200, temperature=0.8)
        print(f"AI: {response}")
        
        conversation.append({"human": user_input, "ai": response})

# Start chat
chat_with_model()

import aicortex
import requests
import tempfile
import os

client = aicortex.Client(api_key="your_api_key")

# Deploy Whisper Large V3
deployment = client.models.deploy(
    model_id="whisper-large-v3",
    name="audio-transcriber",
    config={
        "instance_type": "gpu.small",
        "auto_scaling": {
            "min_instances": 1,
            "max_instances": 3
        }
    }
)

deployment.wait_until_ready()

def transcribe_audio(audio_url, language=None):
    """Transcribe audio from URL or file path"""
    
    if audio_url.startswith('http'):
        # Download audio file
        response = requests.get(audio_url)
        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as f:
            f.write(response.content)
            audio_path = f.name
    else:
        audio_path = audio_url
    
    try:
        # Transcribe audio
        with open(audio_path, 'rb') as audio_file:
            result = client.models.predict(
                deployment_name="audio-transcriber",
                inputs={
                    "audio": audio_file,
                    "language": language,  # Optional: "en", "es", "fr", etc.
                    "response_format": "json",
                    "temperature": 0.0
                }
            )
        
        return result
    finally:
        # Cleanup temporary file
        if audio_url.startswith('http'):
            os.unlink(audio_path)

# Example usage
audio_files = [
    "https://example.com/speech1.mp3",
    "https://example.com/speech2.wav",
    "./local_audio.mp3"
]

for audio_url in audio_files:
    print(f"Transcribing: {audio_url}")
    
    result = transcribe_audio(audio_url, language="en")
    
    print(f"Transcript: {result.text}")
    print(f"Language detected: {result.language}")
    print(f"Duration: {result.duration:.2f}s")
    
    # Print word-level timestamps if available
    if hasattr(result, 'words'):
        print("Word timestamps:")
        for word in result.words[:10]:  # First 10 words
            print(f"  {word.word} ({word.start:.1f}s - {word.end:.1f}s)")
    
    print("-" * 50)

# Batch transcription
def batch_transcribe(audio_urls):
    """Transcribe multiple audio files in parallel"""
    
    batch_inputs = []
    for url in audio_urls:
        if url.startswith('http'):
            batch_inputs.append({"audio": url})
        else:
            with open(url, 'rb') as f:
                batch_inputs.append({"audio": f.read()})
    
    results = client.models.predict_batch(
        deployment_name="audio-transcriber",
        inputs=batch_inputs
    )
    
    return results

# Process multiple files
batch_results = batch_transcribe(audio_files)
for i, result in enumerate(batch_results.predictions):
    print(f"File {i+1}: {result.text[:100]}...")