AI API Gateway Tutorial

Client → Gateway → Load Balancer → Service Layer → AI Providers
    ↓        ↓           ↓              ↓             ↓
  Auth    Rate       Routing       Caching        OpenAI
  Logs   Metrics    Analytics    Transformer     Anthropic
                            

# Check Node.js version
node --version  # Should be 18.x or higher

# Check npm version
npm --version   # Should be 9.x or higher

# Check Docker installation
docker --version

# Check Git installation
git --version
                            

# Create project directory
mkdir ai-api-gateway && cd ai-api-gateway

# Initialize npm project
npm init -y

# Install core dependencies
npm install express cors dotenv helmet rate-limiter
npm install openai @anthropic-ai/sdk axios

# Install development dependencies
npm install -D typescript @types/node nodemon ts-node
npm install -D jest @types/jest supertest
                            

import express from 'express';
import cors from 'cors';
import helmet from 'helmet';
import dotenv from 'dotenv';
import rateLimit from 'express-rate-limit';

// Load environment variables
dotenv.config();

const app = express();
const PORT = process.env.PORT || 3000;

// Security middleware
app.use(helmet());
app.use(cors());
app.use(express.json());

// Rate limiting
const limiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    max: 100, // Limit each IP to 100 requests per windowMs
    message: 'Too many requests from this IP, please try again later.'
});
app.use('/api/', limiter);

// Health check endpoint
app.get('/health', (req, res) => {
    res.json({ status: 'healthy', timestamp: new Date().toISOString() });
});

// AI Gateway endpoint (we'll implement this next)
app.post('/api/v1/chat/completions', async (req, res) => {
    try {
        // AI Gateway logic will go here
        res.json({ message: 'AI Gateway endpoint' });
    } catch (error) {
        res.status(500).json({ error: 'Internal server error' });
    }
});

app.listen(PORT, () => {
    console.log(`AI API Gateway running on port ${PORT}`);
});

# Server Configuration
PORT=3000
NODE_ENV=development

# API Keys (get these from your AI providers)
OPENAI_API_KEY=your_openai_api_key_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here
GOOGLE_AI_API_KEY=your_google_ai_api_key_here

# Gateway Configuration
RATE_LIMIT_PER_MINUTE=60
CACHE_TTL_SECONDS=300
MAX_TOKENS_PER_REQUEST=4000

# Security
JWT_SECRET=your_jwt_secret_here
API_KEY_HEADER=X-API-Key

# Use Node.js LTS as base image
FROM node:18-alpine

# Create app directory
WORKDIR /usr/src/app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy app source
COPY . .

# Build TypeScript
RUN npm run build

# Expose port
EXPOSE 3000

# Start the application
CMD ["node", "dist/server.js"]

version: '3.8'

services:
  ai-gateway:
    build: .
    container_name: ai-api-gateway
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - PORT=3000
    env_file:
      - .env
    restart: unless-stopped
    volumes:
      - ./logs:/usr/src/app/logs
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Optional: Add Redis for caching
  redis:
    image: redis:7-alpine
    container_name: ai-gateway-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes

volumes:
  redis-data:

import Redis from 'ioredis';
import crypto from 'crypto';

class AICache {
    private redis: Redis;
    private ttl: number;

    constructor() {
        this.redis = new Redis({
            host: process.env.REDIS_HOST || 'localhost',
            port: parseInt(process.env.REDIS_PORT || '6379'),
            password: process.env.REDIS_PASSWORD
        });
        this.ttl = parseInt(process.env.CACHE_TTL_SECONDS || '300');
    }

    // Generate cache key from request parameters
    private generateKey(request: any): string {
        const requestString = JSON.stringify(request);
        return `ai_cache:${crypto.createHash('md5').update(requestString).digest('hex')}`;
    }

    // Get cached response
    async get(request: any): Promise {
        const key = this.generateKey(request);
        const cached = await this.redis.get(key);
        return cached ? JSON.parse(cached) : null;
    }

    // Store response in cache
    async set(request: any, response: any): Promise {
        const key = this.generateKey(request);
        await this.redis.setex(key, this.ttl, JSON.stringify(response));
    }

    // Clear cache for specific pattern
    async clear(pattern: string): Promise {
        const keys = await this.redis.keys(pattern);
        if (keys.length > 0) {
            await this.redis.del(...keys);
        }
    }
}

export default new AICache();

class RequestBatcher {
    private batch: Array<{request: any, resolve: Function, reject: Function}> = [];
    private batchSize: number;
    private timeout: NodeJS.Timeout | null = null;

    constructor(batchSize = 10, timeoutMs = 50) {
        this.batchSize = batchSize;
        
        // Process batch when full or timeout
        setInterval(() => {
            if (this.batch.length > 0) {
                this.processBatch();
            }
        }, timeoutMs);
    }

    async addRequest(request: any): Promise {
        return new Promise((resolve, reject) => {
            this.batch.push({ request, resolve, reject });
            
            // Process batch if full
            if (this.batch.length >= this.batchSize) {
                this.processBatch();
            }
        });
    }

    private async processBatch() {
        if (this.batch.length === 0) return;

        const currentBatch = [...this.batch];
        this.batch = [];

        try {
            // Combine similar requests
            const combinedRequests = this.combineRequests(currentBatch);
            const responses = await this.sendToAIProvider(combinedRequests);
            
            // Distribute responses
            this.distributeResponses(currentBatch, responses);
        } catch (error) {
            // Handle errors for all requests in batch
            currentBatch.forEach(item => item.reject(error));
        }
    }

    private combineRequests(batch: any[]) {
        // Implementation for combining similar AI requests
        return batch.map(item => item.request);
    }

    private async sendToAIProvider(requests: any[]) {
        // Send batched requests to AI provider
        // Implementation depends on the AI provider
        return [];
    }

    private distributeResponses(batch: any[], responses: any[]) {
        // Distribute responses to original requests
        batch.forEach((item, index) => {
            item.resolve(responses[index] || null);
        });
    }
}

export default new RequestBatcher();

import client from 'prom-client';

// Create a Registry to register metrics
const register = new client.Registry();

// Enable default metrics
client.collectDefaultMetrics({ register });

// Custom metrics
const requestCounter = new client.Counter({
    name: 'ai_gateway_requests_total',
    help: 'Total number of AI gateway requests',
    labelNames: ['provider', 'status']
});

const responseTimeHistogram = new client.Histogram({
    name: 'ai_gateway_response_time_seconds',
    help: 'Response time histogram',
    labelNames: ['provider'],
    buckets: [0.1, 0.5, 1, 2, 5]
});

const tokenUsageGauge = new client.Gauge({
    name: 'ai_gateway_tokens_used',
    help: 'Number of tokens used',
    labelNames: ['provider']
});

// Register custom metrics
register.registerMetric(requestCounter);
register.registerMetric(responseTimeHistogram);
register.registerMetric(tokenUsageGauge);

export { requestCounter, responseTimeHistogram, tokenUsageGauge, register };