Initial deployment of NexVote AI service

.gitignore

@@ -0,0 +1,22 @@
+# Virtual environments
+venv/
+.venv/
+env/
+ENV/
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Model cache (Hugging Face transformers)
+models/
+.cache/
+
+# Logs
+*.log
+
+# IDE
+.vscode/
+.idea/

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    wget && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY main.py .
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    AI_SERVICE_PORT=8000
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+EXPOSE 8000
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+  CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -0,0 +1,51 @@
+---
+title: NexVote AI Service
+emoji: 🗳️
+colorFrom: purple
+colorTo: indigo
+sdk: docker
+app_port: 8000
+pinned: false
+license: mit
+---
+
+# NexVote AI Service
+
+AI-powered translation, summarization, and semantic search service for the NexVote decentralized voting platform.
+
+## Features
+
+- Multi-language translation (6 languages: en, ta, hi, kn, ml, te)
+- Proposal summarization (BART-large-cnn)
+- Semantic search with embeddings (all-MiniLM-L6-v2)
+- RESTful API with FastAPI
+
+## API Endpoints
+
+- POST /translate - Translate text between supported languages
+- POST /summarize - Generate proposal summaries
+- POST /embed - Create vector embeddings
+- POST /search - Semantic search across content
+- GET /health - Service health check
+
+## Models Used
+
+- Translation: Helsinki-NLP/opus-mt-{en-ta, ta-en, en-hi, hi-en, en-kn, kn-en, en-ml, ml-en, en-te, te-en}
+- Summarization: facebook/bart-large-cnn
+- Embeddings: sentence-transformers/all-MiniLM-L6-v2
+
+## Environment Variables
+
+- AI_API_KEY: API key for authentication (optional)
+- AI_SERVICE_PORT: Port to run the service on (default: 8000)
+
+## Local Development
+
+```bash
+pip install -r requirements.txt
+python main.py
+```
+
+## Documentation
+
+Visit /docs for interactive API documentation (Swagger UI)

main.py

