Deploying AI Agents to the Cloud - Part 3: Deploying to AWS

AWS provides the most comprehensive cloud platform for AI agent deployment, offering everything from simple serverless functions to complex multi-region architectures. While Vercel excels at simplicity, AWS gives you complete control over your infrastructure, security, and scaling strategies.

For AI agents, AWS offers unique advantages: longer execution times, more memory options, extensive database services, and enterprise-grade security features that make it ideal for production AI applications.

Why Choose AWS for AI Agent Deployment

Comprehensive Service Ecosystem AWS offers over 200 services that can enhance your AI agent:

• Lambda: Serverless functions with up to 15-minute execution time
• API Gateway: Managed API endpoints with throttling and caching
• RDS: Managed databases for conversation storage
• S3: Object storage for files, logs, and model artifacts
• CloudWatch: Comprehensive monitoring and alerting

Enterprise-Grade Security AWS provides security features that enterprise customers require:

• VPC: Private networks for your AI agent infrastructure
• IAM: Fine-grained access control for all resources
• KMS: Key management for encryption
• WAF: Web application firewall for API protection

Global Infrastructure AWS operates in 31 regions worldwide, allowing you to deploy your AI agent close to users for optimal performance.

Cost Optimization AWS's pay-as-you-go model with reserved instances and spot pricing can significantly reduce costs for predictable AI workloads.

What You'll Learn in This Tutorial

By the end of this tutorial, you'll have:

• ✅ Complete AWS serverless deployment using Lambda and API Gateway
• ✅ Production database setup with RDS and proper security
• ✅ Comprehensive monitoring with CloudWatch and X-Ray
• ✅ Auto-scaling configuration for variable AI workloads
• ✅ Security best practices including VPC and IAM roles
• ✅ Cost optimization strategies for AI agent workloads

Estimated Time: 45-50 minutes

---

Step 1: Understanding AWS Architecture for AI Agents

Before deploying, it's crucial to understand how AWS services work together to create a robust AI agent platform.

AWS Serverless Architecture for AI Agents

Core Components:

Internet → API Gateway → Lambda Function → RDS Database
                    ↓
                CloudWatch (Monitoring)
                    ↓
                S3 (Storage)

Why This Architecture Works for AI Agents:

API Gateway Acts as the front door for your AI agent, handling:

• Request routing to appropriate Lambda functions
• Rate limiting to prevent abuse
• Authentication integration with AWS Cognito
• Request/response transformation for different client types

Lambda Functions Perfect for AI agents because they:

