Add Docker Compose setup with PostgreSQL, Redis, and Nginx; implement caching and database models

docker-compose.yml

@@ -0,0 +1,57 @@
+services:
+  postgres:
+    image: postgres:15-alpine
+    container_name: sentiment-api-postgres
+    environment:
+      POSTGRES_DB: sentiment
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: pass
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U user -d sentiment"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  redis:
+    image: redis:7-alpine
+    container_name: sentiment-api-redis
+    ports:
+      - "6379:6379"  # Redis default port
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 3s
+      retries: 5
+    command: redis-server --maxmemory 256mb --maxmemory-policy allkeys-lru
+
+  nginx:
+    image: nginx:alpine
+    container_name: sentiment-api-nginx
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+    depends_on:
+      - api
+
+  api:
+    build: .
+    container_name: sentiment-api
+    ports:
+      - "8000:8000"
+    environment:
+      DATABASE_URL: postgresql://user:pass@postgres:5432/sentiment
+      REDIS_URL: redis://redis:6379  # ← ADD THIS LINE
+    depends_on:
+      postgres:
+        condition: service_healthy
+      redis:  # ← ADD THIS
+        condition: service_healthy
+    command: uvicorn src.main:app --host 0.0.0.0 --port 8000
+
+volumes:
+  postgres_data:

nginx/nginx.conf

