Fix backend API files for HF deployment

README.md

@@ -1,212 +1,20 @@
-# AI Backend with RAG + Authentication
+---
+title: AI Textbook Backend
+emoji: 🤖
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_file: main.py
+pinned: false
+---
 
-A scalable backend featuring authentication, RAG capabilities, and integration with external services. The system uses Better Auth for authentication, Qdrant for vector storage, Neon Postgres for relational data, and Google's Gemini models for embeddings and chat functionality.
+# AI Native Textbook Backend
 
-## Architecture Overview
-
-```
-┌─────────────────┐    ┌──────────────────┐    ┌──────────────────┐
-│   Frontend      │────│   FastAPI        │────│  Better Auth     │
-│   (Future)      │    │   Backend        │    │   Service        │
-└─────────────────┘    └──────────────────┘    └──────────────────┘
-                              │
-         ┌────────────────────┼────────────────────┐
-         │                    │                    │
-   ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
-   │  Qdrant     │    │  Neon       │    │  Gemini     │
-   │  Vector DB  │    │  Postgres   │    │  API        │
-   └─────────────┘    └─────────────┘    └─────────────┘
-```
+RAG-based chatbot backend for Physical AI & Humanoid Robotics textbook.
 
 ## Features
-
-- **Authentication**: JWT-based authentication with Better Auth
-- **RAG Pipeline**: Retrieval-Augmented Generation with Qdrant vector database
-- **AI Integration**: Google Gemini for embeddings and chat responses
-- **Database**: Neon Postgres for user data and chat history
-- **Security**: Password hashing, JWT validation, user isolation
-- **Scalability**: Async architecture with connection pooling
-
-## Prerequisites
-
-- Python 3.9+
-- Qdrant vector database instance
-- Neon Postgres database
-- Google Gemini API key
-- Node.js (for development tools, optional)
-
-## Setup
-
-### 1. Clone the repository
-
-```bash
-git clone <repository-url>
-cd backend
-```
-
-### 2. Create a virtual environment
-
-```bash
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-```
-
-### 3. Install dependencies
-
-```bash
-pip install -r requirements.txt
-```
-
-### 4. Configure environment variables
-
-Copy the example environment file:
-
-```bash
-cp .env.example .env
-```
-
-Then edit `.env` with your actual configuration:
-
-```env
-# API Configuration
-GEMINI_API_KEY=your_gemini_api_key_here
-QDRANT_URL=your_qdrant_url_here
-QDRANT_API_KEY=your_qdrant_api_key_here
-NEON_DB_URL=your_neon_db_connection_string_here
-
-# JWT Configuration
-SECRET_KEY=your_secret_key_here  # Use a strong, random secret key
-JWT_EXPIRES_IN=3600
-
-# Application Configuration
-DEBUG=false
-LOG_LEVEL=info
-```
-
-### 5. Run the application
-
-```bash
-cd src
-python main.py
-```
-
-Or using uvicorn directly:
-
-```bash
-cd src
-uvicorn main:app --reload --host 0.0.0.0 --port 8000
-```
-
-The application will be available at `http://localhost:8000`
-
-## API Endpoints
-
-### Authentication
-- `POST /auth/signup` - User registration
-- `POST /auth/login` - User login
-- `GET /auth/me` - Get current user info
-
-### RAG & Embeddings
-- `POST /embed` - Generate embeddings for text
-- `POST /save-document` - Save and embed a document
-- `POST /search` - Semantic search in documents
-- `POST /chat` - Chat with RAG context
-
-### History
-- `GET /history` - Get chat history
-- `GET /history/{conversation_id}` - Get specific conversation
-
-### Health
-- `GET /health` - Health check endpoint
-
-## Project Structure
-
-```
-backend/
-├── src/
-│   ├── __init__.py
-│   ├── main.py                 # Application entry point
-│   ├── config/                 # Configuration management
-│   │   ├── __init__.py
-│   │   ├── settings.py         # App settings and env vars
-│   │   └── database.py         # Database configuration
-│   ├── auth/                   # Authentication module
-│   ├── db/                     # Database module
-│   │   ├── __init__.py
-│   │   ├── base.py             # Base model class
-│   │   ├── models/             # SQLAlchemy models
-│   │   ├── database.py         # Database connection
-│   │   └── crud.py             # CRUD operations
-│   ├── qdrant/                 # Vector database module
-│   ├── embeddings/             # Embedding module
-│   ├── rag/                    # RAG pipeline module
-│   ├── routes/                 # API routes
-│   ├── models/                 # Pydantic models
-│   ├── utils/                  # Utility functions
-│   └── scripts/                # Utility scripts
-├── tests/                      # Test suite
-├── requirements.txt            # Python dependencies
-├── .env.example                # Environment variables template
-└── README.md                   # Documentation
-```
-
-## Development
-
-### Running tests
-
-```bash
-cd backend
-python -m pytest tests/ -v
-```
-
-### Running with auto-reload during development
-
-```bash
-cd src
-uvicorn main:app --reload
-```
-
-## Environment Variables
-
-| Variable | Description | Required |
-|----------|-------------|----------|
-| GEMINI_API_KEY | Google Gemini API key | Yes |
-| QDRANT_URL | Qdrant vector database URL | Yes |
-| QDRANT_API_KEY | Qdrant API key (if secured) | No |
-| NEON_DB_URL | Neon Postgres connection string | Yes |
-| SECRET_KEY | JWT secret key | Yes |
-| JWT_EXPIRES_IN | JWT expiration time in seconds | No (default: 3600) |
-| DEBUG | Enable debug mode | No (default: false) |
-| LOG_LEVEL | Logging level | No (default: info) |
-
-## Security Considerations
-
-- Always use HTTPS in production
-- Store secrets securely (not in version control)
-- Validate and sanitize all user inputs
-- Use parameterized queries to prevent SQL injection
-- Implement rate limiting to prevent abuse
-- Use strong, randomly generated secret keys
-
-## Performance
-
-- Async architecture for high concurrency
-- Connection pooling for database operations
-- Caching mechanisms for frequently accessed data
-- Optimized vector search with Qdrant
-- Efficient embedding processing pipeline
-
-## Contributing
-
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Make your changes
-4. Add tests if applicable
-5. Run tests (`python -m pytest`)
-6. Commit your changes (`git commit -m 'Add amazing feature'`)
-7. Push to the branch (`git push origin feature/amazing-feature`)
-8. Open a Pull Request
-
-## License
-
-[Add your license here]
+- RAG-based Q&A with Qdrant vector database
+- OpenRouter LLM integration
+- Urdu translation support
+- User authentication with JWT
+- Personalized learning roadmaps