• Scale automatically from zero to thousands of concurrent executions
• Support longer execution times (up to 15 minutes vs Vercel's 10 seconds)
• Offer more memory (up to 10GB vs Vercel's 3GB)
• Integrate seamlessly with other AWS services

RDS (Relational Database Service) Provides managed database hosting with:

• Automatic backups and point-in-time recovery
• Multi-AZ deployment for high availability
• Read replicas for improved performance
• Encryption at rest for data protection

AWS vs Other Platforms Comparison

Feature	AWS Lambda	Vercel	Traditional Server
Max Execution Time	15 minutes	10-60 seconds	Unlimited
Max Memory	10GB	3GB	Server dependent
Cold Start	~100-500ms	~100-300ms	None
Scaling	Automatic	Automatic	Manual
Database Integration	Native (RDS)	External only	Any
Monitoring	CloudWatch	Basic	Custom

---

Step 2: Setting Up AWS Infrastructure

Let's create the AWS infrastructure needed for your AI agent using Infrastructure as Code principles.

AWS Account Setup and Security

Initial AWS Setup Steps:

1. Create AWS Account

   • Sign up at aws.amazon.com
   • Complete identity verification
   • Set up billing alerts

2. Secure Root Account

   • Enable MFA (Multi-Factor Authentication)
   • Create IAM user for daily operations
   • Never use root account for development

3. Create Development IAM User

   # Create IAM user with necessary permissions
   aws iam create-user --user-name ai-agent-developer
   
   # Attach policies for Lambda, API Gateway, RDS
   aws iam attach-user-policy --user-name ai-agent-developer --policy-arn arn:aws:iam::aws:policy/AWSLambdaFullAccess
   aws iam attach-user-policy --user-name ai-agent-developer --policy-arn arn:aws:iam::aws:policy/AmazonAPIGatewayAdministrator
   aws iam attach-user-policy --user-name ai-agent-developer --policy-arn arn:aws:iam::aws:policy/AmazonRDSFullAccess
   

Why This Security Setup Matters:

• Root Account Protection: Root account has unlimited access - compromising it could destroy your entire AWS infrastructure
• Principle of Least Privilege: Development user only has permissions needed for AI agent deployment
• MFA Protection: Even if passwords are compromised, MFA prevents unauthorized access

Installing AWS Tools

# Install AWS CLI
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

# Install Serverless Framework (alternative to SAM)
npm install -g serverless

# Install AWS SAM CLI (for local testing)
pip install aws-sam-cli

# Configure AWS credentials
aws configure
# Enter your Access Key ID, Secret Access Key, region, and output format

Tool Selection Explanation:

AWS CLI: Essential for managing AWS resources from command line.

Serverless Framework: Simplifies Lambda deployment with excellent Node.js support.

SAM CLI: AWS's official tool for serverless applications, great for local testing.

---

Step 3: Creating Your AI Agent Lambda Function

Let's create a Lambda function optimized for AI agent workloads.

Lambda Function Structure

AWS Lambda functions for AI agents need specific configuration to handle the unique requirements of AI processing:

// lambda/ai-agent-handler.js

const { OpenAI } = require('openai');

// Initialize OpenAI client outside handler for connection reuse
let openaiClient;

function getOpenAIClient() {
    if (!openaiClient) {
        openaiClient = new OpenAI({
            apiKey: process.env.OPENAI_API_KEY
        });
    }
    return openaiClient;
}

exports.handler = async (event, context) => {
    // Configure Lambda context for AI workloads
    context.callbackWaitsForEmptyEventLoop = false; // Don't wait for event loop to be empty
    
    const startTime = Date.now();
    
    try {
        // Parse incoming request
        const requestBody = JSON.parse(event.body || '{}');
        const { message, userId, conversationId } = requestBody;
        
        // Validate required fields
        if (!message) {
            return {
                statusCode: 400,
                headers: {
                    'Content-Type': 'application/json',
                    'Access-Control-Allow-Origin': '*'
                },
                body: JSON.stringify({
                    error: 'Missing message field',
                    message: 'Please provide a message in the request body'
                })
            };
        }
        
        console.log(`🤖 Processing AI request for user: ${userId}`);
        
        // Get conversation context (if available)
        const conversationContext = await getConversationContext(conversationId);
        
        // Process with OpenAI
        const client = getOpenAIClient();
        const response = await client.chat.completions.create({
            model: process.env.OPENAI_MODEL || 'gpt-3.5-turbo',
            messages: [
                {
                    role: 'system',
                    content: process.env.SYSTEM_PROMPT || 'You are a helpful AI assistant.'
                },
                ...conversationContext,
                {
                    role: 'user',
                    content: message
                }
            ],
            max_tokens: parseInt(process.env.MAX_TOKENS) || 500,
            temperature: parseFloat(process.env.TEMPERATURE) || 0.7
        });
        
        const aiResponse = response.choices[0].message.content;
        
        // Store conversation (if enabled)
        if (conversationId) {
            await storeConversationMessage(conversationId, 'user', message);
            await storeConversationMessage(conversationId, 'assistant', aiResponse);
        }
        
        // Calculate processing time
        const processingTime = Date.now() - startTime;
        
        // Return successful response
        return {
            statusCode: 200,
            headers: {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'
            },
            body: JSON.stringify({
                success: true,
                response: aiResponse,
                metadata: {
                    processingTime: processingTime,
                    model: response.model,
                    tokensUsed: response.usage.total_tokens,
                    conversationId: conversationId
                }
            })
        };
        
    } catch (error) {
        console.error('❌ AI processing error:', error);
        
        // Return error response
        return {
            statusCode: 500,
            headers: {
                'Content-Type': 'application/json',
                'Access-Control-Allow-Origin': '*'
            },
            body: JSON.stringify({
                error: 'AI processing failed',
                message: 'Please try again or contact support',
                requestId: context.awsRequestId
            })
        };
    }
};

async function getConversationContext(conversationId) {
    /**
     * Get recent conversation history for context
     */
    
    if (!conversationId) {
        return [];
    }
    
    try {
        // In production, fetch from RDS database
        // For now, return empty context
        return [];
        
    } catch (error) {
        console.warn('Failed to get conversation context:', error);
        return [];
    }
}

async function storeConversationMessage(conversationId, role, content) {
    /**
     * Store conversation message in database
     */
    
    try {
        // In production, store in RDS database
        console.log(`💾 Storing message: ${role} in conversation ${conversationId}`);
        
    } catch (error) {
        console.warn('Failed to store conversation message:', error);
    }
}

Lambda Function Explanation:

Connection Reuse: We initialize the OpenAI client outside the handler function so it's reused across invocations, reducing cold start time.

Context Configuration: callbackWaitsForEmptyEventLoop = false prevents Lambda from waiting for background processes, improving response time.

Error Handling: Comprehensive error handling ensures users get helpful error messages while protecting internal details.

CORS Headers: Proper CORS configuration allows web clients to call your AI agent API.

Serverless Framework Configuration

Create a serverless.yml file to define your AWS infrastructure:

# serverless.yml - Infrastructure as Code for AI Agent

service: ai-agent-aws

provider:
  name: aws
  runtime: nodejs18.x
  region: us-east-1
  stage: ${opt:stage, 'dev'}
  
  # Memory and timeout configuration for AI workloads
  memorySize: 1024  # 1GB memory for AI processing
  timeout: 300      # 5 minutes timeout (adjust based on needs)
  
  # Environment variables
  environment:
    STAGE: ${self:provider.stage}
    OPENAI_API_KEY: ${env:OPENAI_API_KEY}
    OPENAI_MODEL: ${env:OPENAI_MODEL, 'gpt-3.5-turbo'}
    SYSTEM_PROMPT: ${env:SYSTEM_PROMPT, 'You are a helpful AI assistant.'}
    MAX_TOKENS: ${env:MAX_TOKENS, '500'}
    TEMPERATURE: ${env:TEMPERATURE, '0.7'}
    
    # Database configuration
    DB_HOST: ${env:DB_HOST}
    DB_NAME: ${env:DB_NAME}
    DB_USER: ${env:DB_USER}
    DB_PASSWORD: ${env:DB_PASSWORD}
  
  # IAM permissions
  iamRoleStatements:
    - Effect: Allow
      Action:
        - rds:DescribeDBInstances
        - rds:Connect
      Resource: "*"
    - Effect: Allow
      Action:
        - logs:CreateLogGroup
        - logs:CreateLogStream
        - logs:PutLogEvents
      Resource: "*"
    - Effect: Allow
      Action:
        - xray:PutTraceSegments
        - xray:PutTelemetryRecords
      Resource: "*"

functions:
  # Main AI chat function
  aiChat:
    handler: lambda/ai-agent-handler.handler
    events:
      - http:
          path: /chat
          method: post
          cors: true
    
    # Function-specific configuration
    memorySize: 1024
    timeout: 300
    
    # Environment-specific settings
    environment:
      FUNCTION_NAME: ai-chat
  
  # Health check function
  healthCheck:
    handler: lambda/health-check.handler
    events:
      - http:
          path: /health
          method: get
          cors: true
    
    # Lighter configuration for health checks
    memorySize: 128
    timeout: 30

# CloudFormation resources
resources:
  Resources:
    # API Gateway configuration
    ApiGatewayRestApi:
      Type: AWS::ApiGateway::RestApi
      Properties:
        Name: ${self:service}-${self:provider.stage}
        Description: AI Agent API
        
    # CloudWatch Log Groups
    AiChatLogGroup:
      Type: AWS::Logs::LogGroup
      Properties:
        LogGroupName: /aws/lambda/${self:service}-${self:provider.stage}-aiChat
        RetentionInDays: 14

plugins:
  - serverless-offline  # For local development
  - serverless-plugin-tracing  # For X-Ray tracing

custom:
  # Local development configuration
  serverless-offline:
    httpPort: 3000
    host: 0.0.0.0

Serverless Configuration Explanation:

Memory and Timeout: AI processing requires more resources than typical web APIs. 1GB memory and 5-minute timeout accommodate most AI operations.

IAM Permissions: Specific permissions for database access, logging, and tracing. Following least-privilege principle.

Environment Variables: Centralized configuration that can be different per deployment stage (dev, staging, production).

CloudWatch Integration: Automatic log collection and retention management.

---

Step 4: Database Integration with RDS

AI agents need persistent storage for conversations, user preferences, and learning data. AWS RDS provides managed database hosting.

RDS Setup for AI Agents

Why RDS Over Simple Storage:

• ACID Compliance: Ensures data consistency for conversation storage
• Backup and Recovery: Automatic backups with point-in-time recovery
• Performance: Optimized for read/write operations typical in AI agents
• Security: Encryption at rest and in transit, VPC isolation

RDS Configuration for AI Agents:

# Add to serverless.yml resources section

# RDS Subnet Group (for VPC deployment)
DBSubnetGroup:
  Type: AWS::RDS::DBSubnetGroup
  Properties:
    DBSubnetGroupDescription: Subnet group for AI Agent database
    SubnetIds:
      - ${env:SUBNET_ID_1}
      - ${env:SUBNET_ID_2}
    Tags:
      - Key: Name
        Value: ai-agent-db-subnet-group

# RDS Instance
AIAgentDatabase:
  Type: AWS::RDS::DBInstance
  Properties:
    DBInstanceIdentifier: ai-agent-${self:provider.stage}
    DBInstanceClass: db.t3.micro  # Start small, can scale up
    Engine: postgres
    EngineVersion: '14.9'
    
    # Database configuration
    DBName: aiagent
    MasterUsername: ${env:DB_MASTER_USER}
    MasterUserPassword: ${env:DB_MASTER_PASSWORD}
    
    # Storage configuration
    AllocatedStorage: 20  # 20GB initial storage
    StorageType: gp2
    StorageEncrypted: true
    
    # Network and security
    VPCSecurityGroups:
      - Ref: DatabaseSecurityGroup
    DBSubnetGroupName:
      Ref: DBSubnetGroup
    
    # Backup configuration
    BackupRetentionPeriod: 7
    DeleteAutomatedBackups: false
    DeletionProtection: true  # Prevent accidental deletion
    
    # Monitoring
    MonitoringInterval: 60
    EnablePerformanceInsights: true

# Security Group for Database
DatabaseSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Security group for AI Agent database
    VpcId: ${env:VPC_ID}
    SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 5432
        ToPort: 5432
        SourceSecurityGroupId:
          Ref: LambdaSecurityGroup
    Tags:
      - Key: Name
        Value: ai-agent-db-security-group

Database Connection in Lambda

// lambda/database/connection.js

const { Pool } = require('pg');

// Create connection pool outside handler for reuse
let dbPool;

function getDBPool() {
    if (!dbPool) {
        dbPool = new Pool({
            host: process.env.DB_HOST,
            port: process.env.DB_PORT || 5432,
            database: process.env.DB_NAME,
            user: process.env.DB_USER,
            password: process.env.DB_PASSWORD,
            
            // SSL configuration for security
            ssl: {
                require: true,
                rejectUnauthorized: false
            },
            
            // Connection pool settings optimized for Lambda
            max: 1,  // Lambda functions are single-threaded
            min: 0,  # Allow connections to close when not needed
            idle: 1000,
            acquire: 3000,
            dispose: 5000
        });
        
        console.log('✅ Database connection pool initialized');
    }
    
    return dbPool;
}

async function executeQuery(query, params = []) {
    /**
     * Execute database query with proper error handling
     */
    
    const pool = getDBPool();
    const client = await pool.connect();
    
    try {
        const result = await client.query(query, params);
        return result;
        
    } catch (error) {
        console.error('❌ Database query failed:', error);
        throw error;
        
    } finally {
        client.release();
    }
}

// Conversation storage functions
async function storeConversationMessage(conversationId, role, content, metadata = {}) {
    const query = `
        INSERT INTO messages (conversation_id, role, content, metadata, created_at)
        VALUES ($1, $2, $3, $4, NOW())
        RETURNING id, created_at
    `;
    
    const result = await executeQuery(query, [
        conversationId,
        role,
        content,
        JSON.stringify(metadata)
    ]);
    
    return result.rows[0];
}

async function getConversationHistory(conversationId, limit = 10) {
    const query = `
        SELECT role, content, created_at, metadata
        FROM messages
        WHERE conversation_id = $1
        ORDER BY created_at DESC
        LIMIT $2
    `;
    
    const result = await executeQuery(query, [conversationId, limit]);
    
    // Return in chronological order (oldest first)
    return result.rows.reverse();
}

module.exports = {
    executeQuery,
    storeConversationMessage,
    getConversationHistory
};

Database Integration Explanation:

Connection Pooling: Lambda functions can reuse connections across invocations, reducing connection overhead.

SSL Security: All database connections use SSL encryption to protect data in transit.

Error Handling: Proper error handling ensures database issues don't crash your AI agent.

Optimized Queries: Queries are designed for the access patterns typical in AI agent applications.

---

Step 5: API Gateway Configuration

API Gateway acts as the front door for your AI agent, handling authentication, rate limiting, and request routing.

API Gateway Setup

Why API Gateway is Essential for AI Agents:

• Rate Limiting: Prevents abuse and controls costs
• Authentication: Integrates with AWS Cognito for user management
• Request Transformation: Handles different client formats (web, mobile, etc.)
• Caching: Reduces Lambda invocations for repeated requests
• Monitoring: Detailed metrics and logging

# API Gateway configuration in serverless.yml

custom:
  # API Gateway settings
  apiGateway:
    # Request validation
    request:
      schemas:
        chat-request:
          name: ChatRequest
          description: Schema for AI chat requests
          schema:
            type: object
            properties:
              message:
                type: string
                minLength: 1
                maxLength: 4000
              userId:
                type: string
                pattern: '^[a-zA-Z0-9-_]+$'
              conversationId:
                type: string
                pattern: '^[a-zA-Z0-9-_]+$'
            required:
              - message
    
    # Response templates
    response:
      headers:
        Access-Control-Allow-Origin: "'*'"
        Access-Control-Allow-Headers: "'Content-Type,Authorization'"
        Access-Control-Allow-Methods: "'GET,POST,OPTIONS'"
    
    # Throttling configuration
    throttle:
      burstLimit: 100    # Allow bursts up to 100 requests
      rateLimit: 50      # 50 requests per second sustained

functions:
  aiChat:
    handler: lambda/ai-agent-handler.handler
    events:
      - http:
          path: /chat
          method: post
          cors: true
          
          # Request validation
          request:
            schemas:
              application/json: ${self:custom.apiGateway.request.schemas.chat-request}
          
          # Rate limiting
          throttling:
            burstLimit: 20
            rateLimit: 10

API Gateway Configuration Explanation:

Request Validation: API Gateway validates requests before they reach Lambda, reducing invalid invocations and costs.

Rate Limiting: Protects your AI agent from abuse and helps control OpenAI API costs.

CORS Configuration: Allows web applications to call your AI agent API from browsers.

Schema Validation: Ensures requests have the correct format, preventing errors in your Lambda function.

---

Step 6: Monitoring and Observability

AWS provides comprehensive monitoring tools that give you deep insights into your AI agent's performance.

CloudWatch Monitoring Setup

Essential Metrics for AI Agents:

• Response Time: How long AI processing takes
• Error Rate: Percentage of failed requests
• Token Usage: OpenAI API token consumption
• Memory Usage: Lambda memory utilization
• Database Performance: Query response times

// lambda/monitoring/cloudwatch-metrics.js

const AWS = require('aws-sdk');
const cloudwatch = new AWS.CloudWatch();

class CloudWatchMetrics {
    constructor() {
        this.namespace = 'AIAgent';
        this.defaultDimensions = [
            {
                Name: 'Environment',
                Value: process.env.STAGE || 'dev'
            }
        ];
    }
    
    async recordMetric(metricName, value, unit = 'Count', dimensions = []) {
        /**
         * Record custom metric to CloudWatch
         */
        
        const params = {
            Namespace: this.namespace,
            MetricData: [
                {
                    MetricName: metricName,
                    Value: value,
                    Unit: unit,
                    Timestamp: new Date(),
                    Dimensions: [...this.defaultDimensions, ...dimensions]
                }
            ]
        };
        
        try {
            await cloudwatch.putMetricData(params).promise();
            console.log(`📊 Metric recorded: ${metricName} = ${value}`);
            
        } catch (error) {
            console.error('❌ Failed to record metric:', error);
        }
    }
    
    async recordAIProcessingMetrics(processingTime, tokensUsed, success = true) {
        /**
         * Record AI-specific metrics
         */
        
        // Record processing time
        await this.recordMetric('ProcessingTime', processingTime, 'Milliseconds');
        
        // Record token usage
        await this.recordMetric('TokensUsed', tokensUsed, 'Count');
        
        // Record success/failure
        await this.recordMetric('RequestSuccess', success ? 1 : 0, 'Count');
        
        // Record error if failed
        if (!success) {
            await this.recordMetric('RequestError', 1, 'Count');
        }
    }
    
    async recordDatabaseMetrics(queryTime, queryType) {
        /**
         * Record database performance metrics
         */
        
        await this.recordMetric('DatabaseQueryTime', queryTime, 'Milliseconds', [
            {
                Name: 'QueryType',
                Value: queryType
            }
        ]);
    }
}

module.exports = CloudWatchMetrics;

Setting Up CloudWatch Alarms

# Add to serverless.yml resources

# High error rate alarm
HighErrorRateAlarm:
  Type: AWS::CloudWatch::Alarm
  Properties:
    AlarmName: ${self:service}-${self:provider.stage}-high-error-rate
    AlarmDescription: Alert when AI agent error rate is high
    MetricName: Errors
    Namespace: AWS/Lambda
    Statistic: Sum
    Period: 300  # 5 minutes
    EvaluationPeriods: 2
    Threshold: 10
    ComparisonOperator: GreaterThanThreshold
    Dimensions:
      - Name: FunctionName
        Value: ${self:service}-${self:provider.stage}-aiChat
    
    # SNS notification (configure SNS topic separately)
    AlarmActions:
      - ${env:SNS_ALERT_TOPIC_ARN}

# High response time alarm
HighLatencyAlarm:
  Type: AWS::CloudWatch::Alarm
  Properties:
    AlarmName: ${self:service}-${self:provider.stage}-high-latency
    AlarmDescription: Alert when AI agent response time is high
    MetricName: Duration
    Namespace: AWS/Lambda
    Statistic: Average
    Period: 300
    EvaluationPeriods: 2
    Threshold: 30000  # 30 seconds
    ComparisonOperator: GreaterThanThreshold
    Dimensions:
      - Name: FunctionName
        Value: ${self:service}-${self:provider.stage}-aiChat

Monitoring Explanation:

Custom Metrics: We track AI-specific metrics like token usage and processing time, which aren't available in standard AWS metrics.

Alarms: Automated alerts notify you when your AI agent isn't performing well, allowing quick response to issues.

Retention Policies: Log retention is configured to balance cost and debugging needs.

---

Step 7: Deployment and Testing

Now let's deploy your AI agent to AWS and test it thoroughly.

Deployment Process

1. Configure AWS Credentials:

# Set up AWS credentials
aws configure
# Enter your Access Key ID, Secret Access Key, region (us-east-1), and output format (json)

2. Install Dependencies:

# Install Serverless Framework
npm install -g serverless

# Install project dependencies
npm install

3. Deploy to Development:

# Deploy to development environment
serverless deploy --stage dev

# The output will show your API endpoints:
# endpoints:
#   POST - https://abc123.execute-api.us-east-1.amazonaws.com/dev/chat
#   GET - https://abc123.execute-api.us-east-1.amazonaws.com/dev/health

4. Test Your Deployment:

# Test the health endpoint
curl https://your-api-id.execute-api.us-east-1.amazonaws.com/dev/health

# Test the AI chat endpoint
curl -X POST https://your-api-id.execute-api.us-east-1.amazonaws.com/dev/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello, AI agent!", "userId": "test-user"}'

Production Deployment Best Practices

Environment Separation:

# Deploy to different stages
serverless deploy --stage dev     # Development
serverless deploy --stage staging # Staging/Testing
serverless deploy --stage prod    # Production

Environment-Specific Configuration:

# .env.dev
OPENAI_MODEL=gpt-3.5-turbo
MAX_TOKENS=500
DB_INSTANCE_CLASS=db.t3.micro

# .env.prod
OPENAI_MODEL=gpt-4
MAX_TOKENS=1000
DB_INSTANCE_CLASS=db.t3.small

---

Step 8: Cost Optimization Strategies

AWS costs can add up quickly if not managed properly. Here are strategies to optimize costs for AI agent workloads.

Lambda Cost Optimization

Memory vs Duration Trade-off: Higher memory allocation often reduces execution time, potentially lowering overall costs.

// Example: Cost optimization analysis

const costAnalysis = {
    // Scenario 1: Low memory, longer execution
    lowMemory: {
        memoryMB: 512,
        avgExecutionMs: 5000,
        costPer1MInvocations: 8.33  // USD
    },
    
    // Scenario 2: High memory, shorter execution
    highMemory: {
        memoryMB: 1024,
        avgExecutionMs: 2500,
        costPer1MInvocations: 8.33  // Often the same or lower
    }
};

// Monitor your actual metrics to find the optimal configuration

Reserved Capacity: For predictable workloads, Lambda reserved capacity can reduce costs by up to 17%.

Database Cost Optimization

Right-Sizing Strategy:

# Development environment
DBInstanceClass: db.t3.micro  # $0.017/hour

# Production environment (scale based on usage)
DBInstanceClass: db.t3.small   # $0.034/hour
# or
DBInstanceClass: db.r5.large   # $0.24/hour for high-performance needs

Storage Optimization:

• gp2: General purpose, cost-effective
• gp3: Better performance per dollar for high-throughput applications
• io1: High IOPS for demanding applications

---

What You've Accomplished

Your AI agent is now deployed on AWS with enterprise-grade infrastructure:

• ✅ Serverless Architecture: Lambda functions with optimal memory and timeout configuration