Docker + Railway Deployment for LangChain/FastAPI

├── app/
│   ├── __init__.py
│   ├── main.py              # FastAPI app entrypoint
│   ├── routers/             # API route handlers
│   ├── services/            # LangChain logic
│   └── models/              # Pydantic schemas
├── Dockerfile               # Multi-stage production build
├── docker-compose.yml       # Local dev + testing
├── railway.toml             # Railway deployment config
├── .env.example             # Template for env vars
└── requirements.txt         # Python dependencies

version: "3.9"

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: langchain-api
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql+asyncpg://postgres:postgres@db:5432/langchain
      - REDIS_URL=redis://redis:6379/0
      - ENVIRONMENT=development
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s

  db:
    image: pgvector/pgvector:pg16
    container_name: langchain-db
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=langchain
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    container_name: langchain-redis
    ports:
      - "6379:6379"
    volumes:
      - redisdata:/data
    command: redis-server --appendonly yes
    restart: unless-stopped

volumes:
  pgdata:
  redisdata:

from fastapi import FastAPI, status
from fastapi.responses import JSONResponse
from contextlib import asynccontextmanager
from app.services.database import db
from app.services.cache import redis
from app.services.llm import llm

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup: verify critical connections
    try:
        await db.connect()
        await redis.ping()
        await llm.initialize()
    except Exception as e:
        print(f"Startup failed: {e}")
    yield
    # Shutdown: clean up connections
    await db.disconnect()

app = FastAPI(title="LangChain API", lifespan=lifespan)

@app.get("/health")
async def health_check():
    checks = {
        "status": "healthy",
        "database": "unknown",
        "redis": "unknown",
        "llm": "unknown",
    }
    status_code = 200

    try:
        await db.execute("SELECT 1")
        checks["database"] = "up"
    except Exception as e:
        checks["database"] = f"down: {e}"
        status_code = 503

    try:
        await redis.ping()
        checks["redis"] = "up"
    except Exception as e:
        checks["redis"] = f"down: {e}"
        status_code = 503

    try:
        checks["llm"] = "up" if llm.is_initialized else "not_initialized"
    except Exception as e:
        checks["llm"] = f"down: {e}"
        status_code = 503

    checks["status"] = "healthy" if status_code == 200 else "degraded"

    return JSONResponse(content=checks, status_code=status_code)

# Application
ENVIRONMENT=production
LOG_LEVEL=INFO

# Database
DATABASE_URL=postgresql+asyncpg://user:password@host:5432/dbname

# Redis
REDIS_URL=redis://user:password@host:6379/0

# Authentication
JWT_SECRET=your-256-bit-secret-key-here
JWT_ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=30

# LLM Provider
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...

# LangChain Configuration
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=ls-...
LANGCHAIN_PROJECT=your-project-name

# Optional: Vector Store
USE_PGVECTOR=true