api/auth.py

@@ -2,24 +2,25 @@ from fastapi import APIRouter, HTTPException, Depends, Header
 from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from pydantic import BaseModel, EmailStr
 from typing import Optional
-from sqlalchemy.orm import Session
-from sqlalchemy.exc import IntegrityError
 import logging
 
+logger = logging.getLogger(__name__)
+router = APIRouter()
+security = HTTPBearer(auto_error=False)
+
 # Import database utilities
 try:
     from database.db import get_db
     from database.models import User as DBUser
     from auth.jwt_utils import hash_password, verify_password, create_access_token, get_current_user_id_from_token
+    from sqlalchemy.orm import Session
+    from sqlalchemy.exc import IntegrityError
     DB_ENABLED = True
 except ImportError:
     DB_ENABLED = False
+    get_db = None
     logging.warning("Database modules not available. Auth will use mock mode.")
 
-logger = logging.getLogger(__name__)
-router = APIRouter()
-security = HTTPBearer()
-
 class SignupRequest(BaseModel):
     email: EmailStr
     password: str
@@ -44,11 +45,19 @@ class UserProfileResponse(BaseModel):
     hardware_background: Optional[str]
     experience_level: Optional[str]
 
+
+def get_db_session():
+    """Get database session or None if DB not enabled"""
+    if DB_ENABLED and get_db:
+        return Depends(get_db)
+    return None
+
+
 @router.post("/auth/signup", response_model=AuthResponse)
