should work xd

CLAUDE.md

@@ -6,14 +6,18 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 This is a FastAPI-based multilingual embedding API that provides access to 5 specialized models for generating embeddings from Spanish, Catalan, English, and multilingual text. The API is deployed on Hugging Face Spaces and serves embeddings for different use cases including legal documents and general-purpose text.
 
-## Available Models
+## API Architecture - Endpoint Per Model
 
-The API serves 5 models with different specializations:
-- **jina**: Bilingual Spanish-English (768D, 8192 tokens)
-- **robertalex**: Spanish legal domain (768D, 512 tokens) 
-- **jina-v3**: Multilingual latest generation (1024D, 8192 tokens)
-- **legal-bert**: English legal domain (768D, 512 tokens)
-- **roberta-ca**: Catalan general purpose (1024D, 512 tokens)
+The API uses dedicated endpoints for each model with different loading strategies:
+
+### **Startup Model** (loads at app initialization):
+- **jina-v3**: `/embed/jina-v3` - Multilingual latest generation (1024D, 8192 tokens)
+
+### **On-Demand Models** (load when first requested):
+- **roberta-ca**: `/embed/roberta-ca` - Catalan general purpose (1024D, 512 tokens)
+- **jina**: `/embed/jina` - Bilingual Spanish-English (768D, 8192 tokens)
+- **robertalex**: `/embed/robertalex` - Spanish legal domain (768D, 512 tokens)
+- **legal-bert**: `/embed/legal-bert` - English legal domain (768D, 512 tokens)
 
 ## Architecture
 
