Deploy vectorization service from GitHub 3eb9f3be642221ba8ff6c4accaec7a9da8978534

README.md

@@ -113,13 +113,22 @@ to the base URL ending in `/openai/v1`, not to the Voyage `/v1` URL.
   `usage.total_tokens` format. Only fixed native dimensions are supported.
 - `GET /openai/v1/models`: dense model aliases for provider selection.
 - Bearer authentication uses the **same** `API_KEY` as Voyage; no new secrets.
-- Dense E5 and Qwen3 only. ColBERT retains `/colbert/encode` and Voyage extension.
+- Dense E5, Qwen3 and BGE-M3 (`bge-m3` or `BAAI/bge-m3`). BGE-M3
+  returns only its 1024D dense embedding; sparse and ColBERT are not
+  computed on this route. Use `/bge-m3/encode` for the hybrid API.
+  mLateOn ColBERT remains on `/colbert/encode` and Voyage.
 - **Crucial:** this endpoint forwards raw input to the tokenizer **without adding any
   query/document instructions**. Supply prefixes in the client configuration.
   For **E5 only**, inputs exceeding 512 tokens are truncated from the right
   to 512 tokens, including the prefix and special tokens. Short inputs are
   unchanged; truncation is logged with the input index and original token count.
-  Qwen inputs are not truncated. Unsupported dimensions return an error.
+  Qwen and BGE-M3 inputs are not truncated (BGE-M3 uses
+  `BGE_M3_MAX_TOKENS=2048` by default). Unsupported dimensions return an error.
+
+For BGE-M3 in Dify: use model `bge-m3`, embedding dimensions `1024`,
+and leave query/document prefixes empty. Only dense vectors are returned
+to standard OpenAI-compatible clients; the native BGE-M3 endpoint keeps
+dense + sparse and optional ColBERT.
 
 For E5 configure in Dify:
 - Document prefix: `passage:`

VERSION

@@ -1 +1 @@
-f2352e8140c520d4480226b9332c05011709ed54
+3eb9f3be642221ba8ff6c4accaec7a9da8978534

app/bge_m3.py

@@ -55,7 +55,8 @@ class BgeM3Engine:
         )
         return cls(model, max_tokens=max_tokens)
 
-    def encode(self, texts: list[str], return_colbert: bool = False) -> list[BgeM3Embedding]:
+    def encode(self, texts: list[str], return_colbert: bool = False,
+               return_sparse: bool = True) -> list[BgeM3Embedding]:
         if not texts or len(texts) > 8:
             raise ValueError("BGE-M3 accepts between 1 and 8 texts per request")
 
@@ -80,20 +81,22 @@ class BgeM3Engine:
                 batch_size=1,
                 max_length=self.max_tokens,
                 return_dense=True,
-                return_sparse=True,
+                return_sparse=return_sparse,
                 return_colbert_vecs=return_colbert,
             )
             dense = [float(x) for x in outputs["dense_vecs"][0]]
             validate_vector(dense, self.dimensions)
 
-            weights = outputs["lexical_weights"][0]
-            sparse_items = sorted(
-                (int(token_id), float(weight))
-                for token_id, weight in weights.items()
-            )
-            if any(index < 0 or not math.isfinite(weight) or weight < 0
-                   for index, weight in sparse_items):
-                raise RuntimeError("Invalid BGE-M3 sparse weights")
+            sparse_items = []
+            if return_sparse:
+                weights = outputs["lexical_weights"][0]
+                sparse_items = sorted(
+                    (int(token_id), float(weight))
+                    for token_id, weight in weights.items()
+                )
+                if any(index < 0 or not math.isfinite(weight) or weight < 0
+                       for index, weight in sparse_items):
+                    raise RuntimeError("Invalid BGE-M3 sparse weights")
 
             colbert = None
             if return_colbert:

app/models.py

@@ -186,8 +186,44 @@ class ModelRegistry:
         return (QWEN_ID if engine is self.qwen else E5_ID), engine.dimensions, result
 
     def openai_encode(self, texts, canonical_model):
-        """Raw OpenAI-compatible embeddings: client supplies any query/document prefix."""
+        """OpenAI-compatible output is always dense only."""
         from app.batching import batch_encode
+        from app.bge_m3 import BGE_M3_ID
+        if canonical_model == BGE_M3_ID:
+            if self.bge_m3 is None:
+                raise ValueError("BGE-M3 is disabled")
+
+            def encode_bge_dense():
+                engine = self.bge_m3
+                counts = [
+                    len(engine.model.tokenizer(text, add_special_tokens=True,
+                                               truncation=False)["input_ids"])
+                    for text in texts
+                ]
+                for index, count in enumerate(counts):
+                    if count > engine.max_tokens:
+                        raise TooManyTokens(count, engine.max_tokens,
+                                            input_index=index)
+                if sum(counts) > 65536:
+                    raise ValueError("Batch exceeds 65536 total input tokens")
+                results = []
+                group, group_tokens = [], 0
+                # Dify may send 16+ texts; internal native BGE max is 8.
+                for text, count in zip(texts, counts):
+                    if group and (len(group) == 8 or group_tokens + count > 8192):
+                        results.extend(engine.encode(
+                            group, return_sparse=False, return_colbert=False))
+                        group, group_tokens = [], 0
+                    group.append(text)
+                    group_tokens += count
+                if group:
+                    results.extend(engine.encode(
+                        group, return_sparse=False, return_colbert=False))
+                return [EmbeddingResult(
+                    tokens_count=item.tokens_count, embedding=item.dense)
+                    for item in results]
+
+            return self._run(encode_bge_dense)
         if canonical_model == E5_ID:
             engine, is_qwen = self.e5, False
         elif canonical_model == QWEN_ID:

app/openai_api.py

@@ -15,13 +15,15 @@ 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", "intfloat/multilingual-e5-small", "Qwen/Qwen3-Embedding-0.6B"
+    "e5", "qwen", "bge-m3", "intfloat/multilingual-e5-small",
+    "Qwen/Qwen3-Embedding-0.6B", "BAAI/bge-m3"
 ]
 
 
@@ -61,8 +63,14 @@ def create_embedding(
     registry: ModelRegistry = Depends(resident_models),
 ):
     model = request.model
-    canonical = QWEN_ID if model in ("qwen", QWEN_ID) else E5_ID
-    engine = registry.qwen if canonical == QWEN_ID else registry.e5
+    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, "BGE-M3 model is disabled", "server_error")
     if request.dimensions is not None and request.dimensions != engine.dimensions:
         log.warning(
             "OpenAI embeddings rejected: reason=unsupported_dimensions model=%s "
@@ -131,6 +139,7 @@ def list_models():
         "object": "list",
         "data": [
             {"id": mid, "object": "model", "created": 0, "owned_by": "local"}
-            for mid in ("e5", "qwen", E5_ID, QWEN_ID)
+            for mid in ("e5", "qwen", E5_ID, QWEN_ID,
+                        "bge-m3", BGE_M3_ID)
         ],
     }