AI Key Generator

const rateLimit = require('express-rate-limit');
const OpenAI = require('openai');

// Rate limiting for AI endpoints
const aiRateLimit = rateLimit({
  windowMs: 60 * 1000, // 1 minute
  max: 10, // 10 requests per minute
  message: 'Too many AI requests, try again later',
  standardHeaders: true
});

const openai = new OpenAI({
  apiKey: 'sk-your-openai-key',
});

// Track usage and costs
let monthlyTokens = 0;
const TOKEN_LIMIT = 100000;

app.post('/ai/chat', aiRateLimit, async (req, res) => {
  try {
    // Check token limit
    if (monthlyTokens >= TOKEN_LIMIT) {
      return res.status(429).json({ 
        error: 'Monthly token limit reached' 
      });
    }
    
    const response = await openai.chat.completions.create({
      model: 'gpt-3.5-turbo',
      messages: req.body.messages,
      max_tokens: 150
    });
    
    // Track usage
    monthlyTokens += response.usage.total_tokens;
    
    res.json({
      response: response.choices[0].message,
      tokens_used: response.usage.total_tokens,
      tokens_remaining: TOKEN_LIMIT - monthlyTokens
    });
    
  } catch (error) {
    res.status(500).json({ error: 'AI request failed' });
  }
});

import openai
import time
from functools import wraps

openai.api_key = 'sk-your-openai-key'

class AIUsageTracker:
    def __init__(self, monthly_limit=100000):
        self.monthly_tokens = 0
        self.monthly_limit = monthly_limit
        self.requests = []
    
    def check_rate_limit(self, max_per_minute=10):
        now = time.time()
        # Remove requests older than 1 minute
        self.requests = [req for req in self.requests 
                        if now - req < 60]
        
        if len(self.requests) >= max_per_minute:
            raise Exception("Rate limit exceeded")
        
        self.requests.append(now)
    
    def check_token_limit(self, tokens):
        if self.monthly_tokens + tokens > self.monthly_limit:
            raise Exception("Monthly token limit exceeded")

tracker = AIUsageTracker()

def ai_security_wrapper(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Check rate limits
        tracker.check_rate_limit()
        
        # Make AI request
        response = func(*args, **kwargs)
        
        # Track usage
        tokens_used = response.usage.total_tokens
        tracker.check_token_limit(tokens_used)
        tracker.monthly_tokens += tokens_used
        
        return response
    return wrapper

@ai_security_wrapper
def generate_ai_response(messages, max_tokens=150):
    return openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=messages,
        max_tokens=max_tokens
    )