Cara Deploy AI Agent ke Production (Docker + Railway)

mkdir ai-agent-production
cd ai-agent-production

import os
from openai import OpenAI

client = None

def get_client():
    global client
    if client is None:
        api_key = os.getenv("OPENAI_API_KEY")
        if not api_key:
            raise ValueError("OPENAI_API_KEY tidak ditemukan di environment variables")
        client = OpenAI(api_key=api_key)
    return client


def generate_response(message: str, system_prompt: str = None) -> str:
    """Generate response dari AI agent berdasarkan input message."""
    
    if system_prompt is None:
        system_prompt = (
            "Kamu adalah AI assistant yang helpful. "
            "Jawab dalam Bahasa Indonesia yang natural dan ramah. "
            "Berikan jawaban yang akurat dan to the point."
        )
    
    try:
        client = get_client()
        response = client.chat.completions.create(
            model="gpt-4o-mini",  # Model yang cost-effective
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": message},
            ],
            max_tokens=1000,
            temperature=0.7,
        )
        return response.choices[0].message.content
    
    except Exception as e:
        raise Exception(f"Error generating response: {str(e)}")


def generate_with_context(message: str, context: list[dict]) -> str:
    """Generate response dengan conversation history."""
    
    system_prompt = (
        "Kamu adalah AI assistant yang helpful. "
        "Jawab dalam Bahasa Indonesia."
    )
    
    messages = [{"role": "system", "content": system_prompt}]
    messages.extend(context)
    messages.append({"role": "user", "content": message})
    
    try:
        client = get_client()
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            max_tokens=1000,
            temperature=0.7,
        )
        return response.choices[0].message.content
    
    except Exception as e:
        raise Exception(f"Error generating response: {str(e)}")

from flask import Flask, request, jsonify
import os
import time
from agent import generate_response, generate_with_context

app = Flask(__name__)

# In-memory conversation storage (ganti dengan Redis/database di production)
conversations = {}


@app.route("/health", methods=["GET"])
def health():
    """Health check endpoint — dipakai Railway untuk monitoring."""
    return jsonify({
        "status": "ok",
        "timestamp": time.time(),
        "version": "1.0.0",
    })


