Spaces:
Sleeping
Sleeping
File size: 5,926 Bytes
0458600 3fe3157 0458600 c130de9 0458600 c130de9 0458600 fdb03af 0458600 c130de9 e8bbc58 0458600 3adb6fd 0458600 3adb6fd 0458600 3adb6fd 0458600 f6c8e43 0458600 e8bbc58 0458600 e8bbc58 0458600 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | """OpenAI SDK-compatible embeddings API, intentionally separate from Voyage routes.
Configure OpenAI(base_url="https://HOST/openai/v1", api_key="...").
The client is responsible for model-specific query/document prefixes.
"""
from __future__ import annotations
import base64
import logging
import struct
from typing import Literal
from fastapi import APIRouter, Depends
from fastapi.responses import JSONResponse
from pydantic import BaseModel, ConfigDict, Field, field_validator
from app.embedding import MODEL_ID as E5_ID, TooManyTokens
from app.bge_m3 import BGE_M3_ID
from app.models import ModelRegistry, QWEN_ID, ServiceBusy
from app.voyage_api import authenticate, resident_models
router = APIRouter(prefix="/openai/v1", tags=["OpenAI-compatible"])
log = logging.getLogger(__name__)
DenseModelName = Literal[
"e5", "qwen", "bge-m3", "intfloat/multilingual-e5-small",
"Qwen/Qwen3-Embedding-0.6B", "BAAI/bge-m3"
]
class OpenAIEmbeddingRequest(BaseModel):
model_config = ConfigDict(extra="forbid")
model: DenseModelName
input: str | list[str] = Field(
description="Raw input; client must add model-specific query/document prefixes"
)
dimensions: int | None = Field(default=None, ge=1)
encoding_format: Literal["float", "base64"] = "float"
user: str | None = None
# Non-standard client probe flag (e.g. OpenAI-compatible integrations).
# It does not change server-side processing; accept it for compatibility.
drop_params: bool | None = None
@field_validator("input")
@classmethod
def validate_input(cls, value):
texts = [value] if isinstance(value, str) else value
if not texts or len(texts) > 1000:
raise ValueError("input must contain between 1 and 1000 texts")
if any(not text.strip() for text in texts):
raise ValueError("input cannot contain blank strings")
return value
def api_error(status: int, message: str, error_type="invalid_request_error", code=None):
return JSONResponse(status_code=status, content={
"error": {"message": message, "type": error_type, "param": None, "code": code}
})
@router.post("/embeddings", dependencies=[Depends(authenticate)])
def create_embedding(
request: OpenAIEmbeddingRequest,
registry: ModelRegistry = Depends(resident_models),
):
model = request.model
if model in ("bge-m3", BGE_M3_ID):
canonical, engine = BGE_M3_ID, registry.bge_m3
elif model in ("qwen", QWEN_ID):
canonical, engine = QWEN_ID, registry.qwen
else:
canonical, engine = E5_ID, registry.e5
if engine is None:
return api_error(503, f"Model {model} is not enabled", "server_error")
if request.dimensions is not None and request.dimensions != engine.dimensions:
log.warning(
"OpenAI embeddings rejected: reason=unsupported_dimensions model=%s "
"requested_dimensions=%d expected_dimensions=%d",
model, request.dimensions, engine.dimensions,
)
return api_error(
400,
f"Model {model} supports exactly {engine.dimensions} dimensions",
code="unsupported_dimensions",
)
texts = [request.input] if isinstance(request.input, str) else request.input
try:
results = registry.openai_encode(texts, canonical)
except TooManyTokens as exc:
log.warning(
"OpenAI embeddings rejected: reason=context_length_exceeded model=%s "
"batch_size=%d input_index=%s input_tokens=%d max_tokens=%d",
model, len(texts), exc.input_index, exc.count, exc.limit,
)
return api_error(400, str(exc), code="context_length_exceeded")
except ValueError as exc:
# Never log input texts or untrusted tokenizer exception contents.
reason = ("batch_token_budget_exceeded"
if str(exc) == "Batch exceeds 65536 total input tokens"
else "invalid_batch")
log.warning(
"OpenAI embeddings rejected: reason=%s model=%s batch_size=%d",
reason, model, len(texts),
)
return api_error(400, str(exc))
except ServiceBusy as exc:
response = api_error(429, str(exc), "rate_limit_error", "rate_limit_exceeded")
response.headers["Retry-After"] = "2"
return response
except Exception:
log.exception("OpenAI-compatible embedding failed")
return api_error(500, "Embedding generation failed", "server_error")
def encode(vector):
if request.encoding_format == "float":
return vector
raw = struct.pack(f"<{len(vector)}f", *vector)
return base64.b64encode(raw).decode("ascii")
total_tokens = sum(result.tokens_count for result in results)
# Compact preview of successful inputs for source attribution.
previews = [(i, value[:240]) for i, value in enumerate(texts[:3])]
log.warning("Embeddings input preview: model=%s chunks=%d previews=%r",
model, len(texts), previews)
return {
"object": "list",
"data": [
{"object": "embedding", "index": index, "embedding": encode(item.embedding)}
for index, item in enumerate(results)
],
"model": model,
"usage": {"prompt_tokens": total_tokens, "total_tokens": total_tokens},
}
@router.get("/models", dependencies=[Depends(authenticate)])
def list_models(registry: ModelRegistry = Depends(resident_models)):
available = []
if registry.e5 is not None:
available.extend(("e5", E5_ID))
if registry.qwen is not None:
available.extend(("qwen", QWEN_ID))
if registry.bge_m3 is not None:
available.extend(("bge-m3", BGE_M3_ID))
return {
"object": "list",
"data": [
{"id": mid, "object": "model", "created": 0, "owned_by": "local"}
for mid in available
],
}
|