update: Response format

src/api/routers/embedding.py

@@ -7,6 +7,7 @@ multiple texts in a single request.
 
 import time
 from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.responses import JSONResponse
 from loguru import logger
 
 from src.models.schemas import (
@@ -14,8 +15,6 @@ from src.models.schemas import (
     DenseEmbedResponse,
     EmbeddingObject,
     TokenUsage,
-    SparseEmbedResponse,
-    SparseEmbedding,
 )
 from src.core.manager import ModelManager
 from src.core.exceptions import (
@@ -31,16 +30,17 @@ from src.utils.validators import (
     ensure_model_type,
 )
 
-router = APIRouter(tags=["embeddings"])
+router = APIRouter()
 
 
 @router.post(
     "/embeddings",
     response_model=DenseEmbedResponse,
+    tags=["OpenAI Compatible"],
     summary="Generate single/batch embeddings",
     description="Generate embeddings for multiple texts in a single request",
 )
-async def create_embeddings(
+async def create_openai_embeddings(
     request: EmbedRequest, manager: ModelManager = Depends(get_model_manager)
 ):
     """
@@ -100,6 +100,66 @@ async def create_embeddings(
 
         return response
 
+    except (ValidationError, ModelNotFoundError) as e:
+        raise HTTPException(status_code=e.status_code, detail=e.message)
+    except ModelNotLoadedError as e:
+        raise HTTPException(status_code=e.status_code, detail=e.message)
+    except EmbeddingGenerationError as e:
+        raise HTTPException(status_code=e.status_code, detail=e.message)
+    except Exception as e:
+        logger.exception("Unexpected error in create_openai_embeddings")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create embeddings: {str(e)}",
+        )
+
+
+@router.post(
+    "/embed",
+    tags=["embeddings"],
+    summary="Generate single/batch dense embeddings",
+    description="Generate embedding for a multiple query text",
+)
+async def create_embeddings(
+    request: EmbedRequest, manager: ModelManager = Depends(get_model_manager)
+):
+    """
+    Generate embeddings for multiple texts.
+
+    The endpoint validates the request, checks that the requested
+    model is a dense embedding model, and returns a
+    :class:`DenseEmbedResponse`.
+
+    Raises:
+        HTTPException: On validation or generation errors
+    """
+
+    texts = [request.input] if isinstance(request.input, str) else request.input
+
+    if not texts or not isinstance(texts, list):
+        raise ValidationError("Input must be a non-empty list or string.")
+
+    try:
+        kwargs = extract_embedding_kwargs(request)
+
+        model = manager.get_model(request.model)
+        config = manager.model_configs.get(request.model)
+
+        ensure_model_type(config, "embeddings", request.model)
+
+        start_time = time.time()
+
+        embeddings = model.embed(input=texts, **kwargs)
+        processing_time = time.time() - start_time
+
+        
+        logger.info(
+            f"Generated {len(texts)} embeddings "
+            f"in {processing_time:.3f}s ({len(texts) / processing_time:.1f} texts/s)"
+        )
+
+        return JSONResponse(content=embeddings)
+
     except (ValidationError, ModelNotFoundError) as e:
         raise HTTPException(status_code=e.status_code, detail=e.message)
     except ModelNotLoadedError as e:
@@ -116,7 +176,7 @@ async def create_embeddings(
 
 @router.post(
     "/embed_sparse",
-    response_model=SparseEmbedResponse,
+    tags=["embeddings"],
     summary="Generate single/batch sparse embeddings",
     description="Generate embedding for a multiple query text",
 )
@@ -151,28 +211,18 @@ async def create_sparse_embedding(
 
         sparse_results = model.embed(input=texts, **kwargs)
         processing_time = time.time() - start_time
-
-        sparse_embeddings = [
-            SparseEmbedding(
-                text=texts[idx],
-                indices=sparse_result["indices"],
-                values=sparse_result["values"],
-            )
-            for idx, sparse_result in enumerate(sparse_results)
+        
+        formatted_embeddings = [
+            [{"index": i, "value": v} for i, v in zip(res["indices"], res["values"])]
+            for res in sparse_results
         ]
 
-        response = SparseEmbedResponse(
-            embeddings=sparse_embeddings,
-            count=len(sparse_embeddings),
-            model=request.model,
-        )
-
         logger.info(
             f"Generated {len(texts)} embeddings "
             f"in {processing_time:.3f}s ({len(texts) / processing_time:.1f} texts/s)"
         )
 
-        return response
+        return JSONResponse(content=formatted_embeddings)
 
     except (ValidationError, ModelNotFoundError) as e:
         raise HTTPException(status_code=e.status_code, detail=e.message)

src/models/schemas/__init__.py

@@ -6,7 +6,6 @@ the application.
 """
 
 from .common import (
-    SparseEmbedding,
     ModelInfo,
     HealthStatus,
     ErrorResponse,
@@ -18,7 +17,6 @@ from .requests import BaseEmbedRequest, EmbedRequest, RerankRequest
 from .responses import (
     BaseEmbedResponse,
     DenseEmbedResponse,
-    SparseEmbedResponse,
     RerankResponse,
     EmbeddingObject,
     TokenUsage,
@@ -29,7 +27,6 @@ from .responses import (
 
 __all__ = [
     # Common
-    "SparseEmbedding",
     "ModelInfo",
     "HealthStatus",
     "ErrorResponse",
@@ -43,7 +40,6 @@ __all__ = [
     "DenseEmbedResponse",
     "EmbeddingObject",
     "TokenUsage",
-    "SparseEmbedResponse",
     "RerankResponse",
     "RerankResult",
     "ModelsListResponse",

src/models/schemas/common.py

@@ -5,40 +5,10 @@ This module contains Pydantic models used by both requests and responses,
 such as SparseEmbedding and ModelInfo.
 """
 
-from typing import List, Optional, Literal
+from typing import Optional, Literal
 from pydantic import BaseModel, Field, ConfigDict
 
 
-class SparseEmbedding(BaseModel):
-    """
-    Sparse embedding representation.
-
-    Sparse embeddings are represented as two parallel arrays:
-    - indices: positions of non-zero values
-    - values: the actual values at those positions
-
-    Attributes:
-        indices: List of indices for non-zero elements
-        values: List of values corresponding to the indices
-        text: Optional original text that was embedded
-    """
-
-    indices: List[int] = Field(
-        ..., description="Indices of non-zero elements in the sparse vector"
-    )
-    values: List[float] = Field(..., description="Values corresponding to the indices")
-    text: Optional[str] = Field(None, description="Original text that was embedded")
-
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "indices": [10, 25, 42, 100],
-                "values": [0.85, 0.62, 0.91, 0.73],
-                "text": "example query text",
-            }
-        }
-
-
 class ModelInfo(BaseModel):
     """
     Information about an available model.

src/models/schemas/responses.py

@@ -7,7 +7,7 @@ ensuring consistent output format across all endpoints.
 
 from typing import List, Literal
 from pydantic import BaseModel, Field
-from .common import SparseEmbedding, ModelInfo
+from .common import ModelInfo
 
 
 class BaseEmbedResponse(BaseModel):
@@ -68,45 +68,6 @@ class DenseEmbedResponse(BaseEmbedResponse):
         }
 
 
-class SparseEmbedResponse(BaseEmbedResponse):
-    """
-    Response model for single/batch sparse embeddings.
-
-    Used for /embed_sparse endpoint sparse models.
-
-    Attributes:
-        embeddings: List of generated sparse embeddings
-        count: Number of embeddings returned
-        model: Identifier of the model used
-    """
-
-    embeddings: List[SparseEmbedding] = Field(
-        ..., description="List of sparse embeddings"
-    )
-    count: int = Field(..., description="Number of embeddings", ge=1)
-
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "embeddings": [
-                    {
-                        "indices": [10, 25, 42],
-                        "values": [0.85, 0.62, 0.91],
-                        "text": "first text",
-                    },
-                    {
-                        "indices": [15, 30, 50],
-                        "values": [0.73, 0.88, 0.65],
-                        "text": "second text",
-                    },
-                ],
-                "count": 2,
-                "model_id": "splade-pp-v2",
-                "processing_time": 0.0892,
-            }
-        }
-
-
 class RerankResult(BaseModel):
     """
     Single reranking result.