feat: oom

Dockerfile

@@ -9,7 +9,6 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     ffmpeg \
     libmagic1 \
     nodejs \
-    openjdk-21-jdk-headless \
     && rm -rf /var/lib/apt/lists/*
 
 RUN groupadd --gid 1000 appuser && \
@@ -22,12 +21,9 @@ RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt --extra-index-url https://download.pytorch.org/whl/cpu && \
     python -m spacy download en_core_web_sm
 
-RUN pip install --no-cache-dir "youtube-transcript-api>=1.2.4"
-
 COPY --chown=appuser:appuser . .
 
-# FIXED: Removed all line breaks and spaces inside the python3 -c execution string to prevent IndentationError
-RUN mkdir -p /app/models && python3 -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='ibm-granite/granite-embedding-small-english-r2', local_dir='/app/models/bge-384'); snapshot_download(repo_id='nomic-ai/nomic-embed-text-v1.5', local_dir='/app/models/bge-768'); snapshot_download(repo_id='lightonai/modernbert-embed-large', local_dir='/app/models/bge-1024'); snapshot_download(repo_id='nomic-ai/nomic-embed-vision-v1.5', local_dir='/app/models/vision'); import json, os; cfg='/app/models/vision/config.json'; d=json.load(open(cfg)); d['n_inner']=int(d['n_inner']) if isinstance(d.get('n_inner'), float) else d['n_inner']; json.dump(d, open(cfg, 'w'), indent=2)" && chown -R appuser:appuser /app/models
+RUN mkdir -p /app/models && python3 -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='ibm-granite/granite-embedding-small-english-r2', local_dir='/app/models/bge-384')" && chown -R appuser:appuser /app/models
 
 RUN mkdir -p /app/logs && \
     chown -R appuser:appuser /app/logs

app/api/server.py

@@ -37,12 +37,11 @@ async def _self_ping():
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    _logger.info("Initializing embedding service (loading all models)...")
+    _logger.info("Initializing embedding service (loading 384-dim model)...")
     loop = asyncio.get_running_loop()
-    await loop.run_in_executor(None, _embedding_service.load_all_models)
-    await loop.run_in_executor(None, _embedding_service.load_vision_model)
-    _logger.info("Embedding service initialized with dims: %s, vision=%s",
-                 _embedding_service.loaded_dimensions, _embedding_service._vision_loaded)
+    await loop.run_in_executor(None, _embedding_service.load_model, 384)
+    # await loop.run_in_executor(None, _embedding_service.load_vision_model)  # DISABLED (OOM mitigation)
+    _logger.info("Embedding service initialized with dims: %s", _embedding_service.loaded_dimensions)
 
     asyncio.create_task(_self_ping())
     yield

app/api/v1/embeddings.py

@@ -2,19 +2,19 @@ from __future__ import annotations
 
 import asyncio
 import concurrent.futures
-import io
+# import io  # DISABLED (OOM mitigation) — only used by vision
 import os
 import time
 from typing import Annotated, List, Optional
 
-import httpx
+# import httpx  # DISABLED (OOM mitigation) — only used by vision
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile, status
-from PIL import Image
+# from PIL import Image  # DISABLED (OOM mitigation)
 
 from app.api.deps import require_auth, get_embeddings_service
 from app.config import get_settings
 from app.core.logger import get_logger
-from app.models.schemas import EmbeddingItem, EmbeddingRequest, EmbeddingResponse, VisionUrlRequest
+from app.models.schemas import EmbeddingItem, EmbeddingRequest, EmbeddingResponse  # , VisionUrlRequest  # DISABLED (OOM mitigation)
 from app.services.embeddings_service import EmbeddingService
 
 router = APIRouter()
@@ -22,39 +22,39 @@ _logger = get_logger(__name__)
 _settings = get_settings()
 _MAX_WORKERS = min(32, (os.cpu_count() or 1) + 4)
 _thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=_MAX_WORKERS)
-_MAX_VISION_ITEMS = 5
-_MAX_IMAGE_BYTES = 15 * 1024 * 1024
-
-
-def _validate_image(raw: bytes, source: str) -> Image.Image:
-    # FIX: Check if the file is completely empty (0 bytes)
-    if not raw:
-        raise ValueError(f"File {source} is empty (0 bytes).")
-        
-    if len(raw) > _MAX_IMAGE_BYTES:
-        raise ValueError(f"Image {source} exceeds 15 MB limit")
-        
-    try:
-        img = Image.open(io.BytesIO(raw))
-        img.load()
-        if img.mode != "RGB":
-            img = img.convert("RGB")
-        return img
-    except Exception as exc:
-        raise ValueError(f"Invalid image {source}: {exc}")
-
-
-async def _download_image(url: str) -> bytes:
-    try:
-        async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
-            resp = await client.get(url)
-            resp.raise_for_status()
-            ctype = resp.headers.get("content-type", "")
-            if not ctype.startswith("image/"):
-                raise ValueError(f"URL {url} returned non-image Content-Type: {ctype}")
-            return resp.content
-    except httpx.HTTPError as exc:
-        raise ValueError(f"Failed to download {url}: {exc}")
+# _MAX_VISION_ITEMS = 5  # DISABLED (OOM mitigation)
+# _MAX_IMAGE_BYTES = 15 * 1024 * 1024  # DISABLED (OOM mitigation)
+
+
+# def _validate_image(raw: bytes, source: str) -> Image.Image:  # DISABLED (OOM mitigation)
+#     # FIX: Check if the file is completely empty (0 bytes)
+#     if not raw:
+#         raise ValueError(f"File {source} is empty (0 bytes).")
+#         
+#     if len(raw) > _MAX_IMAGE_BYTES:
+#         raise ValueError(f"Image {source} exceeds 15 MB limit")
+#         
+#     try:
+#         img = Image.open(io.BytesIO(raw))
+#         img.load()
+#         if img.mode != "RGB":
+#             img = img.convert("RGB")
+#         return img
+#     except Exception as exc:
+#         raise ValueError(f"Invalid image {source}: {exc}")
+
+
+# async def _download_image(url: str) -> bytes:  # DISABLED (OOM mitigation)
+#     try:
+#         async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
+#             resp = await client.get(url)
+#             resp.raise_for_status()
+#             ctype = resp.headers.get("content-type", "")
+#             if not ctype.startswith("image/"):
+#                 raise ValueError(f"URL {url} returned non-image Content-Type: {ctype}")
+#             return resp.content
+#     except httpx.HTTPError as exc:
+#         raise ValueError(f"Failed to download {url}: {exc}")
 
 
 @router.post(
@@ -126,185 +126,185 @@ async def create_embeddings(
     )
 
 
-@router.post(
-    "/embeddings/vision/file",
-    response_model=EmbeddingResponse,
-    summary="Generate embeddings from uploaded images",
-)
-async def create_vision_embeddings_file(
-    files: Annotated[List[UploadFile], File(description="Image files to embed (max 5)")],
-    token: str = Depends(require_auth),
-    embedding_service: EmbeddingService = Depends(get_embeddings_service),
-) -> EmbeddingResponse:
-    if not files:
-        raise HTTPException(status_code=400, detail={"success": False, "message": "No files provided."})
-    if len(files) > _MAX_VISION_ITEMS:
-        raise HTTPException(status_code=400, detail={"success": False, "message": f"Maximum {_MAX_VISION_ITEMS} images per request."})
-
-    if not embedding_service._vision_loaded:
-        raise HTTPException(status_code=503, detail={"success": False, "message": "Vision model not loaded."})
-
-    _logger.info("Vision embedding file request: files=%s", len(files))
-
-    dim = embedding_service.vision_dimension
-    start = time.perf_counter()
-    images: List[Image.Image] = []
-    item_results: List[EmbeddingItem] = []
-
-    for f in files:
-        t0 = time.perf_counter()
-        try:
-            # FIX: Guarantee the file cursor is at the beginning before reading!
-            await f.seek(0)
-            raw = await f.read()
-            
-            img = await asyncio.get_running_loop().run_in_executor(_thread_pool, _validate_image, raw, f.filename or "unknown")
-            images.append(img)
-        except Exception as exc:
-            elapsed = (time.perf_counter() - t0) * 1000
-            item_results.append(EmbeddingItem(
-                success=False,
-                time_ms=round(elapsed, 3),
-                error_message=str(exc),
-            ))
-
-    if not images:
-        total_ms = (time.perf_counter() - start) * 1000
-        return EmbeddingResponse(
-            success=False,
-            time_ms=round(total_ms, 3),
-            success_count=0,
-            failed_count=len(item_results),
-            error_message="No valid images could be processed.",
-            results=item_results,
-        )
-
-    try:
-        loop = asyncio.get_running_loop()
-        vectors = await loop.run_in_executor(
-            _thread_pool,
-            embedding_service.generate_image_embedding,
-            images,
-        )
-    except Exception as exc:
-        elapsed = (time.perf_counter() - start) * 1000
-        _logger.error("Vision embedding error: %s", exc)
-        for _ in range(len(images) - len(item_results)):
-            item_results.append(EmbeddingItem(success=False, time_ms=0, error_message=str(exc)))
-        return EmbeddingResponse(
-            success=False,
-            time_ms=round(elapsed, 3),
-            success_count=0,
-            failed_count=len(item_results),
-            error_message=str(exc),
-            results=item_results,
-        )
-
-    total_ms = (time.perf_counter() - start) * 1000
-    for i, vec in enumerate(vectors):
-        item_results.append(EmbeddingItem(
-            success=True,
-            time_ms=round(total_ms / len(vectors), 3),
-            embeddings=vec,
-            dimension=dim,
-        ))
-
-    success_count = sum(1 for r in item_results if r.success)
-    failed_count = len(item_results) - success_count
-    _logger.info("Vision embedding success: items=%s, success=%s, failed=%s, total_ms=%s",
-                 len(item_results), success_count, failed_count, round(total_ms, 3))
-    return EmbeddingResponse(
-        success=failed_count == 0,
-        time_ms=round(total_ms, 3),
-        success_count=success_count,
-        failed_count=failed_count,
-        results=item_results,
-    )
-
-
-@router.post(
-    "/embeddings/vision/url",
-    response_model=EmbeddingResponse,
-    summary="Generate embeddings from image URLs",
-)
-async def create_vision_embeddings_url(
-    body: VisionUrlRequest,
-    token: str = Depends(require_auth),
-    embedding_service: EmbeddingService = Depends(get_embeddings_service),
-) -> EmbeddingResponse:
-    if not embedding_service._vision_loaded:
-        raise HTTPException(status_code=503, detail={"success": False, "message": "Vision model not loaded."})
-
-    _logger.info("Vision embedding URL request: urls=%s", len(body.urls))
-
-    dim = embedding_service.vision_dimension
-    start = time.perf_counter()
-    images: List[Image.Image] = []
-    item_results: List[EmbeddingItem] = []
-
-    for url in body.urls:
-        t0 = time.perf_counter()
-        try:
-            raw = await _download_image(url)
-            img = await asyncio.get_running_loop().run_in_executor(_thread_pool, _validate_image, raw, url)
-            images.append(img)
-        except Exception as exc:
-            elapsed = (time.perf_counter() - t0) * 1000
-            item_results.append(EmbeddingItem(
-                success=False,
-                time_ms=round(elapsed, 3),
-                error_message=str(exc),
-            ))
-
-    if not images:
-        total_ms = (time.perf_counter() - start) * 1000
-        return EmbeddingResponse(
-            success=False,
-            time_ms=round(total_ms, 3),
-            success_count=0,
-            failed_count=len(item_results),
-            error_message="No valid images could be downloaded.",
-            results=item_results,
-        )
-
-    try:
-        loop = asyncio.get_running_loop()
-        vectors = await loop.run_in_executor(
-            _thread_pool,
-            embedding_service.generate_image_embedding,
-            images,
-        )
-    except Exception as exc:
-        elapsed = (time.perf_counter() - start) * 1000
-        _logger.error("Vision embedding error: %s", exc)
-        for _ in range(len(images) - len(item_results)):
-            item_results.append(EmbeddingItem(success=False, time_ms=0, error_message=str(exc)))
-        return EmbeddingResponse(
-            success=False,
-            time_ms=round(elapsed, 3),
-            success_count=0,
-            failed_count=len(item_results),
-            error_message=str(exc),
-            results=item_results,
-        )
-
-    total_ms = (time.perf_counter() - start) * 1000
-    for i, vec in enumerate(vectors):
-        item_results.append(EmbeddingItem(
-            success=True,
-            time_ms=round(total_ms / len(vectors), 3),
-            embeddings=vec,
-            dimension=dim,
-        ))
-
-    success_count = sum(1 for r in item_results if r.success)
-    failed_count = len(item_results) - success_count
-    _logger.info("Vision embedding success: items=%s, success=%s, failed=%s, total_ms=%s",
-                 len(item_results), success_count, failed_count, round(total_ms, 3))
-    return EmbeddingResponse(
-        success=failed_count == 0,
-        time_ms=round(total_ms, 3),
-        success_count=success_count,
-        failed_count=failed_count,
-        results=item_results,
-    )
+# @router.post(  # DISABLED (OOM mitigation)
+#     "/embeddings/vision/file",
+#     response_model=EmbeddingResponse,
+#     summary="Generate embeddings from uploaded images",
+# )
+# async def create_vision_embeddings_file(
+#     files: Annotated[List[UploadFile], File(description="Image files to embed (max 5)")],
+#     token: str = Depends(require_auth),
+#     embedding_service: EmbeddingService = Depends(get_embeddings_service),
+# ) -> EmbeddingResponse:
+#     if not files:
+#         raise HTTPException(status_code=400, detail={"success": False, "message": "No files provided."})
+#     if len(files) > _MAX_VISION_ITEMS:
+#         raise HTTPException(status_code=400, detail={"success": False, "message": f"Maximum {_MAX_VISION_ITEMS} images per request."})
+# 
+#     if not embedding_service._vision_loaded:
+#         raise HTTPException(status_code=503, detail={"success": False, "message": "Vision model not loaded."})
+# 
+#     _logger.info("Vision embedding file request: files=%s", len(files))
+# 
+#     dim = embedding_service.vision_dimension
+#     start = time.perf_counter()
+#     images: List[Image.Image] = []
+#     item_results: List[EmbeddingItem] = []
+# 
+#     for f in files:
+#         t0 = time.perf_counter()
+#         try:
+#             # FIX: Guarantee the file cursor is at the beginning before reading!
+#             await f.seek(0)
+#             raw = await f.read()
+#             
+#             img = await asyncio.get_running_loop().run_in_executor(_thread_pool, _validate_image, raw, f.filename or "unknown")
+#             images.append(img)
+#         except Exception as exc:
+#             elapsed = (time.perf_counter() - t0) * 1000
+#             item_results.append(EmbeddingItem(
+#                 success=False,
+#                 time_ms=round(elapsed, 3),
+#                 error_message=str(exc),
+#             ))
+# 
+#     if not images:
+#         total_ms = (time.perf_counter() - start) * 1000
+#         return EmbeddingResponse(
+#             success=False,
+#             time_ms=round(total_ms, 3),
+#             success_count=0,
+#             failed_count=len(item_results),
+#             error_message="No valid images could be processed.",
+#             results=item_results,
+#         )
+# 
+#     try:
+#         loop = asyncio.get_running_loop()
+#         vectors = await loop.run_in_executor(
+#             _thread_pool,
+#             embedding_service.generate_image_embedding,
+#             images,
+#         )
+#     except Exception as exc:
+#         elapsed = (time.perf_counter() - start) * 1000
+#         _logger.error("Vision embedding error: %s", exc)
+#         for _ in range(len(images) - len(item_results)):
+#             item_results.append(EmbeddingItem(success=False, time_ms=0, error_message=str(exc)))
+#         return EmbeddingResponse(
+#             success=False,
+#             time_ms=round(elapsed, 3),
+#             success_count=0,
+#             failed_count=len(item_results),
+#             error_message=str(exc),
+#             results=item_results,
+#         )
+# 
+#     total_ms = (time.perf_counter() - start) * 1000
+#     for i, vec in enumerate(vectors):
+#         item_results.append(EmbeddingItem(
+#             success=True,
+#             time_ms=round(total_ms / len(vectors), 3),
+#             embeddings=vec,
+#             dimension=dim,
+#         ))
+# 
+#     success_count = sum(1 for r in item_results if r.success)
+#     failed_count = len(item_results) - success_count
+#     _logger.info("Vision embedding success: items=%s, success=%s, failed=%s, total_ms=%s",
+#                  len(item_results), success_count, failed_count, round(total_ms, 3))
+#     return EmbeddingResponse(
+#         success=failed_count == 0,
+#         time_ms=round(total_ms, 3),
+#         success_count=success_count,
+#         failed_count=failed_count,
+#         results=item_results,
+#     )
+# 
+# 
+# @router.post(  # DISABLED (OOM mitigation)
+#     "/embeddings/vision/url",
+#     response_model=EmbeddingResponse,
+#     summary="Generate embeddings from image URLs",
+# )
+# async def create_vision_embeddings_url(
+#     body: VisionUrlRequest,
+#     token: str = Depends(require_auth),
+#     embedding_service: EmbeddingService = Depends(get_embeddings_service),
+# ) -> EmbeddingResponse:
+#     if not embedding_service._vision_loaded:
+#         raise HTTPException(status_code=503, detail={"success": False, "message": "Vision model not loaded."})
+# 
+#     _logger.info("Vision embedding URL request: urls=%s", len(body.urls))
+# 
+#     dim = embedding_service.vision_dimension
+#     start = time.perf_counter()
+#     images: List[Image.Image] = []
+#     item_results: List[EmbeddingItem] = []
+# 
+#     for url in body.urls:
+#         t0 = time.perf_counter()
+#         try:
+#             raw = await _download_image(url)
+#             img = await asyncio.get_running_loop().run_in_executor(_thread_pool, _validate_image, raw, url)
+#             images.append(img)
+#         except Exception as exc:
+#             elapsed = (time.perf_counter() - t0) * 1000
+#             item_results.append(EmbeddingItem(
+#                 success=False,
+#                 time_ms=round(elapsed, 3),
+#                 error_message=str(exc),
+#             ))
+# 
+#     if not images:
+#         total_ms = (time.perf_counter() - start) * 1000
+#         return EmbeddingResponse(
+#             success=False,
+#             time_ms=round(total_ms, 3),
+#             success_count=0,
+#             failed_count=len(item_results),
+#             error_message="No valid images could be downloaded.",
+#             results=item_results,
+#         )
+# 
+#     try:
+#         loop = asyncio.get_running_loop()
+#         vectors = await loop.run_in_executor(
+#             _thread_pool,
+#             embedding_service.generate_image_embedding,
+#             images,
+#         )
+#     except Exception as exc:
+#         elapsed = (time.perf_counter() - start) * 1000
+#         _logger.error("Vision embedding error: %s", exc)
+#         for _ in range(len(images) - len(item_results)):
+#             item_results.append(EmbeddingItem(success=False, time_ms=0, error_message=str(exc)))
+#         return EmbeddingResponse(
+#             success=False,
+#             time_ms=round(elapsed, 3),
+#             success_count=0,
+#             failed_count=len(item_results),
+#             error_message=str(exc),
+#             results=item_results,
+#         )
+# 
+#     total_ms = (time.perf_counter() - start) * 1000
+#     for i, vec in enumerate(vectors):
+#         item_results.append(EmbeddingItem(
+#             success=True,
+#             time_ms=round(total_ms / len(vectors), 3),
+#             embeddings=vec,
+#             dimension=dim,
+#         ))
+# 
+#     success_count = sum(1 for r in item_results if r.success)
+#     failed_count = len(item_results) - success_count
+#     _logger.info("Vision embedding success: items=%s, success=%s, failed=%s, total_ms=%s",
+#                  len(item_results), success_count, failed_count, round(total_ms, 3))
+#     return EmbeddingResponse(
+#         success=failed_count == 0,
+#         time_ms=round(total_ms, 3),
+#         success_count=success_count,
+#         failed_count=failed_count,
+#         results=item_results,
+#     )

app/models/__init__.py

@@ -15,7 +15,7 @@ from app.models.schemas import (
     SpacyLabelsResponse,
     SupportedFormatsResponse,
     UrlRequest,
-    VisionUrlRequest,
+    # VisionUrlRequest,  # DISABLED (OOM mitigation)
 )
 
 __all__ = [
@@ -34,5 +34,5 @@ __all__ = [
     "InfoResponse",
     "SupportedFormatsResponse",
     "SpacyLabelsResponse",
-    "VisionUrlRequest",
+    # "VisionUrlRequest",  # DISABLED (OOM mitigation)
 ]

app/models/schemas.py

@@ -235,7 +235,7 @@ class EmbeddingItem(BaseModel):
 
 class EmbeddingRequest(BaseModel):
     content: List[str] = Field(..., min_length=1, max_length=10, description="Array of text strings to embed (max 10)")
-    dimension: int = Field(default=384, ge=384, le=1024, description="Target embedding dimension (384, 768, or 1024)")
+    dimension: int = Field(default=384, ge=384, le=384, description="Target embedding dimension (384 only)")
 
     @field_validator("content")
     @classmethod
@@ -256,20 +256,20 @@ class EmbeddingResponse(BaseModel):
     results: List[EmbeddingItem]
 
 
-class VisionUrlRequest(BaseModel):
-    urls: List[str] = Field(..., min_length=1, max_length=5, description="Array of image URLs to embed (max 5)")
-
-    @field_validator("urls")
-    @classmethod
-    def validate_urls(cls, v: List[str]) -> List[str]:
-        for url in v:
-            if not url.startswith(("http://", "https://")):
-                raise ValueError(f"Invalid URL scheme: {url}")
-        return v
+# class VisionUrlRequest(BaseModel):  # DISABLED (OOM mitigation)
+#     urls: List[str] = Field(..., min_length=1, max_length=5, description="Array of image URLs to embed (max 5)")
+# 
+#     @field_validator("urls")
+#     @classmethod
+#     def validate_urls(cls, v: List[str]) -> List[str]:
+#         for url in v:
+#             if not url.startswith(("http://", "https://")):
+#                 raise ValueError(f"Invalid URL scheme: {url}")
+#         return v
 
 
 class CodeItem(BaseModel):
-    language: Literal["python", "javascript", "java"]
+    language: Literal["python", "javascript"]  # "java" DISABLED (OOM mitigation)
     code: str = Field(..., min_length=1, max_length=65536, description="Source code to execute")
 
 

app/services/code_executor_service.py

@@ -70,27 +70,27 @@ class CodeSanitizer:
             (r"worker_threads", "worker_threads not allowed"),
             (r"Buffer\s*\.", "Buffer not allowed"),
         ],
-        "java": [
-            (r"ProcessBuilder", "ProcessBuilder not allowed"),
-            (r"Runtime\.exec", "Runtime.exec() not allowed"),
-            (r"Runtime\.getRuntime\s*\(\s*\)", "Runtime.getRuntime() not allowed"),
-            (r"System\.exit\s*\(", "System.exit() not allowed"),
-            (r"System\.gc\s*\(", "System.gc() not allowed"),
-            (r"File\s*\(", "File operations not allowed"),
-            (r"FileInputStream", "FileInputStream not allowed"),
-            (r"FileOutputStream", "FileOutputStream not allowed"),
-            (r"FileReader", "FileReader not allowed"),
-            (r"FileWriter", "FileWriter not allowed"),
-            (r"Socket\s*\(", "Socket not allowed"),
-            (r"ServerSocket\s*\(", "ServerSocket not allowed"),
-            (r"URL\s*\(", "URL not allowed"),
-            (r"Class\.forName", "Class.forName() not allowed"),
-            (r"Thread\s*\(", "Thread not allowed"),
-            (r"ThreadPoolExecutor", "ThreadPoolExecutor not allowed"),
-            (r"Runtime\.", "Runtime not allowed"),
-            (r"System\.getProperty", "System.getProperty not allowed"),
-            (r"System\.getenv", "System.getenv not allowed"),
-        ],
+        # "java": [  # DISABLED (OOM mitigation)
+        #     (r"ProcessBuilder", "ProcessBuilder not allowed"),
+        #     (r"Runtime\.exec", "Runtime.exec() not allowed"),
+        #     (r"Runtime\.getRuntime\s*\(\s*\)", "Runtime.getRuntime() not allowed"),
+        #     (r"System\.exit\s*\(", "System.exit() not allowed"),
+        #     (r"System\.gc\s*\(", "System.gc() not allowed"),
+        #     (r"File\s*\(", "File operations not allowed"),
+        #     (r"FileInputStream", "FileInputStream not allowed"),
+        #     (r"FileOutputStream", "FileOutputStream not allowed"),
+        #     (r"FileReader", "FileReader not allowed"),
+        #     (r"FileWriter", "FileWriter not allowed"),
+        #     (r"Socket\s*\(", "Socket not allowed"),
+        #     (r"ServerSocket\s*\(", "ServerSocket not allowed"),
+        #     (r"URL\s*\(", "URL not allowed"),
+        #     (r"Class\.forName", "Class.forName() not allowed"),
+        #     (r"Thread\s*\(", "Thread not allowed"),
+        #     (r"ThreadPoolExecutor", "ThreadPoolExecutor not allowed"),
+        #     (r"Runtime\.", "Runtime not allowed"),
+        #     (r"System\.getProperty", "System.getProperty not allowed"),
+        #     (r"System\.getenv", "System.getenv not allowed"),
+        # ],
     }
 
     @classmethod
@@ -101,11 +101,11 @@ class CodeSanitizer:
                 return False, f"Forbidden: {message}"
         return True, None
 
-    @classmethod
-    def validate_java_class(cls, code: str) -> tuple[bool, Optional[str]]:
-        if not re.search(r"public\s+class\s+Main\s*\{", code):
-            return False, "Java code must have 'public class Main' with 'public static void main(String[] args)'"
-        return True, None
+    # @classmethod  # DISABLED (OOM mitigation)
+    # def validate_java_class(cls, code: str) -> tuple[bool, Optional[str]]:
+    #     if not re.search(r"public\s+class\s+Main\s*\{", code):
+    #         return False, "Java code must have 'public class Main' with 'public static void main(String[] args)'"
+    #     return True, None
 
 
 class CodeExecutorService:
@@ -131,14 +131,14 @@ class CodeExecutorService:
                 "language": language, "timed_out": False,
             }
 
-        if language == "java":
-            valid, err = CodeSanitizer.validate_java_class(code)
-            if not valid:
-                return {
-                    "success": False, "output": "", "error": err,
-                    "exit_code": None, "execution_time_ms": None,
-                    "language": language, "timed_out": False,
-                }
+        # if language == "java":  # DISABLED (OOM mitigation)
+        #     valid, err = CodeSanitizer.validate_java_class(code)
+        #     if not valid:
+        #         return {
+        #             "success": False, "output": "", "error": err,
+        #             "exit_code": None, "execution_time_ms": None,
+        #             "language": language, "timed_out": False,
+        #         }
 
         exec_timeout = min(timeout or self._max_execution_time, self._max_execution_time)
 
@@ -233,14 +233,15 @@ class CodeExecutorService:
 
     async def check_runtimes(self) -> dict[str, str]:
         status = {}
-        for lang, runtime in [("python", "python3"), ("javascript", "node"), ("java", "javac")]:
+        for lang, runtime in [("python", "python3"), ("javascript", "node")]:  # "java" DISABLED (OOM mitigation)
             path = shutil.which(runtime)
             status[lang] = f"found at {path}" if path else "missing"
         return status
 
     @staticmethod
     def _filename_for(language: str) -> str:
-        return {"python": "code.py", "javascript": "code.js", "java": "Main.java"}[language]
+        return {"python": "code.py", "javascript": "code.js"  # "java": "Main.java" DISABLED (OOM mitigation)
+               }[language]
 
     @staticmethod
     def _build_command(language: str, run_dir: Path, filename: str) -> list[str]:
@@ -250,7 +251,7 @@ class CodeExecutorService:
             return ["python3", str(sandbox_py), str(run_dir / filename)]
         elif language == "javascript":
             return ["node", str(sandbox_js), str(run_dir / filename)]
-        elif language == "java":
-            return ["sh", "-c",
-                    f"cd {run_dir} && javac Main.java 2>&1 && java -XX:CompressedClassSpaceSize=64m -Xmx96m Main 2>&1"]
+        # elif language == "java":  # DISABLED (OOM mitigation)
+        #     return ["sh", "-c",
+        #             f"cd {run_dir} && javac Main.java 2>&1 && java -XX:CompressedClassSpaceSize=64m -Xmx96m Main 2>&1"]
         return []

app/services/converter_service.py

@@ -8,7 +8,7 @@ import time
 from pathlib import Path
 from urllib.parse import urlparse
 
-import httpx
+# import httpx  # DISABLED (OOM mitigation) — only used by YouTube
 from markitdown import MarkItDown
 
 from app.core.constants import IMAGE_EXTENSIONS, IMAGE_MIME_PREFIXES
@@ -19,99 +19,99 @@ from app.services.ocr_service import ocr_image, ocr_pdf
 _logger = get_logger(__name__)
 
 
-def _extract_youtube_video_id(url_or_id: str) -> str:
-    if len(url_or_id) == 11 and not url_or_id.startswith("http"):
-        return url_or_id
-    pattern = r"(?:v=|\/)([0-9A-Za-z_-]{11}).*"
-    match = re.search(pattern, url_or_id)
-    if match:
-        return match.group(1)
-    raise ValueError(f"Could not extract a valid YouTube ID from: {url_or_id}")
-
-
-def _fetch_youtube_oembed(video_id: str) -> dict | None:
-    oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
-    try:
-        resp = httpx.get(oembed_url, timeout=10.0)
-        resp.raise_for_status()
-        return resp.json()
-    except Exception as exc:
-        _logger.warning("YouTube oEmbed failed for %s: %s", video_id, exc)
-        return None
-
-
-def _fetch_youtube_transcript(video_id: str) -> str | None:
-    try:
-        import json as _json
-        import os as _os
-
-        from youtube_transcript_api import YouTubeTranscriptApi
-        from youtube_transcript_api.formatters import TextFormatter
-        from youtube_transcript_api._errors import (
-            TranscriptsDisabled,
-            NoTranscriptFound,
-            VideoUnavailable,
-        )
-
-        kwargs: dict = {}
-        cookies_raw = _os.environ.get("YOUTUBE_COOKIES", "").strip()
-        if cookies_raw:
-            try:
-                import requests as _requests
-                session = _requests.Session()
-                session.cookies.update(_json.loads(cookies_raw))
-                kwargs["http_client"] = session
-            except Exception as exc:
-                _logger.warning("Failed to apply YOUTUBE_COOKIES: %s", exc)
-
-        ytt_api = YouTubeTranscriptApi(**kwargs)
-        transcript_data = ytt_api.fetch(video_id, languages=["en"])
-        formatter = TextFormatter()
-        return formatter.format_transcript(transcript_data)
-    except TranscriptsDisabled:
-        _logger.warning("Transcripts disabled for video %s", video_id)
-    except NoTranscriptFound:
-        _logger.warning("No transcript found for video %s in language 'en'", video_id)
-    except VideoUnavailable:
-        _logger.warning("Video %s is unavailable, deleted, or private", video_id)
-    except ValueError as ve:
-        _logger.warning("Invalid video ID %s: %s", video_id, ve)
-    except Exception as exc:
-        _logger.warning("YouTube transcript failed for %s: %s", video_id, exc)
-    return None
-
-
-def _convert_youtube(url: str) -> ConversionResult | None:
-    try:
-        video_id = _extract_youtube_video_id(url)
-    except ValueError:
-        return None
-
-    oembed = _fetch_youtube_oembed(video_id)
-    transcript = _fetch_youtube_transcript(video_id)
-
-    lines = ["# YouTube\n"]
-    title = (oembed or {}).get("title", "")
-    if title:
-        lines.append(f"\n## {title}\n")
-
-    author = (oembed or {}).get("author_name", "")
-    if author:
-        lines.append(f"\n- **Channel:** {author}\n")
-
-    desc = (oembed or {}).get("description", "")
-    if desc:
-        lines.append(f"\n### Description\n{desc}\n")
-
-    if transcript:
-        lines.append(f"\n### Transcript\n{transcript}\n")
-    else:
-        if not title and not desc:
-            return None
-        lines.append("\n> No transcript available.\n")
-
-    markdown = "".join(lines)
-    return _build_result(url, markdown, 0, "text/html", 0.0)
+# def _extract_youtube_video_id(url_or_id: str) -> str:  # DISABLED (OOM mitigation)
+#     if len(url_or_id) == 11 and not url_or_id.startswith("http"):
+#         return url_or_id
+#     pattern = r"(?:v=|\/)([0-9A-Za-z_-]{11}).*"
+#     match = re.search(pattern, url_or_id)
+#     if match:
+#         return match.group(1)
+#     raise ValueError(f"Could not extract a valid YouTube ID from: {url_or_id}")
+# 
+# 
+# def _fetch_youtube_oembed(video_id: str) -> dict | None:  # DISABLED (OOM mitigation)
+#     oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
+#     try:
+#         resp = httpx.get(oembed_url, timeout=10.0)
+#         resp.raise_for_status()
+#         return resp.json()
+#     except Exception as exc:
+#         _logger.warning("YouTube oEmbed failed for %s: %s", video_id, exc)
+#         return None
+# 
+# 
+# def _fetch_youtube_transcript(video_id: str) -> str | None:  # DISABLED (OOM mitigation)
+#     try:
+#         import json as _json
+#         import os as _os
+# 
+#         from youtube_transcript_api import YouTubeTranscriptApi
+#         from youtube_transcript_api.formatters import TextFormatter
+#         from youtube_transcript_api._errors import (
+#             TranscriptsDisabled,
+#             NoTranscriptFound,
+#             VideoUnavailable,
+#         )
+# 
+#         kwargs: dict = {}
+#         cookies_raw = _os.environ.get("YOUTUBE_COOKIES", "").strip()
+#         if cookies_raw:
+#             try:
+#                 import requests as _requests
+#                 session = _requests.Session()
+#                 session.cookies.update(_json.loads(cookies_raw))
+#                 kwargs["http_client"] = session
+#             except Exception as exc:
+#                 _logger.warning("Failed to apply YOUTUBE_COOKIES: %s", exc)
+# 
+#         ytt_api = YouTubeTranscriptApi(**kwargs)
+#         transcript_data = ytt_api.fetch(video_id, languages=["en"])
+#         formatter = TextFormatter()
+#         return formatter.format_transcript(transcript_data)
+#     except TranscriptsDisabled:
+#         _logger.warning("Transcripts disabled for video %s", video_id)
+#     except NoTranscriptFound:
+#         _logger.warning("No transcript found for video %s in language 'en'", video_id)
+#     except VideoUnavailable:
+#         _logger.warning("Video %s is unavailable, deleted, or private", video_id)
+#     except ValueError as ve:
+#         _logger.warning("Invalid video ID %s: %s", video_id, ve)
+#     except Exception as exc:
+#         _logger.warning("YouTube transcript failed for %s: %s", video_id, exc)
+#     return None
+# 
+# 
+# def _convert_youtube(url: str) -> ConversionResult | None:  # DISABLED (OOM mitigation)
+#     try:
+#         video_id = _extract_youtube_video_id(url)
+#     except ValueError:
+#         return None
+# 
+#     oembed = _fetch_youtube_oembed(video_id)
+#     transcript = _fetch_youtube_transcript(video_id)
+# 
+#     lines = ["# YouTube\n"]
+#     title = (oembed or {}).get("title", "")
+#     if title:
+#         lines.append(f"\n## {title}\n")
+# 
+#     author = (oembed or {}).get("author_name", "")
+#     if author:
+#         lines.append(f"\n- **Channel:** {author}\n")
+# 
+#     desc = (oembed or {}).get("description", "")
+#     if desc:
+#         lines.append(f"\n### Description\n{desc}\n")
+# 
+#     if transcript:
+#         lines.append(f"\n### Transcript\n{transcript}\n")
+#     else:
+#         if not title and not desc:
+#             return None
+#         lines.append("\n> No transcript available.\n")
+# 
+#     markdown = "".join(lines)
+#     return _build_result(url, markdown, 0, "text/html", 0.0)
 
 
 def _is_image(ext: str, mime: str) -> bool:
@@ -193,26 +193,26 @@ class ConverterService:
 
         start = time.perf_counter()
 
-        try:
-            _extract_youtube_video_id(url)
-        except ValueError:
-            pass
-        else:
-            result = _convert_youtube(url)
-            if result is not None:
-                result = ConversionResult(
-                    source=result.source,
-                    markdown=result.markdown,
-                    char_count=result.char_count,
-                    word_count=result.word_count,
-                    line_count=result.line_count,
-                    duration_ms=(time.perf_counter() - start) * 1000,
-                    file_size_bytes=result.file_size_bytes,
-                    mime_type=result.mime_type,
-                    content_hash=result.content_hash,
-                )
-                return result
-            _logger.warning("YouTube conversion returned None, falling back to markitdown: %s", url)
+        # try:  # DISABLED (OOM mitigation) — YouTube transcription
+        #     _extract_youtube_video_id(url)
+        # except ValueError:
+        #     pass
+        # else:
+        #     result = _convert_youtube(url)
+        #     if result is not None:
+        #         result = ConversionResult(
+        #             source=result.source,
+        #             markdown=result.markdown,
+        #             char_count=result.char_count,
+        #             word_count=result.word_count,
+        #             line_count=result.line_count,
+        #             duration_ms=(time.perf_counter() - start) * 1000,
+        #             file_size_bytes=result.file_size_bytes,
+        #             mime_type=result.mime_type,
+        #             content_hash=result.content_hash,
+        #         )
+        #         return result
+        #     _logger.warning("YouTube conversion returned None, falling back to markitdown: %s", url)
 
         try:
             url_ext = Path(urlparse(url).path).suffix.lower()

app/services/embeddings_service.py

@@ -5,24 +5,23 @@ import os
 from typing import Dict, List, Optional
 
 import numpy as np
-import torch
-import torch.nn.functional as F
-from PIL import Image
+# import torch  # DISABLED (OOM mitigation) — only used by vision
+# import torch.nn.functional as F  # DISABLED (OOM mitigation)
+# from PIL import Image  # DISABLED (OOM mitigation)
 from sentence_transformers import SentenceTransformer
-from transformers import AutoImageProcessor, AutoModel
+# from transformers import AutoImageProcessor, AutoModel  # DISABLED (OOM mitigation)
 
 _logger = logging.getLogger(__name__)
 
-# NOTE: Fixed model mapping to align nomic-embed-text-v1.5 (dim=768) with nomic-embed-vision-v1.5 (dim=768).
-# This configuration is required if you are comparing text and image embeddings.
+# Only 384-dim embedding is enabled. 768 and 1024 are disabled to reduce memory usage.
 _MODEL_MAP: Dict[int, str] = {
     384: "ibm-granite/granite-embedding-small-english-r2",
-    768: "nomic-ai/nomic-embed-text-v1.5",
-    1024: "lightonai/modernbert-embed-large",
+    # 768: "nomic-ai/nomic-embed-text-v1.5",   # DISABLED (OOM mitigation)
+    # 1024: "lightonai/modernbert-embed-large", # DISABLED (OOM mitigation)
 }
 
-_VISION_MODEL_NAME = "nomic-ai/nomic-embed-vision-v1.5"
-_VISION_DIMENSION = 768
+# _VISION_MODEL_NAME = "nomic-ai/nomic-embed-vision-v1.5"  # DISABLED (OOM mitigation)
+# _VISION_DIMENSION = 768
 
 
 class EmbeddingService:
@@ -38,9 +37,9 @@ class EmbeddingService:
             self._device = "cpu"
 
         self._loaded_dimensions: List[int] = []
-        self._vision_processor: Optional[AutoImageProcessor] = None
-        self._vision_model: Optional[AutoModel] = None
-        self._vision_loaded = False
+        # self._vision_processor: Optional[AutoImageProcessor] = None  # DISABLED (OOM mitigation)
+        # self._vision_model: Optional[AutoModel] = None              # DISABLED (OOM mitigation)
+        # self._vision_loaded = False
 
     def load_model(self, dimension: int) -> None:
         if dimension in self._models:
@@ -66,34 +65,34 @@ class EmbeddingService:
         for dim in _MODEL_MAP:
             self.load_model(dim)
 
-    def load_vision_model(self) -> None:
-        if self._vision_loaded:
-            return
-        local_path = os.path.join(self._models_dir, "vision")
-        source = local_path if os.path.isdir(local_path) else _VISION_MODEL_NAME
-
-        cfg_path = os.path.join(local_path, "config.json")
-        if os.path.exists(cfg_path):
-            import json
-            with open(cfg_path) as f:
-                d = json.load(f)
-            if isinstance(d.get("n_inner"), float):
-                d["n_inner"] = int(d["n_inner"])
-                with open(cfg_path, "w") as f:
-                    json.dump(d, f, indent=2)
-                _logger.info("Patched vision model config: n_inner float -> int")
-
-        _logger.info("Loading vision embedding model from %s", source)
-        self._vision_processor = AutoImageProcessor.from_pretrained(source)
-        self._vision_model = AutoModel.from_pretrained(
-            source,
-            trust_remote_code=True,
-            _fast_init=False,
-        )
-        self._vision_model.eval()
-        self._vision_model.to(self._device)
-        self._vision_loaded = True
-        _logger.info("Loaded vision embedding model (device=%s)", self._device)
+    # def load_vision_model(self) -> None:  # DISABLED (OOM mitigation)
+    #     if self._vision_loaded:
+    #         return
+    #     local_path = os.path.join(self._models_dir, "vision")
+    #     source = local_path if os.path.isdir(local_path) else _VISION_MODEL_NAME
+    # 
+    #     cfg_path = os.path.join(local_path, "config.json")
+    #     if os.path.exists(cfg_path):
+    #         import json
+    #         with open(cfg_path) as f:
+    #             d = json.load(f)
+    #         if isinstance(d.get("n_inner"), float):
+    #             d["n_inner"] = int(d["n_inner"])
+    #             with open(cfg_path, "w") as f:
+    #                 json.dump(d, f, indent=2)
+    #             _logger.info("Patched vision model config: n_inner float -> int")
+    # 
+    #     _logger.info("Loading vision embedding model from %s", source)
+    #     self._vision_processor = AutoImageProcessor.from_pretrained(source)
+    #     self._vision_model = AutoModel.from_pretrained(
+    #         source,
+    #         trust_remote_code=True,
+    #         _fast_init=False,
+    #     )
+    #     self._vision_model.eval()
+    #     self._vision_model.to(self._device)
+    #     self._vision_loaded = True
+    #     _logger.info("Loaded vision embedding model (device=%s)", self._device)
 
     def generate_embedding(self, text: List[str], dimension: int) -> List[List[float]]:
         if dimension not in self._models:
@@ -110,19 +109,19 @@ class EmbeddingService:
         )
         return result.tolist()
 
-    def generate_image_embedding(self, images: List[Image.Image]) -> List[List[float]]:
-        if not self._vision_loaded or self._vision_model is None or self._vision_processor is None:
-            raise ValueError("Vision model not loaded")
-        all_embeddings: List[List[float]] = []
-        with torch.no_grad():
-            for image in images:
-                inputs = self._vision_processor(image, return_tensors="pt")
-                inputs = {k: v.to(self._device) for k, v in inputs.items()}
-                outputs = self._vision_model(**inputs)
-                emb = outputs.last_hidden_state[:, 0]
-                emb = F.normalize(emb, p=2, dim=1)
-                all_embeddings.append(emb.cpu().numpy().flatten().tolist())
-        return all_embeddings
+    # def generate_image_embedding(self, images: List[Image.Image]) -> List[List[float]]:  # DISABLED (OOM mitigation)
+    #     if not self._vision_loaded or self._vision_model is None or self._vision_processor is None:
+    #         raise ValueError("Vision model not loaded")
+    #     all_embeddings: List[List[float]] = []
+    #     with torch.no_grad():
+    #         for image in images:
+    #             inputs = self._vision_processor(image, return_tensors="pt")
+    #             inputs = {k: v.to(self._device) for k, v in inputs.items()}
+    #             outputs = self._vision_model(**inputs)
+    #             emb = outputs.last_hidden_state[:, 0]
+    #             emb = F.normalize(emb, p=2, dim=1)
+    #             all_embeddings.append(emb.cpu().numpy().flatten().tolist())
+    #     return all_embeddings
 
     @property
     def loaded_dimensions(self) -> List[int]:
@@ -131,6 +130,6 @@ class EmbeddingService:
     def is_loaded(self, dimension: int) -> bool:
         return dimension in self._models
 
-    @property
-    def vision_dimension(self) -> int:
-        return _VISION_DIMENSION
+    # @property  # DISABLED (OOM mitigation)
+    # def vision_dimension(self) -> int:
+    #     return _VISION_DIMENSION

requirements.txt

@@ -17,7 +17,7 @@ sentence-transformers==5.6.0
 transformers==4.49.0
 
 torch==2.12.1
-torchvision==0.27.1
+# torchvision==0.27.1
 einops
 spacy>=3.7.0
 phonenumbers>=8.13.0