-async def signup(request: SignupRequest, db: Session = Depends(get_db) if DB_ENABLED else None):
+async def signup(request: SignupRequest):
     """Handle user registration with background information"""
     try:
-        if not DB_ENABLED or db is None:
+        if not DB_ENABLED:
             # Mock mode for testing without database
             return AuthResponse(
                 user_id="mock_user_id",
@@ -57,59 +66,68 @@ async def signup(request: SignupRequest, db: Session = Depends(get_db) if DB_ENA
                 token_type="bearer"
             )
 
-        # Validate password strength
-        if len(request.password) < 8:
-            raise HTTPException(status_code=400, detail="Password must be at least 8 characters long")
-
-        # Validate background fields
-        if request.software_background and len(request.software_background) < 10:
-            raise HTTPException(status_code=400, detail="Software background must be at least 10 characters")
-        if request.hardware_background and len(request.hardware_background) < 10:
-            raise HTTPException(status_code=400, detail="Hardware background must be at least 10 characters")
-
-        # Hash the password
-        hashed_password = hash_password(request.password)
-
-        # Create new user in database
-        db_user = DBUser(
-            email=request.email,
-            password_hash=hashed_password,
-            software_background=request.software_background,
-            hardware_background=request.hardware_background,
-            experience_level=request.experience_level or "Intermediate"
-        )
-
-        db.add(db_user)
-        db.commit()
-        db.refresh(db_user)
-
-        # Generate JWT token
-        access_token = create_access_token(data={
-            "sub": str(db_user.id),
-            "email": db_user.email
-        })
-
-        return AuthResponse(
-            user_id=str(db_user.id),
-            email=db_user.email,
-            access_token=access_token,
-            token_type="bearer"
-        )
-
-    except IntegrityError:
-        db.rollback()
-        raise HTTPException(status_code=400, detail="Email already registered")
+        # Get database session
+        from database.db import SessionLocal
+        db = SessionLocal()
+
+        try:
+            # Validate password strength
+            if len(request.password) < 8:
+                raise HTTPException(status_code=400, detail="Password must be at least 8 characters long")
+
+            # Validate background fields
+            if request.software_background and len(request.software_background) < 10:
+                raise HTTPException(status_code=400, detail="Software background must be at least 10 characters")
+            if request.hardware_background and len(request.hardware_background) < 10:
+                raise HTTPException(status_code=400, detail="Hardware background must be at least 10 characters")
+
+            # Hash the password
+            hashed_password = hash_password(request.password)
+
+            # Create new user in database
+            db_user = DBUser(
+                email=request.email,
+                password_hash=hashed_password,
+                software_background=request.software_background,
+                hardware_background=request.hardware_background,
+                experience_level=request.experience_level or "Intermediate"
+            )
+
+            db.add(db_user)
+            db.commit()
+            db.refresh(db_user)
+
+            # Generate JWT token
+            access_token = create_access_token(data={
+                "sub": str(db_user.id),
+                "email": db_user.email
+            })
+
+            return AuthResponse(
+                user_id=str(db_user.id),
+                email=db_user.email,
+                access_token=access_token,
+                token_type="bearer"
+            )
+
+        except IntegrityError:
+            db.rollback()
+            raise HTTPException(status_code=400, detail="Email already registered")
+        finally:
+            db.close()
+
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Error during signup: {str(e)}")
-        if db:
-            db.rollback()
         raise HTTPException(status_code=500, detail=f"Error during signup: {str(e)}")
 
+
 @router.post("/auth/login", response_model=AuthResponse)
-async def login(request: LoginRequest, db: Session = Depends(get_db) if DB_ENABLED else None):
+async def login(request: LoginRequest):
     """Handle user login"""
     try:
-        if not DB_ENABLED or db is None:
+        if not DB_ENABLED:
             # Mock mode for testing without database
             return AuthResponse(
                 user_id="mock_user_id",
@@ -118,27 +136,35 @@ async def login(request: LoginRequest, db: Session = Depends(get_db) if DB_ENABL
                 token_type="bearer"
             )
 
-        # Find user by email
-        user = db.query(DBUser).filter(DBUser.email == request.email).first()
-        if not user:
-            raise HTTPException(status_code=401, detail="Invalid credentials")
+        # Get database session
+        from database.db import SessionLocal
+        db = SessionLocal()
 
-        # Verify password
-        if not verify_password(request.password, user.password_hash):
-            raise HTTPException(status_code=401, detail="Invalid credentials")
+        try:
+            # Find user by email
+            user = db.query(DBUser).filter(DBUser.email == request.email).first()
+            if not user:
+                raise HTTPException(status_code=401, detail="Invalid credentials")
 
-        # Generate JWT token
-        access_token = create_access_token(data={
-            "sub": str(user.id),
-            "email": user.email
-        })
+            # Verify password
+            if not verify_password(request.password, user.password_hash):
+                raise HTTPException(status_code=401, detail="Invalid credentials")
 
-        return AuthResponse(
-            user_id=str(user.id),
-            email=user.email,
-            access_token=access_token,
-            token_type="bearer"
-        )
+            # Generate JWT token
+            access_token = create_access_token(data={
+                "sub": str(user.id),
+                "email": user.email
+            })
+
+            return AuthResponse(
+                user_id=str(user.id),
+                email=user.email,
+                access_token=access_token,
+                token_type="bearer"
+            )
+
+        finally:
+            db.close()
 
     except HTTPException:
         raise
@@ -146,15 +172,15 @@ async def login(request: LoginRequest, db: Session = Depends(get_db) if DB_ENABL
         logger.error(f"Error during login: {str(e)}")
         raise HTTPException(status_code=500, detail="Error during login")
 
+
 @router.get("/auth/profile", response_model=UserProfileResponse)
 async def get_profile(
     authorization: Optional[str] = Header(None),
-    credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
-    db: Session = Depends(get_db) if DB_ENABLED else None
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)
 ):
     """Get user profile information"""
     try:
-        if not DB_ENABLED or db is None:
+        if not DB_ENABLED:
             # Mock mode for testing without database
             return UserProfileResponse(
                 user_id="mock_user_id",
@@ -166,10 +192,10 @@ async def get_profile(
 
         # Get token from Authorization header or credentials
         token = None
-        if authorization:
-            token = authorization
-        elif credentials:
+        if credentials:
             token = credentials.credentials
+        elif authorization and authorization.startswith("Bearer "):
+            token = authorization.replace("Bearer ", "")
 
         if not token:
             raise HTTPException(status_code=401, detail="Authorization token required")
@@ -179,18 +205,25 @@ async def get_profile(
         if not user_id:
             raise HTTPException(status_code=401, detail="Invalid or expired token")
 
-        # Get user from database
-        user = db.query(DBUser).filter(DBUser.id == user_id).first()
-        if not user:
-            raise HTTPException(status_code=404, detail="User not found")
+        # Get database session
+        from database.db import SessionLocal
+        db = SessionLocal()
 
-        return UserProfileResponse(
-            user_id=str(user.id),
-            email=user.email,
-            software_background=user.software_background,
-            hardware_background=user.hardware_background,
-            experience_level=user.experience_level
-        )
+        try:
+            # Get user from database
+            user = db.query(DBUser).filter(DBUser.id == user_id).first()
+            if not user:
+                raise HTTPException(status_code=404, detail="User not found")
+
+            return UserProfileResponse(
+                user_id=str(user.id),
+                email=user.email,
+                software_background=user.software_background,
+                hardware_background=user.hardware_background,
+                experience_level=user.experience_level
+            )
+        finally:
+            db.close()
 
     except HTTPException:
         raise
@@ -198,6 +231,7 @@ async def get_profile(
         logger.error(f"Error retrieving profile: {str(e)}")
         raise HTTPException(status_code=500, detail="Error retrieving profile")
 
+
 @router.get("/auth/health")
 async def auth_health():
     """Health check for auth service"""

api/translation.py

@@ -1,30 +1,38 @@
-from fastapi import APIRouter, HTTPException, Depends, Header
+from fastapi import APIRouter, HTTPException, Header
 from pydantic import BaseModel
 from typing import Optional
-from sqlalchemy.orm import Session
-from sqlalchemy.exc import IntegrityError
 import hashlib
 import logging
 import os
 
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
 # Import dependencies
 try:
     from services.translation_service import TranslationService
     from services.rate_limiter import RateLimiter
-    from database.db import get_db
-    from database.models import Translation
     from auth.jwt_utils import get_current_user_id_from_token
+    SERVICES_ENABLED = True
+except ImportError as e:
+    SERVICES_ENABLED = False
+    logging.warning(f"Services not available: {str(e)}")
+
+try:
+    from database.db import SessionLocal
+    from database.models import Translation
     DB_ENABLED = True
 except ImportError as e:
     DB_ENABLED = False
-    logging.warning(f"Database or dependencies not available: {str(e)}")
-
-logger = logging.getLogger(__name__)
-router = APIRouter()
+    logging.warning(f"Database not available: {str(e)}")
 
 # Initialize services
-translation_service = TranslationService()
-rate_limiter = RateLimiter(max_requests=10, window_seconds=3600)  # 10 translations/hour
+if SERVICES_ENABLED:
+    translation_service = TranslationService()
+    rate_limiter = RateLimiter(max_requests=10, window_seconds=3600)
+else:
+    translation_service = None
+    rate_limiter = None
 
 # Cost and performance metrics (in-memory)
 translation_metrics = {
@@ -42,9 +50,9 @@ def log_metrics():
     if total > 0:
         cache_hit_rate = (translation_metrics["cache_hits"] / total) * 100
         avg_latency = translation_metrics["total_latency_ms"] / total
-        cost_savings = (translation_metrics["cache_hits"] / total) * 100  # % of API calls saved
+        cost_savings = (translation_metrics["cache_hits"] / total) * 100
         logger.info(
-            f"📊 Translation Metrics: "
+            f"Translation Metrics: "
             f"Total={total}, Cache Hit Rate={cache_hit_rate:.1f}%, "
             f"API Calls={translation_metrics['api_calls']}, "
             f"Avg Latency={avg_latency:.0f}ms, "
@@ -75,26 +83,19 @@ class TranslationResponse(BaseModel):
     source_lang: str
     target_lang: str
 
+
 @router.post("/translate/urdu", response_model=UrduTranslationResponse)
 async def translate_to_urdu(
     request: UrduTranslationRequest,
-    authorization: Optional[str] = Header(None),
-    db: Session = Depends(get_db) if DB_ENABLED else None
+    authorization: Optional[str] = Header(None)
 ):
     """
     Translate chapter content to Urdu with JWT authentication, caching, and rate limiting
-
-    **Requirements**:
-    - JWT token in Authorization header
-    - Content hash must match SHA-256 of content
-    - Rate limit: 10 translations per user per hour
-
-    **Returns**:
-    - translated_content: Urdu translation
-    - cached: Whether result came from cache
-    - translation_id: UUID of translation record
     """
     try:
+        if not SERVICES_ENABLED:
+            raise HTTPException(status_code=503, detail="Translation service not available")
+
         # 1. Verify JWT authentication
         if not authorization or not authorization.startswith("Bearer "):
             raise HTTPException(status_code=401, detail="Missing or invalid authorization header")
@@ -130,49 +131,56 @@ async def translate_to_urdu(
             )
 
         # 4. Check database cache (if enabled)
-        if DB_ENABLED and db:
-            from database.models import Translation as DBTranslation
-
-            cached_translation = db.query(DBTranslation).filter(
-                DBTranslation.chapter_id == request.chapter_id,
-                DBTranslation.content_hash == request.content_hash,
-                DBTranslation.target_language == "urdu"
-            ).first()
-
-            if cached_translation:
-                latency_ms = (time.time() - start_time) * 1000
-                translation_metrics["cache_hits"] += 1
-                translation_metrics["total_latency_ms"] += latency_ms
-                logger.info(f"✅ Cache HIT for chapter {request.chapter_id} | Latency: {latency_ms:.0f}ms")
-                log_metrics()  # Log aggregated metrics every 10 requests
-                return UrduTranslationResponse(
-                    translated_content=cached_translation.translated_content,
-                    cached=True,
-                    translation_id=str(cached_translation.id)
-                )
+        db = None
+        if DB_ENABLED:
+            try:
+                db = SessionLocal()
+                cached_translation = db.query(Translation).filter(
+                    Translation.chapter_id == request.chapter_id,
+                    Translation.content_hash == request.content_hash,
+                    Translation.target_language == "urdu"
+                ).first()
+
+                if cached_translation:
+                    latency_ms = (time.time() - start_time) * 1000
+                    translation_metrics["cache_hits"] += 1
+                    translation_metrics["total_latency_ms"] += latency_ms
+                    logger.info(f"Cache HIT for chapter {request.chapter_id} | Latency: {latency_ms:.0f}ms")
+                    log_metrics()
+                    return UrduTranslationResponse(
+                        translated_content=cached_translation.translated_content,
+                        cached=True,
+                        translation_id=str(cached_translation.id)
+                    )
+            except Exception as db_err:
+                logger.warning(f"Database cache check failed: {str(db_err)}")
+            finally:
+                if db:
+                    db.close()
+                    db = None
 
         # 5. Cache MISS - Translate using OpenRouter
         translation_metrics["cache_misses"] += 1
         translation_metrics["api_calls"] += 1
-        logger.info(f"❌ Cache MISS for chapter {request.chapter_id} - calling OpenRouter API")
+        logger.info(f"Cache MISS for chapter {request.chapter_id} - calling OpenRouter API")
 
         api_start_time = time.time()
         try:
             translated_text = translation_service.translate_to_urdu(request.content)
             api_latency_ms = (time.time() - api_start_time) * 1000
-            logger.info(f"🌐 OpenRouter API call successful | API Latency: {api_latency_ms:.0f}ms")
+            logger.info(f"OpenRouter API call successful | API Latency: {api_latency_ms:.0f}ms")
         except Exception as api_error:
             translation_metrics["api_failures"] += 1
-            logger.error(f"❌ OpenRouter API error: {str(api_error)}")
+            logger.error(f"OpenRouter API error: {str(api_error)}")
             # Retry once with exponential backoff
             time.sleep(2)
             try:
                 translated_text = translation_service.translate_to_urdu(request.content)
                 api_latency_ms = (time.time() - api_start_time) * 1000
-                logger.info(f"✅ Retry successful after {api_latency_ms:.0f}ms")
+                logger.info(f"Retry successful after {api_latency_ms:.0f}ms")
             except Exception as retry_error:
                 translation_metrics["api_failures"] += 1
-                logger.error(f"❌ Retry failed: {str(retry_error)}")
+                logger.error(f"Retry failed: {str(retry_error)}")
                 raise HTTPException(
                     status_code=503,
                     detail="Translation service temporarily unavailable. Please try again."
@@ -180,12 +188,12 @@ async def translate_to_urdu(
 
         # 6. Save to database (if enabled)
         translation_id = None
-        if DB_ENABLED and db:
+        if DB_ENABLED:
             try:
-                from database.models import Translation as DBTranslation
                 import uuid
+                db = SessionLocal()
 
-                db_translation = DBTranslation(
+                db_translation = Translation(
                     id=uuid.uuid4(),
                     chapter_id=request.chapter_id,
                     content_hash=request.content_hash,
@@ -203,22 +211,18 @@ async def translate_to_urdu(
                 translation_id = str(db_translation.id)
                 logger.info(f"Saved translation to database: {translation_id}")
 
-            except IntegrityError as e:
-                logger.warning(f"Duplicate translation detected (race condition): {str(e)}")
-                db.rollback()
-                # Query again to get existing translation
-                cached_translation = db.query(DBTranslation).filter(
-                    DBTranslation.chapter_id == request.chapter_id,
-                    DBTranslation.content_hash == request.content_hash,
-                    DBTranslation.target_language == "urdu"
-                ).first()
-                if cached_translation:
-                    translation_id = str(cached_translation.id)
+            except Exception as save_err:
+                logger.warning(f"Failed to save translation: {str(save_err)}")
+                if db:
+                    db.rollback()
+            finally:
+                if db:
+                    db.close()
 
         # Log final metrics
         total_latency_ms = (time.time() - start_time) * 1000
         translation_metrics["total_latency_ms"] += total_latency_ms
-        logger.info(f"💾 Translation complete | Total Latency: {total_latency_ms:.0f}ms | Cached: False")
+        logger.info(f"Translation complete | Total Latency: {total_latency_ms:.0f}ms | Cached: False")
         log_metrics()
 
         return UrduTranslationResponse(
@@ -239,9 +243,11 @@ async def translate_to_urdu(
 async def translate_text(request: TranslationRequest):
     """
     Legacy translation endpoint - translate text between languages
-    (Kept for backward compatibility with existing frontend)
     """
     try:
+        if not SERVICES_ENABLED:
+            raise HTTPException(status_code=503, detail="Translation service not available")
+
         if request.source_lang == "en" and request.target_lang == "ur":
             translated_text = translation_service.translate_to_urdu(request.text)
         elif request.source_lang == "ur" and request.target_lang == "en":
@@ -259,6 +265,8 @@ async def translate_text(request: TranslationRequest):
             target_lang=request.target_lang
         )
 
+    except HTTPException:
+        raise
     except Exception as e:
         logger.error(f"Translation error: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Error during translation: {str(e)}")
@@ -269,8 +277,9 @@ async def translation_health():
     """Health check for translation service"""
     return {
         "status": "translation service is running",
+        "services_enabled": SERVICES_ENABLED,
         "database_enabled": DB_ENABLED,
-        "rate_limiter_enabled": True
+        "rate_limiter_enabled": rate_limiter is not None
     }
 
 
@@ -280,6 +289,9 @@ async def translation_stats(
 ):
     """Get translation statistics for current user"""
     try:
+        if not SERVICES_ENABLED:
+            raise HTTPException(status_code=503, detail="Service not available")
+
         if not authorization or not authorization.startswith("Bearer "):
             raise HTTPException(status_code=401, detail="Missing authorization header")
 

requirements.txt

@@ -1,18 +1,15 @@
-fastapi>=0.104.1
-uvicorn[standard]>=0.24.0
-sqlalchemy[asyncio]>=2.0.23
-asyncpg>=0.29.0
-qdrant-client>=1.7.1
-google-generativeai>=0.4.0
-python-multipart>=0.0.6
-python-jose[cryptography]>=3.3.0
-passlib[bcrypt]>=1.7.4
-better-exceptions>=0.3.3
-python-dotenv>=1.0.0
-pydantic>=2.5.0
-pydantic-settings>=2.1.0
-httpx>=0.25.2
-pytest>=7.4.3
-pytest-asyncio>=0.21.1
-alembic>=1.13.1
-openai>=1.10.0
+fastapi==0.109.0
+uvicorn==0.27.0
+python-dotenv==1.0.0
+openai==1.12.0
+qdrant-client==1.7.0
+pydantic==2.5.3
+pydantic[email]
+python-multipart==0.0.6
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+sqlalchemy==2.0.25
+asyncpg==0.29.0
+httpx==0.26.0
+alembic==1.13.1
+psycopg2-binary