@app.route("/chat", methods=["POST"])
def chat():
    """Main chat endpoint."""
    data = request.json
    
    if not data or not data.get("message"):
        return jsonify({"error": "Field 'message' wajib diisi"}), 400
    
    message = data["message"]
    system_prompt = data.get("system_prompt")
    
    try:
        response = generate_response(message, system_prompt)
        return jsonify({
            "response": response,
            "model": "gpt-4o-mini",
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 500


@app.route("/chat/<session_id>", methods=["POST"])
def chat_with_session(session_id: str):
    """Chat dengan session — menyimpan conversation history."""
    data = request.json
    
    if not data or not data.get("message"):
        return jsonify({"error": "Field 'message' wajib diisi"}), 400
    
    message = data["message"]
    
    # Ambil history conversation
    if session_id not in conversations:
        conversations[session_id] = []
    
    history = conversations[session_id]
    
    try:
        response = generate_with_context(message, history)
        
        # Simpan ke history
        history.append({"role": "user", "content": message})
        history.append({"role": "assistant", "content": response})
        
        # Batasi history max 20 messages (hemat token)
        if len(history) > 20:
            history = history[-20:]
            conversations[session_id] = history
        
        return jsonify({
            "response": response,
            "session_id": session_id,
            "history_length": len(history),
        })
    except Exception as e:
        return jsonify({"error": str(e)}), 500


@app.errorhandler(404)
def not_found(e):
    return jsonify({"error": "Endpoint tidak ditemukan"}), 404


@app.errorhandler(500)
def internal_error(e):
    return jsonify({"error": "Internal server error"}), 500


if __name__ == "__main__":
    port = int(os.getenv("PORT", 8080))
    debug = os.getenv("FLASK_ENV") == "development"
    app.run(host="0.0.0.0", port=port, debug=debug)

# Base image — Python 3.11 slim (lebih kecil dari full image)
FROM python:3.11-slim

# Prevent Python dari buffer stdout/stderr (penting untuk logging)
ENV PYTHONUNBUFFERED=1
ENV PYTHONDONTWRITEBYTECODE=1

# Set working directory
WORKDIR /app

# Install system dependencies yang mungkin dibutuhkan
RUN apt-get update && \
    apt-get install -y --no-install-recommends gcc && \
    rm -rf /var/lib/apt/lists/*

# Copy dan install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir --upgrade pip && \
    pip install --no-cache-dir -r requirements.txt

# Copy source code
COPY . .

# Expose port (Railway inject PORT automatically)
EXPOSE 8080

# Run dengan Gunicorn untuk production
# Railway inject PORT env var, jadi pakai itu
CMD gunicorn main:app --bind 0.0.0.0:${PORT:-8080} --workers 2 --timeout 120

# Copy environment variables template
cp .env.example .env

# Edit .env, tambahkan API key kamu
# OPENAI_API_KEY=sk-your-key-here

# Install dependencies
pip install -r requirements.txt

# Jalankan
python main.py

# Test health endpoint
curl http://localhost:8080/health

# Test chat endpoint
curl -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Halo, siapa kamu?"}'

# Build image
docker build -t ai-agent .

# Run container
docker run -d -p 8080:8080 \
  -e OPENAI_API_KEY=sk-your-key-here \
  --name ai-agent \
  ai-agent

# Test
curl http://localhost:8080/health
curl -X POST http://localhost:8080/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Halo, siapa kamu?"}'

# Lihat logs
docker logs -f ai-agent

version: '3.8'

services:
  ai-agent:
    build: .
    ports:
      - "8080:8080"
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - FLASK_ENV=development
    restart: unless-stopped

docker compose up --build

git init
git add .
git commit -m "feat: AI agent with Docker + Flask API"
git remote add origin https://github.com/username/ai-agent.git
git push -u origin main

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    message = data.get("message", "")
    
    logger.info(f"Chat request received: {message[:50]}...")
    
    try:
        response = generate_response(message)
        logger.info(f"Response generated successfully")
        return jsonify({"response": response})
    except Exception as e:
        logger.error(f"Error: {str(e)}")
        return jsonify({"error": str(e)}), 500

@app.route("/health", methods=["GET"])
def health():
    return jsonify({"status": "ok"})

from functools import wraps
from collections import defaultdict
import time

request_counts = defaultdict(list)

def rate_limit(max_requests=10, window=60):
    def decorator(f):
        @wraps(f)
        def wrapped(*args, **kwargs):
            now = time.time()
            client_ip = request.remote_addr
            
            # Hapus request yang sudah di luar window
            request_counts[client_ip] = [
                t for t in request_counts[client_ip] if now - t < window
            ]
            
            if len(request_counts[client_ip]) >= max_requests:
                return jsonify({"error": "Rate limit exceeded"}), 429
            
            request_counts[client_ip].append(now)
            return f(*args, **kwargs)
        return wrapped
    return decorator

@app.route("/chat", methods=["POST"])
@rate_limit(max_requests=20, window=60)
def chat():
    # ... existing code

@app.route("/chat", methods=["POST"])
def chat():
    data = request.json
    
    if not data:
        return jsonify({"error": "Request body required"}), 400
    
    message = data.get("message")
    if not message or not isinstance(message, str):
        return jsonify({"error": "Field 'message' harus string"}), 400
    
    if len(message) > 5000:
        return jsonify({"error": "Message maksimal 5000 karakter"}), 400
    
    # ... process message

async function sendMessage(message: string): Promise<string> {
  const response = await fetch("https://your-agent.up.railway.app/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ message }),
  });
  
  if (!response.ok) {
    throw new Error("Failed to get response");
  }
  
  const data = await response.json();
  return data.response;
}

# Cek logs di Railway dashboard
# Biasanya karena:
# 1. requirements.txt ada typo
# 2. Dockerfile syntax error
# 3. Missing dependency

# Tambahkan retry logic untuk API call
import time

def generate_with_retry(message, retries=3):
    for attempt in range(retries):
        try:
            return generate_response(message)
        except Exception as e:
            if attempt == retries - 1:
                raise
            time.sleep(2 ** attempt)  # Exponential backoff