@@ -0,0 +1,19 @@
+events {
+    worker_connections 1024;
+}
+
+http {
+    upstream api {
+        server sentiment-api:8000;
+    }
+
+    server {
+        listen 80;
+        
+        location / {
+            proxy_pass http://api;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+        }
+    }
+}

requirements.txt

@@ -8,4 +8,11 @@ httpx==0.28.1
 
 # Testing
 pytest==8.3.4
-pytest-cov==6.0.0
+pytest-cov==6.0.0
+
+# Database
+psycopg2-binary==2.9.9
+sqlalchemy==2.0.23
+
+# Cache
+redis==5.2.1

src/cache.py

@@ -0,0 +1,151 @@
+"""
+Redis cache layer for sentiment analysis API
+
+Caches ML inference results to avoid redundant model calls
+Uses Redis for sub-millisecond lookup times
+"""
+
+import redis
+import hashlib
+import json
+import os
+from typing import Optional, Dict, Any
+
+# Get Redis URL from environment variable
+REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
+
+# Create Redis client
+# decode_responses=True converts bytes to strings automatically
+redis_client = redis.from_url(REDIS_URL, decode_responses=True)
+
+# Cache TTL (Time To Live) - how long to keep cached results
+CACHE_TTL_SECONDS = 3600  # 1 hour
+
+
+def generate_cache_key(text: str) -> str:
+    """
+    Generate a unique cache key for the input text
+    
+    Uses SHA-256 hash to create consistent keys
+    Same text always generates same key
+    
+    Args:
+        text: Input text to analyze
+        
+    Returns:
+        Cache key string (e.g., "sentiment:abc123...")
+    """
+    # Create hash of the text (consistent for same input)
+    text_hash = hashlib.sha256(text.encode()).hexdigest()[:16]
+    return f"sentiment:{text_hash}"
+
+
+def get_cached_result(text: str) -> Optional[Dict[str, Any]]:
+    """
+    Retrieve cached sentiment analysis result
+    
+    Args:
+        text: Input text to look up
+        
+    Returns:
+        Cached result dict if found, None if cache miss
+    """
+    try:
+        cache_key = generate_cache_key(text)
+        cached_data = redis_client.get(cache_key)
+        
+        if cached_data:
+            # Parse JSON string back to dict
+            return json.loads(cached_data)
+        
+        return None
+    except Exception as e:
+        # If Redis fails, log but don't crash
+        print(f"Cache retrieval error: {e}")
+        return None
+
+
+def cache_result(text: str, result: Dict[str, Any]) -> bool:
+    """
+    Store sentiment analysis result in cache
+    
+    Args:
+        text: Input text that was analyzed
+        result: Analysis result to cache
+        
+    Returns:
+        True if cached successfully, False otherwise
+    """
+    try:
+        cache_key = generate_cache_key(text)
+        
+        # Convert dict to JSON string
+        result_json = json.dumps(result)
+        
+        # Store in Redis with TTL
+        redis_client.setex(
+            cache_key,
+            CACHE_TTL_SECONDS,
+            result_json
+        )
+        
+        return True
+    except Exception as e:
+        print(f"Cache storage error: {e}")
+        return False
+
+
+def get_cache_stats() -> Dict[str, Any]:
+    """
+    Get Redis cache statistics
+    
+    Returns:
+        Dict with cache info (memory usage, keys, hits, etc.)
+    """
+    try:
+        info = redis_client.info("stats")
+        memory = redis_client.info("memory")
+        
+        # Count sentiment-related keys
+        sentiment_keys = len(redis_client.keys("sentiment:*"))
+        
+        return {
+            "status": "connected",
+            "total_keys": redis_client.dbsize(),
+            "sentiment_keys": sentiment_keys,
+            "memory_used_mb": round(memory["used_memory"] / 1024 / 1024, 2),
+            "hits": info.get("keyspace_hits", 0),
+            "misses": info.get("keyspace_misses", 0),
+            "hit_rate": round(
+                info.get("keyspace_hits", 0) / 
+                max(info.get("keyspace_hits", 0) + info.get("keyspace_misses", 0), 1) * 100,
+                2
+            )
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": str(e)
+        }
+
+
+def clear_cache() -> bool:
+    """
+    Clear all sentiment cache entries
+    
+    WARNING: This removes all cached results
+    
+    Returns:
+        True if cleared successfully
+    """
+    try:
+        # Get all sentiment keys
+        keys = redis_client.keys("sentiment:*")
+        
+        if keys:
+            redis_client.delete(*keys)
+        
+        return True
+    except Exception as e:
+        print(f"Cache clear error: {e}")
+        return False

src/database.py

@@ -0,0 +1,91 @@
+"""
+Database connection and models for sentiment API
+
+Uses SQLAlchemy ORM for clean database interactions
+PostgreSQL for persistent storage (runs in Docker container - FREE!)
+"""
+
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from datetime import datetime
+import os
+
+# Get database URL from environment variable
+# Set by docker-compose.yml
+DATABASE_URL = os.getenv(
+    "DATABASE_URL",
+    "postgresql://user:pass@localhost:5432/sentiment"  # Fallback for local dev
+)
+
+# Create database engine
+# This connects to PostgreSQL container
+engine = create_engine(DATABASE_URL)
+
+# Create session factory
+# Sessions are like "conversations" with the database
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Base class for database models
+Base = declarative_base()
+
+
+# Database Model (Table Definition)
+class SentimentAnalysis(Base):
+    """
+    Stores sentiment analysis results
+    
+    Table: sentiment_analyses
+    """
+    __tablename__ = "sentiment_analyses"
+    
+    # Primary key (auto-incrementing ID)
+    id = Column(Integer, primary_key=True, index=True)
+    
+    # The text that was analyzed
+    text = Column(String(512), nullable=False)
+    
+    # Sentiment result (POSITIVE or NEGATIVE)
+    sentiment = Column(String(50), nullable=False)
+    
+    # Confidence score (0.0 to 1.0)
+    confidence = Column(Float, nullable=False)
+    
+    # Processing time in milliseconds
+    processing_time_ms = Column(Integer, nullable=False)
+    
+    # When this analysis was created
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+
+
+# Create all tables in the database
+# This runs when the app starts
+def init_db():
+    """
+    Initialize database tables
+    
+    Creates sentiment_analyses table if it doesn't exist
+    Safe to call multiple times (won't recreate existing tables)
+    """
+    Base.metadata.create_all(bind=engine)
+
+
+# Dependency for FastAPI routes
+# Provides a database session to each request
+def get_db():
+    """
+    FastAPI dependency that provides a database session
+    
+    Usage in routes:
+        @app.post("/analyze")
+        def analyze(db: Session = Depends(get_db)):
+            # Use db here
+            pass
+    
+    Automatically closes session after request
+    """
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

src/main.py

@@ -1,7 +1,11 @@
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel, Field
 from transformers import pipeline
+from sqlalchemy.orm import Session
+from fastapi import Depends
+from .database import init_db, get_db, SentimentAnalysis
 import time
+from . import cache
 
 app = FastAPI(
     title="Sentiment Analysis API",
@@ -9,6 +13,14 @@ app = FastAPI(
     version="1.0.0"
 )
 
+# Initialize database on startup
+@app.on_event("startup")
+def startup_event():
+    """Create database tables if they don't exist"""
+    print("Initializing database...")
+    init_db()
+    print("Database ready!")
+
 # Load model once at startup
 print("Loading sentiment analysis model...")
 sentiment_analyzer = pipeline(
@@ -26,6 +38,7 @@ class SentimentResponse(BaseModel):
     sentiment: str
     confidence: float
     processing_time_ms: int
+    cached: bool = False  # ← ADD THIS LINE
 
 @app.get("/")
 def root():
@@ -37,29 +50,92 @@ def root():
     }
 
 @app.post("/analyze", response_model=SentimentResponse)
-def analyze_sentiment(request: TextRequest):
+def analyze_sentiment(
+    request: TextRequest,
+    db: Session = Depends(get_db)
+):
     """
-    Analyze sentiment of input text.
+    Analyze sentiment of input text with caching.
+    
     Returns sentiment (POSITIVE/NEGATIVE) with confidence score.
+    Stores result in PostgreSQL database and Redis cache.
     """
     start_time = time.time()
     
     try:
-        # Run inference
+        cached_result = cache.get_cached_result(request.text)
+        
+        if cached_result:
+            # Cache HIT - return cached result
+            print(f"Cache HIT for: {request.text[:50]}")
+            
+            # Add cache indicator
+            cached_result["cached"] = True
+            cached_result["processing_time_ms"] = int((time.time() - start_time) * 1000)
+            
+            return SentimentResponse(**cached_result)
+        
+        # Cache MISS - run ML model
+        print(f"Cache MISS for: {request.text[:50]}")
+        
         result = sentiment_analyzer(request.text)[0]
         
         processing_time = int((time.time() - start_time) * 1000)
         
-        return SentimentResponse(
+        # Create response
+        response_data = {
+            "text": request.text,
+            "sentiment": result['label'],
+            "confidence": round(result['score'], 4),
+            "processing_time_ms": processing_time,
+            "cached": False  # NEW: indicate this wasn't cached
+        }
+        
+        # Store in database
+        db_analysis = SentimentAnalysis(
             text=request.text,
             sentiment=result['label'],
             confidence=round(result['score'], 4),
             processing_time_ms=processing_time
         )
+        db.add(db_analysis)
+        db.commit()
+        db.refresh(db_analysis)
+        
+        # ===== NEW: Store in cache =====
+        cache.cache_result(request.text, response_data)
+        # ===============================
+        
+        return SentimentResponse(**response_data)
+        
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/health")
 def health():
     """Kubernetes-style health check"""
-    return {"status": "ok"}
+    return {"status": "ok"}
+
+@app.get("/cache/stats")
+def get_cache_statistics():
+    """
+    Get Redis cache statistics
+    
+    Shows cache hit rate, memory usage, and key counts
+    """
+    return cache.get_cache_stats()
+
+
+@app.delete("/cache/clear")
+def clear_cache_endpoint():
+    """
+    Clear all cached sentiment results
+    
+    Use this to force fresh analysis for all requests
+    """
+    success = cache.clear_cache()
+    
+    if success:
+        return {"message": "Cache cleared successfully"}
+    else:
+        return {"message": "Failed to clear cache"}