@@ -40,17 +44,27 @@ The API will start on `http://0.0.0.0:7860` by default.
 
 ### Testing the API
 ```bash
-# Using the test script
-python test_api.py
+# Using the endpoint test script
+python test_endpoints.py
 
 # Manual testing with curl
 # Health check
 curl http://localhost:7860/health
 
-# Generate embeddings
-curl -X POST "http://localhost:7860/embed" \
+# Test jina-v3 endpoint (startup model)
+curl -X POST "http://localhost:7860/embed/jina-v3" \
+     -H "Content-Type: application/json" \
+     -d '{"texts": ["Hello world", "Hola mundo"], "normalize": true}'
+
+# Test Catalan RoBERTa endpoint
+curl -X POST "http://localhost:7860/embed/roberta-ca" \
+     -H "Content-Type: application/json" \
+     -d '{"texts": ["Bon dia", "Com estàs?"], "normalize": true}'
+
+# Test Spanish legal endpoint
+curl -X POST "http://localhost:7860/embed/robertalex" \
      -H "Content-Type: application/json" \
-     -d '{"texts": ["Texto de prueba"], "model": "jina"}'
+     -d '{"texts": ["Artículo primero"], "normalize": true}'
 
 # List models
 curl http://localhost:7860/models

app.py

@@ -1,5 +1,6 @@
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
 from typing import List
 import torch
 import uvicorn
@@ -7,32 +8,59 @@ import uvicorn
 from models.schemas import EmbeddingRequest, EmbeddingResponse, ModelInfo
 from utils.helpers import load_models, get_embeddings, cleanup_memory
 
-# Global model cache - completely on-demand loading
+# Global model cache
 models_cache = {}
 
-# All models load on demand to test deployment
-ON_DEMAND_MODELS = ["jina", "robertalex", "jina-v3", "legal-bert", "roberta-ca"]
+# Load jina-v3 at startup (most important model)
+STARTUP_MODEL = "jina-v3"
 
-def ensure_model_loaded(model_name: str):
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan handler for startup and shutdown"""
+    # Startup - load jina-v3 model
+    try:
+        global models_cache
+        print(f"Loading startup model: {STARTUP_MODEL}...")
+        models_cache = load_models([STARTUP_MODEL])
+        print(f"Startup model loaded successfully: {list(models_cache.keys())}")
+        yield
+    except Exception as e:
+        print(f"Failed to load startup model: {str(e)}")
+        # Continue anyway - jina-v3 can be loaded on demand if startup fails
+        yield
+    finally:
+        # Shutdown - cleanup resources
+        cleanup_memory()
+
+def ensure_model_loaded(model_name: str, max_length_limit: int):
     """Load a specific model on demand if not already loaded"""
     global models_cache
     if model_name not in models_cache:
-        if model_name in ON_DEMAND_MODELS:
-            try:
-                print(f"Loading model on demand: {model_name}...")
-                new_models = load_models([model_name])
-                models_cache.update(new_models)
-                print(f"Model {model_name} loaded successfully!")
-            except Exception as e:
-                print(f"Failed to load model {model_name}: {str(e)}")
-                raise HTTPException(status_code=500, detail=f"Model {model_name} loading failed: {str(e)}")
-        else:
-            raise HTTPException(status_code=400, detail=f"Unknown model: {model_name}")
+        try:
+            print(f"Loading model on demand: {model_name}...")
+            new_models = load_models([model_name])
+            models_cache.update(new_models)
+            print(f"Model {model_name} loaded successfully!")
+        except Exception as e:
+            print(f"Failed to load model {model_name}: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Model {model_name} loading failed: {str(e)}")
+
+def validate_request_for_model(request: EmbeddingRequest, model_name: str, max_length_limit: int):
+    """Validate request parameters for specific model"""
+    if not request.texts:
+        raise HTTPException(status_code=400, detail="No texts provided")
+    
+    if len(request.texts) > 50:
+        raise HTTPException(status_code=400, detail="Maximum 50 texts per request")
+    
+    if request.max_length is not None and request.max_length > max_length_limit:
+        raise HTTPException(status_code=400, detail=f"Max length for {model_name} is {max_length_limit}")
 
 app = FastAPI(
     title="Multilingual & Legal Embedding API",
-    description="Multi-model embedding API for Spanish, Catalan, English and Legal texts",
-    version="3.0.0"
+    description="Multi-model embedding API with dedicated endpoints per model",
+    version="4.0.0",
+    lifespan=lifespan
 )
 
 # Add CORS middleware to allow cross-origin requests
@@ -47,42 +75,151 @@ app.add_middleware(
 @app.get("/")
 async def root():
     return {
-        "message": "Multilingual & Legal Embedding API - Minimal Version",
-        "models": ["jina", "robertalex", "jina-v3", "legal-bert", "roberta-ca"],
+        "message": "Multilingual & Legal Embedding API - Endpoint Per Model",
+        "version": "4.0.0",
         "status": "running",
         "docs": "/docs",
-        "total_models": 5,
-        "note": "All models load on first request"
+        "startup_model": STARTUP_MODEL,
+        "available_endpoints": {
+            "jina-v3": "/embed/jina-v3",
+            "roberta-ca": "/embed/roberta-ca", 
+            "jina": "/embed/jina",
+            "robertalex": "/embed/robertalex",
+            "legal-bert": "/embed/legal-bert"
+        }
     }
 
-@app.post("/embed", response_model=EmbeddingResponse)
-async def create_embeddings(request: EmbeddingRequest):
-    """Generate embeddings for input texts"""
+# Jina v3 - Multilingual (loads at startup)
+@app.post("/embed/jina-v3", response_model=EmbeddingResponse)
+async def embed_jina_v3(request: EmbeddingRequest):
+    """Generate embeddings using Jina v3 model (multilingual)"""
     try:
-        # Load specific model on demand
-        ensure_model_loaded(request.model)
+        ensure_model_loaded("jina-v3", 8192)
+        validate_request_for_model(request, "jina-v3", 8192)
         
-        if not request.texts:
-            raise HTTPException(status_code=400, detail="No texts provided")
+        embeddings = get_embeddings(
+            request.texts,
+            "jina-v3",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="jina-v3",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
         
-        if len(request.texts) > 50:  # Rate limiting
-            raise HTTPException(status_code=400, detail="Maximum 50 texts per request")
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# Catalan RoBERTa
+@app.post("/embed/roberta-ca", response_model=EmbeddingResponse)
+async def embed_roberta_ca(request: EmbeddingRequest):
+    """Generate embeddings using Catalan RoBERTa model"""
+    try:
+        ensure_model_loaded("roberta-ca", 512)
+        validate_request_for_model(request, "roberta-ca", 512)
         
         embeddings = get_embeddings(
             request.texts,
-            request.model,
+            "roberta-ca",
             models_cache,
             request.normalize,
             request.max_length
         )
         
-        # Cleanup memory after large batches
-        if len(request.texts) > 20:
-            cleanup_memory()
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="roberta-ca",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# Jina v2 - Spanish/English
+@app.post("/embed/jina", response_model=EmbeddingResponse)
+async def embed_jina(request: EmbeddingRequest):
+    """Generate embeddings using Jina v2 Spanish/English model"""
+    try:
+        ensure_model_loaded("jina", 8192)
+        validate_request_for_model(request, "jina", 8192)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "jina",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
         
         return EmbeddingResponse(
             embeddings=embeddings,
-            model_used=request.model,
+            model_used="jina",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# RoBERTalex - Spanish Legal
+@app.post("/embed/robertalex", response_model=EmbeddingResponse)
+async def embed_robertalex(request: EmbeddingRequest):
+    """Generate embeddings using RoBERTalex Spanish legal model"""
+    try:
+        ensure_model_loaded("robertalex", 512)
+        validate_request_for_model(request, "robertalex", 512)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "robertalex",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="robertalex",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# Legal BERT - English Legal
+@app.post("/embed/legal-bert", response_model=EmbeddingResponse)
+async def embed_legal_bert(request: EmbeddingRequest):
+    """Generate embeddings using Legal BERT English model"""
+    try:
+        ensure_model_loaded("legal-bert", 512)
+        validate_request_for_model(request, "legal-bert", 512)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "legal-bert",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="legal-bert",
             dimensions=len(embeddings[0]) if embeddings else 0,
             num_texts=len(request.texts)
         )
@@ -96,6 +233,24 @@ async def create_embeddings(request: EmbeddingRequest):
 async def list_models():
     """List available models and their specifications"""
     return [
+        ModelInfo(
+            model_id="jina-v3",
+            name="jinaai/jina-embeddings-v3",
+            dimensions=1024,
+            max_sequence_length=8192,
+            languages=["Multilingual"],
+            model_type="multilingual",
+            description="Latest Jina v3 with superior multilingual performance - loaded at startup"
+        ),
+        ModelInfo(
+            model_id="roberta-ca",
+            name="projecte-aina/roberta-large-ca-v2",
+            dimensions=1024,
+            max_sequence_length=512,
+            languages=["Catalan"],
+            model_type="general",
+            description="Catalan RoBERTa-large model trained on large corpus"
+        ),
         ModelInfo(
             model_id="jina",
             name="jinaai/jina-embeddings-v2-base-es",
@@ -114,15 +269,6 @@ async def list_models():
             model_type="legal domain",
             description="Spanish legal domain specialized embeddings"
         ),
-        ModelInfo(
-            model_id="jina-v3",
-            name="jinaai/jina-embeddings-v3",
-            dimensions=1024,
-            max_sequence_length=8192,
-            languages=["Multilingual"],
-            model_type="multilingual",
-            description="Latest Jina v3 with superior multilingual performance"
-        ),
         ModelInfo(
             model_id="legal-bert",
             name="nlpaueb/legal-bert-base-uncased",
@@ -131,30 +277,27 @@ async def list_models():
             languages=["English"],
             model_type="legal domain",
             description="English legal domain BERT model"
-        ),
-        ModelInfo(
-            model_id="roberta-ca",
-            name="projecte-aina/roberta-large-ca-v2",
-            dimensions=1024,
-            max_sequence_length=512,
-            languages=["Catalan"],
-            model_type="general",
-            description="Catalan RoBERTa-large model trained on large corpus"
         )
     ]
 
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    all_models_loaded = len(models_cache) == 5
+    startup_loaded = STARTUP_MODEL in models_cache
     
     return {
-        "status": "healthy",
-        "all_models_loaded": all_models_loaded,
+        "status": "healthy" if startup_loaded else "partial",
+        "startup_model": STARTUP_MODEL,
+        "startup_model_loaded": startup_loaded,
         "available_models": list(models_cache.keys()),
-        "on_demand_models": ON_DEMAND_MODELS,
         "models_count": len(models_cache),
-        "note": "All models load on first embedding request - minimal deployment version"
+        "endpoints": {
+            "jina-v3": f"/embed/jina-v3 {'(ready)' if 'jina-v3' in models_cache else '(loads on demand)'}",
+            "roberta-ca": f"/embed/roberta-ca {'(ready)' if 'roberta-ca' in models_cache else '(loads on demand)'}",
+            "jina": f"/embed/jina {'(ready)' if 'jina' in models_cache else '(loads on demand)'}",
+            "robertalex": f"/embed/robertalex {'(ready)' if 'robertalex' in models_cache else '(loads on demand)'}",
+            "legal-bert": f"/embed/legal-bert {'(ready)' if 'legal-bert' in models_cache else '(loads on demand)'}"
+        }
     }
 
 if __name__ == "__main__":

app_endpoints.py

@@ -0,0 +1,308 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from typing import List
+import torch
+import uvicorn
+
+from models.schemas import EmbeddingRequest, EmbeddingResponse, ModelInfo
+from utils.helpers import load_models, get_embeddings, cleanup_memory
+
+# Global model cache
+models_cache = {}
+
+# Load jina-v3 at startup (most important model)
+STARTUP_MODEL = "jina-v3"
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan handler for startup and shutdown"""
+    # Startup - load jina-v3 model
+    try:
+        global models_cache
+        print(f"Loading startup model: {STARTUP_MODEL}...")
+        models_cache = load_models([STARTUP_MODEL])
+        print(f"Startup model loaded successfully: {list(models_cache.keys())}")
+        yield
+    except Exception as e:
+        print(f"Failed to load startup model: {str(e)}")
+        # Continue anyway - jina-v3 can be loaded on demand if startup fails
+        yield
+    finally:
+        # Shutdown - cleanup resources
+        cleanup_memory()
+
+def ensure_model_loaded(model_name: str, max_length_limit: int):
+    """Load a specific model on demand if not already loaded"""
+    global models_cache
+    if model_name not in models_cache:
+        try:
+            print(f"Loading model on demand: {model_name}...")
+            new_models = load_models([model_name])
+            models_cache.update(new_models)
+            print(f"Model {model_name} loaded successfully!")
+        except Exception as e:
+            print(f"Failed to load model {model_name}: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Model {model_name} loading failed: {str(e)}")
+
+def validate_request_for_model(request: EmbeddingRequest, model_name: str, max_length_limit: int):
+    """Validate request parameters for specific model"""
+    if not request.texts:
+        raise HTTPException(status_code=400, detail="No texts provided")
+    
+    if len(request.texts) > 50:
+        raise HTTPException(status_code=400, detail="Maximum 50 texts per request")
+    
+    if request.max_length is not None and request.max_length > max_length_limit:
+        raise HTTPException(status_code=400, detail=f"Max length for {model_name} is {max_length_limit}")
+
+app = FastAPI(
+    title="Multilingual & Legal Embedding API",
+    description="Multi-model embedding API with dedicated endpoints per model",
+    version="4.0.0",
+    lifespan=lifespan
+)
+
+# Add CORS middleware to allow cross-origin requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify actual domains
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Multilingual & Legal Embedding API - Endpoint Per Model",
+        "version": "4.0.0",
+        "status": "running",
+        "docs": "/docs",
+        "startup_model": STARTUP_MODEL,
+        "available_endpoints": {
+            "jina-v3": "/embed/jina-v3",
+            "roberta-ca": "/embed/roberta-ca", 
+            "jina": "/embed/jina",
+            "robertalex": "/embed/robertalex",
+            "legal-bert": "/embed/legal-bert"
+        }
+    }
+
+# Jina v3 - Multilingual (loads at startup)
+@app.post("/embed/jina-v3", response_model=EmbeddingResponse)
+async def embed_jina_v3(request: EmbeddingRequest):
+    """Generate embeddings using Jina v3 model (multilingual)"""
+    try:
+        ensure_model_loaded("jina-v3", 8192)
+        validate_request_for_model(request, "jina-v3", 8192)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "jina-v3",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="jina-v3",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# Catalan RoBERTa
+@app.post("/embed/roberta-ca", response_model=EmbeddingResponse)
+async def embed_roberta_ca(request: EmbeddingRequest):
+    """Generate embeddings using Catalan RoBERTa model"""
+    try:
+        ensure_model_loaded("roberta-ca", 512)
+        validate_request_for_model(request, "roberta-ca", 512)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "roberta-ca",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="roberta-ca",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# Jina v2 - Spanish/English
+@app.post("/embed/jina", response_model=EmbeddingResponse)
+async def embed_jina(request: EmbeddingRequest):
+    """Generate embeddings using Jina v2 Spanish/English model"""
+    try:
+        ensure_model_loaded("jina", 8192)
+        validate_request_for_model(request, "jina", 8192)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "jina",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="jina",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# RoBERTalex - Spanish Legal
+@app.post("/embed/robertalex", response_model=EmbeddingResponse)
+async def embed_robertalex(request: EmbeddingRequest):
+    """Generate embeddings using RoBERTalex Spanish legal model"""
+    try:
+        ensure_model_loaded("robertalex", 512)
+        validate_request_for_model(request, "robertalex", 512)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "robertalex",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="robertalex",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+# Legal BERT - English Legal
+@app.post("/embed/legal-bert", response_model=EmbeddingResponse)
+async def embed_legal_bert(request: EmbeddingRequest):
+    """Generate embeddings using Legal BERT English model"""
+    try:
+        ensure_model_loaded("legal-bert", 512)
+        validate_request_for_model(request, "legal-bert", 512)
+        
+        embeddings = get_embeddings(
+            request.texts,
+            "legal-bert",
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used="legal-bert",
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+@app.get("/models", response_model=List[ModelInfo])
+async def list_models():
+    """List available models and their specifications"""
+    return [
+        ModelInfo(
+            model_id="jina-v3",
+            name="jinaai/jina-embeddings-v3",
+            dimensions=1024,
+            max_sequence_length=8192,
+            languages=["Multilingual"],
+            model_type="multilingual",
+            description="Latest Jina v3 with superior multilingual performance - loaded at startup"
+        ),
+        ModelInfo(
+            model_id="roberta-ca",
+            name="projecte-aina/roberta-large-ca-v2",
+            dimensions=1024,
+            max_sequence_length=512,
+            languages=["Catalan"],
+            model_type="general",
+            description="Catalan RoBERTa-large model trained on large corpus"
+        ),
+        ModelInfo(
+            model_id="jina",
+            name="jinaai/jina-embeddings-v2-base-es",
+            dimensions=768,
+            max_sequence_length=8192,
+            languages=["Spanish", "English"],
+            model_type="bilingual",
+            description="Bilingual Spanish-English embeddings with long context support"
+        ),
+        ModelInfo(
+            model_id="robertalex",
+            name="PlanTL-GOB-ES/RoBERTalex",
+            dimensions=768,
+            max_sequence_length=512,
+            languages=["Spanish"],
+            model_type="legal domain",
+            description="Spanish legal domain specialized embeddings"
+        ),
+        ModelInfo(
+            model_id="legal-bert",
+            name="nlpaueb/legal-bert-base-uncased",
+            dimensions=768,
+            max_sequence_length=512,
+            languages=["English"],
+            model_type="legal domain",
+            description="English legal domain BERT model"
+        )
+    ]
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    startup_loaded = STARTUP_MODEL in models_cache
+    
+    return {
+        "status": "healthy" if startup_loaded else "partial",
+        "startup_model": STARTUP_MODEL,
+        "startup_model_loaded": startup_loaded,
+        "available_models": list(models_cache.keys()),
+        "models_count": len(models_cache),
+        "endpoints": {
+            "jina-v3": f"/embed/jina-v3 {'(ready)' if 'jina-v3' in models_cache else '(loads on demand)'}",
+            "roberta-ca": f"/embed/roberta-ca {'(ready)' if 'roberta-ca' in models_cache else '(loads on demand)'}",
+            "jina": f"/embed/jina {'(ready)' if 'jina' in models_cache else '(loads on demand)'}",
+            "robertalex": f"/embed/robertalex {'(ready)' if 'robertalex' in models_cache else '(loads on demand)'}",
+            "legal-bert": f"/embed/legal-bert {'(ready)' if 'legal-bert' in models_cache else '(loads on demand)'}"
+        }
+    }
+
+if __name__ == "__main__":
+    # Set multi-threading for CPU
+    torch.set_num_threads(8)
+    torch.set_num_interop_threads(1)
+    
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app_old_minimal.py

@@ -0,0 +1,165 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List
+import torch
+import uvicorn
+
+from models.schemas import EmbeddingRequest, EmbeddingResponse, ModelInfo
+from utils.helpers import load_models, get_embeddings, cleanup_memory
+
+# Global model cache - completely on-demand loading
+models_cache = {}
+
+# All models load on demand to test deployment
+ON_DEMAND_MODELS = ["jina", "robertalex", "jina-v3", "legal-bert", "roberta-ca"]
+
+def ensure_model_loaded(model_name: str):
+    """Load a specific model on demand if not already loaded"""
+    global models_cache
+    if model_name not in models_cache:
+        if model_name in ON_DEMAND_MODELS:
+            try:
+                print(f"Loading model on demand: {model_name}...")
+                new_models = load_models([model_name])
+                models_cache.update(new_models)
+                print(f"Model {model_name} loaded successfully!")
+            except Exception as e:
+                print(f"Failed to load model {model_name}: {str(e)}")
+                raise HTTPException(status_code=500, detail=f"Model {model_name} loading failed: {str(e)}")
+        else:
+            raise HTTPException(status_code=400, detail=f"Unknown model: {model_name}")
+
+app = FastAPI(
+    title="Multilingual & Legal Embedding API",
+    description="Multi-model embedding API for Spanish, Catalan, English and Legal texts",
+    version="3.0.0"
+)
+
+# Add CORS middleware to allow cross-origin requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify actual domains
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Multilingual & Legal Embedding API - Minimal Version",
+        "models": ["jina", "robertalex", "jina-v3", "legal-bert", "roberta-ca"],
+        "status": "running",
+        "docs": "/docs",
+        "total_models": 5,
+        "note": "All models load on first request"
+    }
+
+@app.post("/embed", response_model=EmbeddingResponse)
+async def create_embeddings(request: EmbeddingRequest):
+    """Generate embeddings for input texts"""
+    try:
+        # Load specific model on demand
+        ensure_model_loaded(request.model)
+        
+        if not request.texts:
+            raise HTTPException(status_code=400, detail="No texts provided")
+        
+        if len(request.texts) > 50:  # Rate limiting
+            raise HTTPException(status_code=400, detail="Maximum 50 texts per request")
+        
+        embeddings = get_embeddings(
+            request.texts,
+            request.model,
+            models_cache,
+            request.normalize,
+            request.max_length
+        )
+        
+        # Cleanup memory after large batches
+        if len(request.texts) > 20:
+            cleanup_memory()
+        
+        return EmbeddingResponse(
+            embeddings=embeddings,
+            model_used=request.model,
+            dimensions=len(embeddings[0]) if embeddings else 0,
+            num_texts=len(request.texts)
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+@app.get("/models", response_model=List[ModelInfo])
+async def list_models():
+    """List available models and their specifications"""
+    return [
+        ModelInfo(
+            model_id="jina",
+            name="jinaai/jina-embeddings-v2-base-es",
+            dimensions=768,
+            max_sequence_length=8192,
+            languages=["Spanish", "English"],
+            model_type="bilingual",
+            description="Bilingual Spanish-English embeddings with long context support"
+        ),
+        ModelInfo(
+            model_id="robertalex",
+            name="PlanTL-GOB-ES/RoBERTalex",
+            dimensions=768,
+            max_sequence_length=512,
+            languages=["Spanish"],
+            model_type="legal domain",
+            description="Spanish legal domain specialized embeddings"
+        ),
+        ModelInfo(
+            model_id="jina-v3",
+            name="jinaai/jina-embeddings-v3",
+            dimensions=1024,
+            max_sequence_length=8192,
+            languages=["Multilingual"],
+            model_type="multilingual",
+            description="Latest Jina v3 with superior multilingual performance"
+        ),
+        ModelInfo(
+            model_id="legal-bert",
+            name="nlpaueb/legal-bert-base-uncased",
+            dimensions=768,
+            max_sequence_length=512,
+            languages=["English"],
+            model_type="legal domain",
+            description="English legal domain BERT model"
+        ),
+        ModelInfo(
+            model_id="roberta-ca",
+            name="projecte-aina/roberta-large-ca-v2",
+            dimensions=1024,
+            max_sequence_length=512,
+            languages=["Catalan"],
+            model_type="general",
+            description="Catalan RoBERTa-large model trained on large corpus"
+        )
+    ]
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    all_models_loaded = len(models_cache) == 5
+    
+    return {
+        "status": "healthy",
+        "all_models_loaded": all_models_loaded,
+        "available_models": list(models_cache.keys()),
+        "on_demand_models": ON_DEMAND_MODELS,
+        "models_count": len(models_cache),
+        "note": "All models load on first embedding request - minimal deployment version"
+    }
+
+if __name__ == "__main__":
+    # Set multi-threading for CPU
+    torch.set_num_threads(8)
+    torch.set_num_interop_threads(1)
+    
+    uvicorn.run(app, host="0.0.0.0", port=7860)

models/schemas.py

@@ -11,10 +11,6 @@ class EmbeddingRequest(BaseModel):
         description="List of texts to embed",
         example=["Hola mundo", "¿Cómo estás?"]
     )
-    model: Literal["jina", "robertalex", "jina-v3", "legal-bert", "roberta-ca"] = Field(
-        default="jina",
-        description="Model to use for embeddings"
-    )
     normalize: bool = Field(
         default=True,
         description="Whether to normalize embeddings to unit length"
@@ -36,15 +32,12 @@ class EmbeddingRequest(BaseModel):
         return v
     
     @validator('max_length')
-    def validate_max_length(cls, v, values):
+    def validate_max_length(cls, v):
         if v is not None:
-            model = values.get('model', 'jina')
-            if model in ['jina', 'jina-v3'] and v > 8192:
-                raise ValueError(f"Max length for {model} model is 8192")
-            elif model in ['robertalex', 'legal-bert', 'roberta-ca'] and v > 512:
-                raise ValueError(f"Max length for {model} model is 512")
             if v < 1:
                 raise ValueError("Max length must be positive")
+            if v > 8192:
+                raise ValueError("Max length cannot exceed 8192")
         return v
 
 class EmbeddingResponse(BaseModel):

test_endpoints.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""
+Test script for the new endpoint-per-model API architecture
+"""
+
+import requests
+import json
+import time
+
+def test_endpoint_api(base_url="https://aurasystems-spanish-embeddings-api.hf.space"):
+    """Test the new endpoint-based API"""
+    
+    print(f"Testing Endpoint-Based API at {base_url}")
+    print("=" * 60)
+    
+    # Test root endpoint
+    try:
+        response = requests.get(f"{base_url}/")
+        print(f"✓ Root endpoint: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"  Version: {data.get('version', 'N/A')}")
+            print(f"  Startup model: {data.get('startup_model', 'N/A')}")
+            print(f"  Available endpoints: {list(data.get('available_endpoints', {}).keys())}")
+        else:
+            print(f"  Error: {response.text}")
+            return False
+    except Exception as e:
+        print(f"✗ Root endpoint failed: {e}")
+        return False
+    
+    # Test health endpoint
+    try:
+        response = requests.get(f"{base_url}/health")
+        print(f"✓ Health endpoint: {response.status_code}")
+        if response.status_code == 200:
+            health_data = response.json()
+            print(f"  Startup model loaded: {health_data.get('startup_model_loaded', False)}")
+            print(f"  Available models: {health_data.get('available_models', [])}")
+            print(f"  Models count: {health_data.get('models_count', 0)}")
+        else:
+            print(f"  Error: {response.text}")
+    except Exception as e:
+        print(f"✗ Health endpoint failed: {e}")
+    
+    print("\n" + "=" * 60)
+    print("TESTING MODEL ENDPOINTS")
+    print("=" * 60)
+    
+    # Test jina-v3 endpoint (startup model)
+    try:
+        payload = {
+            "texts": ["Hello world", "Bonjour le monde", "Hola mundo"],
+            "normalize": True
+        }
+        response = requests.post(f"{base_url}/embed/jina-v3", json=payload)
+        print(f"✓ Jina-v3 endpoint: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"  Model: {data.get('model_used', 'N/A')}")
+            print(f"  Embeddings: {data.get('num_texts', 0)} texts → {data.get('dimensions', 0)} dimensions")
+        else:
+            print(f"  Error: {response.text}")
+    except Exception as e:
+        print(f"✗ Jina-v3 endpoint failed: {e}")
+    
+    # Test roberta-ca endpoint (on-demand)
+    try:
+        payload = {
+            "texts": ["Bon dia", "Com estàs?", "Catalunya és meravellosa"],
+            "normalize": True
+        }
+        response = requests.post(f"{base_url}/embed/roberta-ca", json=payload)
+        print(f"✓ RoBERTa-ca endpoint: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"  Model: {data.get('model_used', 'N/A')}")
+            print(f"  Embeddings: {data.get('num_texts', 0)} texts → {data.get('dimensions', 0)} dimensions")
+        else:
+            print(f"  Error: {response.text}")
+    except Exception as e:
+        print(f"✗ RoBERTa-ca endpoint failed: {e}")
+    
+    # Test jina endpoint (on-demand)
+    try:
+        payload = {
+            "texts": ["Texto en español", "Text in English"],
+            "normalize": True
+        }
+        response = requests.post(f"{base_url}/embed/jina", json=payload)
+        print(f"✓ Jina endpoint: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"  Model: {data.get('model_used', 'N/A')}")
+            print(f"  Embeddings: {data.get('num_texts', 0)} texts → {data.get('dimensions', 0)} dimensions")
+        else:
+            print(f"  Error: {response.text}")
+    except Exception as e:
+        print(f"✗ Jina endpoint failed: {e}")
+    
+    # Test robertalex endpoint (Spanish legal)
+    try:
+        payload = {
+            "texts": ["Artículo primero de la constitución", "El contrato será válido"],
+            "normalize": True
+        }
+        response = requests.post(f"{base_url}/embed/robertalex", json=payload)
+        print(f"✓ RoBERTalex endpoint: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"  Model: {data.get('model_used', 'N/A')}")
+            print(f"  Embeddings: {data.get('num_texts', 0)} texts → {data.get('dimensions', 0)} dimensions")
+        else:
+            print(f"  Error: {response.text}")
+    except Exception as e:
+        print(f"✗ RoBERTalex endpoint failed: {e}")
+    
+    # Test legal-bert endpoint (English legal)
+    try:
+        payload = {
+            "texts": ["This agreement is legally binding", "The contract shall be valid"],
+            "normalize": True
+        }
+        response = requests.post(f"{base_url}/embed/legal-bert", json=payload)
+        print(f"✓ Legal-BERT endpoint: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"  Model: {data.get('model_used', 'N/A')}")
+            print(f"  Embeddings: {data.get('num_texts', 0)} texts → {data.get('dimensions', 0)} dimensions")
+        else:
+            print(f"  Error: {response.text}")
+    except Exception as e:
+        print(f"✗ Legal-BERT endpoint failed: {e}")
+    
+    print("\n" + "=" * 60)
+    print("FINAL HEALTH CHECK")
+    print("=" * 60)
+    
+    # Final health check to see all loaded models
+    try:
+        response = requests.get(f"{base_url}/health")
+        if response.status_code == 200:
+            health_data = response.json()
+            print(f"✓ Final status: {health_data.get('status', 'unknown')}")
+            print(f"  Available models: {health_data.get('available_models', [])}")
+            print(f"  Total models loaded: {health_data.get('models_count', 0)}/5")
+            
+            endpoints = health_data.get('endpoints', {})
+            for model, status in endpoints.items():
+                print(f"  {model}: {status}")
+    except Exception as e:
+        print(f"✗ Final health check failed: {e}")
+    
+    return True
+
+if __name__ == "__main__":
+    test_endpoint_api()