@@ -0,0 +1,292 @@
+"""
+NexVote AI Service
+FastAPI server providing /summarize and /embed endpoints.
+Uses a local model for embeddings and summarization to keep all data private.
+"""
+
+import os
+import logging
+import hashlib
+from typing import Optional
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Header
+from pydantic import BaseModel
+import numpy as np
+
+load_dotenv(dotenv_path="../.env")
+
+# ── Config ────────────────────────────────────────────────────────────────────
+
+AI_API_KEY = os.getenv("AI_API_KEY", "change-me-ai-api-key")
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "all-MiniLM-L6-v2")
+SUMMARIZER_MODEL = os.getenv("SUMMARIZER_MODEL", "facebook/bart-large-cnn")
+MAX_SUMMARY_TOKENS = int(os.getenv("MAX_SUMMARY_TOKENS", "200"))
+EMBEDDING_DIMENSION = int(os.getenv("EMBEDDING_DIMENSION", "384"))
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+
+TRANSLATION_MODELS = {
+    ("en", "ta"): "Helsinki-NLP/opus-mt-en-ta",
+    ("ta", "en"): "Helsinki-NLP/opus-mt-ta-en",
+    ("en", "hi"): "Helsinki-NLP/opus-mt-en-hi",
+    ("hi", "en"): "Helsinki-NLP/opus-mt-hi-en",
+    ("en", "kn"): "Helsinki-NLP/opus-mt-en-kn",
+    ("kn", "en"): "Helsinki-NLP/opus-mt-kn-en",
+    ("en", "ml"): "Helsinki-NLP/opus-mt-en-ml",
+    ("ml", "en"): "Helsinki-NLP/opus-mt-ml-en",
+    ("en", "te"): "Helsinki-NLP/opus-mt-en-te",
+    ("te", "en"): "Helsinki-NLP/opus-mt-te-en",
+}
+
+logging.basicConfig(level=getattr(logging, LOG_LEVEL))
+logger = logging.getLogger("nexvote-ai")
+
+app = FastAPI(
+    title="NexVote AI Service",
+    description="Local LLM service for proposal summarization and embedding generation.",
+    version="0.1.0",
+)
+
+# ── Lazy model loading ────────────────────────────────────────────────────────
+
+_embedding_model = None
+_summarizer = None
+_translation_pipelines = {}
+
+
+def get_embedding_model():
+    """Lazy-load the sentence transformer embedding model."""
+    global _embedding_model
+    if _embedding_model is None:
+        logger.info("Loading embedding model: %s", EMBEDDING_MODEL)
+        from sentence_transformers import SentenceTransformer
+
+        _embedding_model = SentenceTransformer(EMBEDDING_MODEL)
+        logger.info("Embedding model loaded (dimension=%d)", EMBEDDING_DIMENSION)
+    return _embedding_model
+
+
+def get_summarizer():
+    """Lazy-load the summarization pipeline."""
+    global _summarizer
+    if _summarizer is None:
+        logger.info("Loading summarizer model: %s", SUMMARIZER_MODEL)
+        from transformers import pipeline
+
+        _summarizer = pipeline(
+            "summarization",
+            model=SUMMARIZER_MODEL,
+            max_length=MAX_SUMMARY_TOKENS,
+            min_length=30,
+            do_sample=False,
+        )
+        logger.info("Summarizer model loaded")
+    return _summarizer
+
+
+def get_translator(source_lang: str, target_lang: str):
+    """Lazy-load a translation pipeline for the given language pair."""
+    key = f"{source_lang}->{target_lang}"
+    model_name = TRANSLATION_MODELS.get((source_lang, target_lang))
+    if not model_name:
+        raise HTTPException(status_code=400, detail="Translation pair not supported.")
+
+    if key not in _translation_pipelines:
+        logger.info("Loading translation model: %s", model_name)
+        from transformers import pipeline
+
+        _translation_pipelines[key] = pipeline("translation", model=model_name)
+        logger.info("Translation model loaded (%s)", key)
+
+    return _translation_pipelines[key]
+
+
+# ── Auth helper ───────────────────────────────────────────────────────────────
+
+
+def verify_api_key(x_api_key: Optional[str] = Header(None)):
+    """Verify the API key from the X-API-Key header."""
+    if AI_API_KEY and x_api_key != AI_API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid or missing API key.")
+
+
+# ── Request / Response models ─────────────────────────────────────────────────
+
+
+class EmbedRequest(BaseModel):
+    text: str
+    id: Optional[str] = None
+
+
+class EmbedResponse(BaseModel):
+    id: Optional[str]
+    embedding: list[float]
+    dimension: int
+
+
+class SummarizeRequest(BaseModel):
+    text: str
+
+
+class SummarizeResponse(BaseModel):
+    summary: str
+    original_length: int
+    summary_length: int
+
+
+class TranslateRequest(BaseModel):
+    text: str
+    source_lang: str
+    target_lang: str
+
+
+class TranslateResponse(BaseModel):
+    translation: str
+
+
+class BatchEmbedRequest(BaseModel):
+    texts: list[str]
+    ids: Optional[list[str]] = None
+
+
+class BatchEmbedResponse(BaseModel):
+    embeddings: list[list[float]]
+    ids: Optional[list[str]]
+    dimension: int
+    count: int
+
+
+# ── Endpoints ─────────────────────────────────────────────────────────────────
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {
+        "status": "ok",
+        "embedding_model": EMBEDDING_MODEL,
+        "summarizer_model": SUMMARIZER_MODEL,
+        "embedding_dimension": EMBEDDING_DIMENSION,
+    }
+
+
+@app.post("/embed", response_model=EmbedResponse)
+async def embed(req: EmbedRequest, x_api_key: Optional[str] = Header(None)):
+    """Generate an embedding vector for the given text."""
+    verify_api_key(x_api_key)
+
+    if not req.text or len(req.text.strip()) < 5:
+        raise HTTPException(status_code=400, detail="Text too short for embedding.")
+
+    request_id = hashlib.sha256(req.text[:100].encode()).hexdigest()[:12]
+    logger.info("Embed request [%s] text_length=%d", request_id, len(req.text))
+
+    try:
+        model = get_embedding_model()
+        embedding = model.encode(req.text, normalize_embeddings=True)
+        embedding_list = embedding.tolist()
+
+        return EmbedResponse(
+            id=req.id,
+            embedding=embedding_list,
+            dimension=len(embedding_list),
+        )
+    except Exception as e:
+        logger.error("Embedding failed [%s]: %s", request_id, str(e))
+        raise HTTPException(status_code=500, detail="Embedding generation failed.")
+
+
+@app.post("/embed/batch", response_model=BatchEmbedResponse)
+async def embed_batch(req: BatchEmbedRequest, x_api_key: Optional[str] = Header(None)):
+    """Generate embedding vectors for a batch of texts."""
+    verify_api_key(x_api_key)
+
+    if not req.texts or len(req.texts) == 0:
+        raise HTTPException(status_code=400, detail="No texts provided.")
+
+    if len(req.texts) > 100:
+        raise HTTPException(status_code=400, detail="Batch size exceeds maximum of 100.")
+
+    logger.info("Batch embed request count=%d", len(req.texts))
+
+    try:
+        model = get_embedding_model()
+        embeddings = model.encode(req.texts, normalize_embeddings=True, batch_size=32)
+        embeddings_list = [e.tolist() for e in embeddings]
+
+        return BatchEmbedResponse(
+            embeddings=embeddings_list,
+            ids=req.ids,
+            dimension=len(embeddings_list[0]) if embeddings_list else EMBEDDING_DIMENSION,
+            count=len(embeddings_list),
+        )
+    except Exception as e:
+        logger.error("Batch embedding failed: %s", str(e))
+        raise HTTPException(status_code=500, detail="Batch embedding generation failed.")
+
+
+@app.post("/summarize", response_model=SummarizeResponse)
+async def summarize(req: SummarizeRequest, x_api_key: Optional[str] = Header(None)):
+    """Generate a concise summary of the given text."""
+    verify_api_key(x_api_key)
+
+    if not req.text or len(req.text.strip()) < 20:
+        raise HTTPException(status_code=400, detail="Text too short for summarization.")
+
+    request_id = hashlib.sha256(req.text[:100].encode()).hexdigest()[:12]
+    logger.info("Summarize request [%s] text_length=%d", request_id, len(req.text))
+
+    try:
+        summarizer = get_summarizer()
+
+        # Truncate to model max input if necessary
+        input_text = req.text[:4096]
+        result = summarizer(input_text)
+        summary = result[0]["summary_text"]
+
+        return SummarizeResponse(
+            summary=summary,
+            original_length=len(req.text),
+            summary_length=len(summary),
+        )
+    except Exception as e:
+        logger.error("Summarization failed [%s]: %s", request_id, str(e))
+        raise HTTPException(status_code=500, detail="Summarization failed.")
+
+
+@app.post("/translate", response_model=TranslateResponse)
+async def translate(req: TranslateRequest, x_api_key: Optional[str] = Header(None)):
+    """Translate text between supported languages."""
+    verify_api_key(x_api_key)
+
+    if not req.text or len(req.text.strip()) < 1:
+        raise HTTPException(status_code=400, detail="Text is required for translation.")
+
+    source_lang = req.source_lang.lower().strip()
+    target_lang = req.target_lang.lower().strip()
+
+    if source_lang == target_lang:
+        return TranslateResponse(translation=req.text)
+
+    request_id = hashlib.sha256(req.text[:100].encode()).hexdigest()[:12]
+    logger.info("Translate request [%s] %s->%s", request_id, source_lang, target_lang)
+
+    try:
+        translator = get_translator(source_lang, target_lang)
+        result = translator(req.text)
+        translation = result[0]["translation_text"]
+        return TranslateResponse(translation=translation)
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error("Translation failed [%s]: %s", request_id, str(e))
+        raise HTTPException(status_code=500, detail="Translation failed.")
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import uvicorn
+
+    port = int(os.getenv("AI_SERVICE_PORT", "8000"))
+    uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.115.0
+uvicorn[standard]==0.32.0
+sentence-transformers==3.3.0
+transformers==4.46.0
+torch==2.5.0
+numpy>=1.26.0,<2.0.0
+pydantic==2.10.0
+python-dotenv==1.0.1
+sentencepiece==0.2.0
+sacremoses==0.1.1