Init commit

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential git libglib2.0-0 libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+COPY app.py ./
+
+ENV HF_HOME="/home/user/.cache/huggingface"
+ENV SENTENCE_TRANSFORMERS_HOME="/home/user/.cache/huggingface/sentence-transformers"
+
+ENV PORT=7860
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+
+

README.md

@@ -0,0 +1,57 @@
+---
+title: Embedding
+emoji: 🐠
+colorFrom: purple
+colorTo: gray
+sdk: docker
+pinned: false
+short_description: Simple API run sentence-transformers/all-MiniLM-L6-v2
+---
+
+# Embedder Service (HuggingFace Space)
+
+A lightweight microservice exposing sentence-transformers embeddings over HTTP.
+
+- Model: `sentence-transformers/all-MiniLM-L6-v2`
+- Sequential queueing: handles one request at a time to avoid resource spikes.
+
+## Endpoints
+
+- `GET /health` → `{ ok: true, model: string, loaded: boolean }`
+- `POST /embed`
+  - Request:
+
+```
+{
+  "texts": ["hello world", "another document"]
+}
+```
+
+  - Response:
+
+```
+{
+  "vectors": [[0.01, -0.02, ...], [0.03, -0.01, ...]],
+  "model": "sentence-transformers/all-MiniLM-L6-v2"
+}
+```
+
+## Deploy on HF Spaces
+
+1. Create a new Space (Docker type)
+2. Upload `app.py`, `Dockerfile`, `requirements.txt`
+3. Set Space hardware to CPU (Small is fine)
+4. Space will run on port 7860 by default
+
+## Example cURL
+
+```
+curl -s -X POST https://binkhoale1812-embedding.hf.space/embed \
+  -H 'Content-Type: application/json' \
+  -d '{"texts": ["An embedding request", "Second input"]}' | jq .
+```
+
+## Notes
+
+- The service lazily loads the model on first request.
+- If concurrent clients hit it, requests are serialized by a semaphore to reduce memory and CPU spikes.

app.py

@@ -0,0 +1,60 @@
+import os
+import asyncio
+from typing import List
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+
+MODEL_NAME = os.getenv("EMBED_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
+
+app = FastAPI(title="Embedder Service", version="1.0.0")
+
+
+class EmbedRequest(BaseModel):
+    texts: List[str]
+
+
+class EmbedResponse(BaseModel):
+    vectors: List[List[float]]
+    model: str
+
+
+_model = None
+_model_lock = asyncio.Lock()
+_sequential_gate = asyncio.Semaphore(1)  # ensure one job at a time
+
+
+def _lazy_load_model():
+    global _model
+    if _model is None:
+        # Lazy import to keep container startup light
+        from sentence_transformers import SentenceTransformer
+        _model = SentenceTransformer(MODEL_NAME)
+
+
+@app.get("/health")
+async def health():
+    return {"ok": True, "model": MODEL_NAME, "loaded": _model is not None}
+
+
+@app.post("/embed", response_model=EmbedResponse)
+async def embed(req: EmbedRequest):
+    # Simple sequential queueing: only one request processes at a time
+    async with _sequential_gate:
+        # Protect model initialization under a lock to avoid concurrent loads
+        async with _model_lock:
+            _lazy_load_model()
+        # Actual encoding
+        # sentence-transformers encode is sync; run in thread pool so we don't block loop
+        loop = asyncio.get_event_loop()
+        vectors = await loop.run_in_executor(None, lambda: _model.encode(req.texts, show_progress_bar=False, normalize_embeddings=True).tolist())
+        return EmbedResponse(vectors=vectors, model=MODEL_NAME)
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run(app, host="0.0.0.0", port=port)
+
+

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.114.2
+uvicorn[standard]==0.30.6
+sentence-transformers==3.1.1
+torch==2.2.2
+numpy==1.26.4
+