Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix: route embeddings through model wrapper (#20378)

buua436b912faf964b8
diff --git a/internal/entity/models/embed_limit.go b/internal/entity/models/embed_limit.go
index 7ad7f560d6..9e9178002d 100644
--- a/internal/entity/models/embed_limit.go
+++ b/internal/entity/models/embed_limit.go
@@ -24,7 +24,7 @@ import (
"ragflow/internal/tokenizer"
)
-// EmbedWithinLimit embeds req after cutting every text to what this model accepts,
+// Embed embeds req after cutting every text to what this model accepts,
// and retries with a smaller budget if the provider still rejects an input as over
// its window. It is the embedding counterpart of RerankModel.Rerank, which cuts its
// documents the same way for the same reason.
@@ -48,7 +48,7 @@ import (
// that declares a tokenizer whose asset is not on disk is refused before the first
// attempt, because counting it with the calibrated cl100k estimate is exactly what
// lets an oversized request through.
-func (m *EmbeddingModel) EmbedWithinLimit(ctx context.Context, req EmbedRequest, embeddingConfig *EmbeddingConfig, usage *common.ModelUsage) ([]EmbeddingData, error) {
+func (m *EmbeddingModel) Embed(ctx context.Context, req EmbedRequest, embeddingConfig *EmbeddingConfig, usage *common.ModelUsage) ([]EmbeddingData, error) {
if m == nil || m.ModelDriver == nil {
return nil, fmt.Errorf("embedding model: driver is nil")
}
diff --git a/internal/entity/models/embed_limit_test.go b/internal/entity/models/embed_limit_test.go
index 953c575631..218b879825 100644
--- a/internal/entity/models/embed_limit_test.go
+++ b/internal/entity/models/embed_limit_test.go
@@ -86,21 +86,21 @@ func newEmbedModel(t *testing.T, driver ModelDriver, tokenizerID string, maxToke
}
// embedBudget is the budget a single cut would use, computed the same way
-// EmbedWithinLimit computes its first rung.
+// Embed computes its first rung.
func embedBudget(t *testing.T, model *EmbeddingModel) (int, tokenizer.Counter) {
t.Helper()
limiter := tokenizer.LimiterFor(model.ResolveTokenizerID(), model.QuotaKey(), tokenizer.DefaultCalibration())
return limiter.Limit(model.ResolveMaxTokens()), limiter.Counter()
}
-// TestEmbedWithinLimitCutsToTheWindow pins what the dataset-nav, knowledge-compiler,
+// TestEmbedCutsToTheWindow pins what the dataset-nav, knowledge-compiler,
// chunk and memory callers rely on: what reaches the driver fits the window, order is
// preserved, a short text is untouched, and a first-attempt success is not retried.
//
// The empty tokenizer id is the calibrated path (a model whose tokenizer the catalog
// does not name); xlmr-spm is covered when its asset is present because it is the
// counter behind the reported failure (a nav summary against bge-m3, 400/20015).
-func TestEmbedWithinLimitCutsToTheWindow(t *testing.T) {
+func TestEmbedCutsToTheWindow(t *testing.T) {
long := strings.Repeat("中文 hello ", 5000)
for _, id := range []string{"", tokenizer.CounterXLMRSentence} {
if id != "" && !tokenizer.CounterExact(id) {
@@ -109,9 +109,9 @@ func TestEmbedWithinLimitCutsToTheWindow(t *testing.T) {
}
driver := &recordingEmbedDriver{}
model := newEmbedModel(t, driver, id, 8192)
- embeds, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{Texts: []string{long, "short"}}, nil, nil)
+ embeds, err := model.Embed(t.Context(), EmbedRequest{Texts: []string{long, "short"}}, nil, nil)
if err != nil {
- t.Fatalf("tokenizer %q: EmbedWithinLimit: %v", id, err)
+ t.Fatalf("tokenizer %q: Embed: %v", id, err)
}
if len(embeds) != 2 {
t.Fatalf("tokenizer %q: got %d embeddings, want 2", id, len(embeds))
@@ -133,14 +133,14 @@ func TestEmbedWithinLimitCutsToTheWindow(t *testing.T) {
}
}
-// TestEmbedWithinLimitRetriesWithASmallerBudget is the property that turns "this
+// TestEmbedRetriesWithASmallerBudget is the property that turns "this
// batch fails forever" into "this batch succeeds": the retried text must be strictly
// shorter, and the caller must not see the rejection.
-func TestEmbedWithinLimitRetriesWithASmallerBudget(t *testing.T) {
+func TestEmbedRetriesWithASmallerBudget(t *testing.T) {
driver := &recordingEmbedDriver{rejectFor: 1}
model := newEmbedModel(t, driver, "", 8192)
- if _, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{Texts: []string{strings.Repeat("中", 20000)}}, nil, nil); err != nil {
- t.Fatalf("EmbedWithinLimit: %v", err)
+ if _, err := model.Embed(t.Context(), EmbedRequest{Texts: []string{strings.Repeat("中", 20000)}}, nil, nil); err != nil {
+ t.Fatalf("Embed: %v", err)
}
if len(driver.attempts) != 2 {
t.Fatalf("attempts = %d, want 2", len(driver.attempts))
@@ -150,13 +150,13 @@ func TestEmbedWithinLimitRetriesWithASmallerBudget(t *testing.T) {
}
}
-// TestEmbedWithinLimitDoesNotRetryUnrelatedErrors keeps the retry narrow: a 5xx is
+// TestEmbedDoesNotRetryUnrelatedErrors keeps the retry narrow: a 5xx is
// not something a shorter input fixes, so it comes back on the first attempt.
-func TestEmbedWithinLimitDoesNotRetryUnrelatedErrors(t *testing.T) {
+func TestEmbedDoesNotRetryUnrelatedErrors(t *testing.T) {
boom := errors.New("SILICONFLOW API error: 503 Service Unavailable")
driver := &recordingEmbedDriver{failWith: boom}
model := newEmbedModel(t, driver, "", 8192)
- _, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{Texts: []string{"hello"}}, nil, nil)
+ _, err := model.Embed(t.Context(), EmbedRequest{Texts: []string{"hello"}}, nil, nil)
if !errors.Is(err, boom) {
t.Fatalf("error = %v, want the provider's own error", err)
}
@@ -165,13 +165,13 @@ func TestEmbedWithinLimitDoesNotRetryUnrelatedErrors(t *testing.T) {
}
}
-// TestEmbedWithinLimitRefusesAnUnavailableDeclaredTokenizer is the half of the
+// TestEmbedRefusesAnUnavailableDeclaredTokenizer is the half of the
// contract that keeps the retry from hiding a provisioning gap: a model that declares
// a tokenizer we cannot load fails before the first attempt.
-func TestEmbedWithinLimitRefusesAnUnavailableDeclaredTokenizer(t *testing.T) {
+func TestEmbedRefusesAnUnavailableDeclaredTokenizer(t *testing.T) {
driver := &recordingEmbedDriver{}
model := newEmbedModel(t, driver, "no-such-family", 8192)
- _, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{Texts: []string{"hello"}}, nil, nil)
+ _, err := model.Embed(t.Context(), EmbedRequest{Texts: []string{"hello"}}, nil, nil)
if err == nil {
t.Fatal("expected an error for a declared tokenizer whose asset is unavailable")
}
@@ -185,10 +185,10 @@ func TestEmbedWithinLimitRefusesAnUnavailableDeclaredTokenizer(t *testing.T) {
}
}
-// TestEmbedWithinLimitIsolatesAPathologicalInput is the property that keeps one bad
+// TestEmbedIsolatesAPathologicalInput is the property that keeps one bad
// input from failing the whole batch: when no batch budget fits, every input is
// embedded on its own, in order, and the healthy ones keep their content.
-func TestEmbedWithinLimitIsolatesAPathologicalInput(t *testing.T) {
+func TestEmbedIsolatesAPathologicalInput(t *testing.T) {
driver := &recordingEmbedDriver{rejectBatch: true}
model := newEmbedModel(t, driver, "", 8192)
// Read the ladder length before the call: the call's own rejections ratchet the
@@ -196,9 +196,9 @@ func TestEmbedWithinLimitIsolatesAPathologicalInput(t *testing.T) {
budget, _ := embedBudget(t, model)
batchRungs := len(tokenizer.OverLimitLadder(budget))
texts := []string{strings.Repeat("a", 40), "second"}
- embeds, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{Texts: texts}, nil, nil)
+ embeds, err := model.Embed(t.Context(), EmbedRequest{Texts: texts}, nil, nil)
if err != nil {
- t.Fatalf("EmbedWithinLimit: %v", err)
+ t.Fatalf("Embed: %v", err)
}
if len(embeds) != 2 {
t.Fatalf("got %d embeddings, want 2", len(embeds))
@@ -218,14 +218,14 @@ func TestEmbedWithinLimitIsolatesAPathologicalInput(t *testing.T) {
}
}
-// TestEmbedWithinLimitFailsWhenNoBudgetFits keeps the floor honest: the ladder ends
+// TestEmbedFailsWhenNoBudgetFits keeps the floor honest: the ladder ends
// above OverLimitFloorTokens and only isolation reaches it, so the error may only be
// raised after the floor was actually tried - and never with a partial result.
-func TestEmbedWithinLimitFailsWhenNoBudgetFits(t *testing.T) {
+func TestEmbedFailsWhenNoBudgetFits(t *testing.T) {
driver := &recordingEmbedDriver{rejectLongerThan: 8}
model := newEmbedModel(t, driver, "", 8192)
budget, _ := embedBudget(t, model)
- embeds, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{Texts: []string{strings.Repeat("中", 500)}}, nil, nil)
+ embeds, err := model.Embed(t.Context(), EmbedRequest{Texts: []string{strings.Repeat("中", 500)}}, nil, nil)
if err == nil {
t.Fatal("expected an error when not even the floor fits")
}
@@ -241,17 +241,17 @@ func TestEmbedWithinLimitFailsWhenNoBudgetFits(t *testing.T) {
}
}
-// TestEmbedWithinLimitRecordsTheDeclaredLimitInTheCalibration pins the third argument
+// TestEmbedRecordsTheDeclaredLimitInTheCalibration pins the third argument
// of ObserveOverLimit: it is the provider's declared window, not the local budget
// derived from it. Passing the (smaller) budget would understate the inferred ratio
// and leave the calibration effectively unchanged, so the next call would repeat the
// same rejection.
-func TestEmbedWithinLimitRecordsTheDeclaredLimitInTheCalibration(t *testing.T) {
+func TestEmbedRecordsTheDeclaredLimitInTheCalibration(t *testing.T) {
driver := &recordingEmbedDriver{rejectFor: 1}
const declared = 8192
model := newEmbedModel(t, driver, "", declared)
- if _, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{Texts: []string{strings.Repeat("a", 40000)}}, nil, nil); err != nil {
- t.Fatalf("EmbedWithinLimit: %v", err)
+ if _, err := model.Embed(t.Context(), EmbedRequest{Texts: []string{strings.Repeat("a", 40000)}}, nil, nil); err != nil {
+ t.Fatalf("Embed: %v", err)
}
if len(driver.attempts) == 0 {
t.Fatal("no attempt recorded")
@@ -264,15 +264,30 @@ func TestEmbedWithinLimitRecordsTheDeclaredLimitInTheCalibration(t *testing.T) {
}
}
-// TestEmbedWithinLimitEmptyTexts: nothing to embed is a no-op, not a call.
-func TestEmbedWithinLimitEmptyTexts(t *testing.T) {
+// TestEmbedEmptyTexts: nothing to embed is a no-op, not a call.
+func TestEmbedEmptyTexts(t *testing.T) {
driver := &recordingEmbedDriver{}
model := newEmbedModel(t, driver, "", 8192)
- embeds, err := model.EmbedWithinLimit(t.Context(), EmbedRequest{}, nil, nil)
+ embeds, err := model.Embed(t.Context(), EmbedRequest{}, nil, nil)
if err != nil {
- t.Fatalf("EmbedWithinLimit: %v", err)
+ t.Fatalf("Embed: %v", err)
}
if len(embeds) != 0 || len(driver.attempts) != 0 {
t.Fatalf("embeds = %d, attempts = %d, want 0 and 0", len(embeds), len(driver.attempts))
}
}
+
+func TestEmbedUsesTokenizerPreprocessing(t *testing.T) {
+ driver := &recordingEmbedDriver{}
+ model := newEmbedModel(t, driver, "", 8192)
+ long := strings.Repeat("中文 hello ", 5000)
+ if _, err := model.Embed(t.Context(), EmbedRequest{Texts: []string{long}}, nil, nil); err != nil {
+ t.Fatalf("Embed: %v", err)
+ }
+ if len(driver.attempts) != 1 {
+ t.Fatalf("attempts = %d, want 1", len(driver.attempts))
+ }
+ if driver.attempts[0][0] == long {
+ t.Fatal("Embed passed the untrimmed text to the driver")
+ }
+}
diff --git a/internal/ingestion/task/embedder.go b/internal/ingestion/task/embedder.go
index 0effbb5276..1fc65c9070 100644
--- a/internal/ingestion/task/embedder.go
+++ b/internal/ingestion/task/embedder.go
@@ -268,7 +268,7 @@ func (e *embedder) embedWithRetry(ctx context.Context, texts []string) ([]models
return nil, 0, cerr
}
usage := &common.ModelUsage{}
- embeds, err = e.model.ModelDriver.Embed(ctx, e.model.ModelName, req, e.model.APIConfig, config, usage)
+ embeds, err = e.model.Embed(ctx, req, config, usage)
if err == nil {
return embeds, usage.InputTokens, nil
}
diff --git a/internal/ingestion/task/knowledge_compiler_wiring.go b/internal/ingestion/task/knowledge_compiler_wiring.go
index eceb7f28b5..e9b5c1adac 100644
--- a/internal/ingestion/task/knowledge_compiler_wiring.go
+++ b/internal/ingestion/task/knowledge_compiler_wiring.go
@@ -758,7 +758,7 @@ func (e *kcEmbedder) Encode(ctx context.Context, texts []string) ([][]float32, e
// Embed inside the model's window: compile products include the summaries
// and entity descriptions that feed the nav index, and an over-window input
// is a hard 400/20015 that fails the whole batch instead of being trimmed.
- embeds, jobErr := mdl.EmbedWithinLimit(ctx, models.EmbedRequest{Texts: batchTexts}, config, nil)
+ embeds, jobErr := mdl.Embed(ctx, models.EmbedRequest{Texts: batchTexts}, config, nil)
if jobErr != nil {
return fmt.Errorf("knowledge_compiler: embed: %w", jobErr)
}
diff --git a/internal/service/chat_pipeline.go b/internal/service/chat_pipeline.go
index 2f9402046d..aa3e7230d9 100644
--- a/internal/service/chat_pipeline.go
+++ b/internal/service/chat_pipeline.go
@@ -3088,7 +3088,7 @@ func (e *embeddingModelEmbedder) Encode(ctx context.Context, texts []string) ([]
config := &modelModule.EmbeddingConfig{Dimension: 0}
// Embed inside the model's window: the caller supplies arbitrary text and the
// provider rejects an over-window input with 400/20015 instead of truncating it.
- embeds, err := e.embModel.EmbedWithinLimit(ctx, modelModule.EmbedRequest{Texts: texts}, config, nil)
+ embeds, err := e.embModel.Embed(ctx, modelModule.EmbedRequest{Texts: texts}, config, nil)
if err != nil {
return nil, err
}
diff --git a/internal/service/chunk/chunk.go b/internal/service/chunk/chunk.go
index 42d585b003..2b832f31e6 100644
--- a/internal/service/chunk/chunk.go
+++ b/internal/service/chunk/chunk.go
@@ -1466,7 +1466,7 @@ func (s *ChunkService) AddChunk(ctx context.Context, req *service.AddChunkReques
}
// Embed inside the model's window: Content arrives from the API and can be
// arbitrarily long, and the provider answers 400/20015 instead of truncating it.
- embeddings, err := embeddingModel.EmbedWithinLimit(ctx, models.EmbedRequest{Texts: []string{docName, embeddingText}}, &models.EmbeddingConfig{Dimension: 0}, nil)
+ embeddings, err := embeddingModel.Embed(ctx, models.EmbedRequest{Texts: []string{docName, embeddingText}}, &models.EmbeddingConfig{Dimension: 0}, nil)
if err != nil {
return nil, addChunkError{code: common.CodeServerError, message: fmt.Sprintf("encode chunk embedding: %v", err)}
}
diff --git a/internal/service/dataset/utils.go b/internal/service/dataset/utils.go
index 7cc4004a52..acc7c3b35b 100644
--- a/internal/service/dataset/utils.go
+++ b/internal/service/dataset/utils.go
@@ -259,7 +259,7 @@ func datasetEncodeEmbedding(ctx context.Context, embeddingModel *modelModule.Emb
// Embed inside the model's window: this path takes whatever text the API handed
// it, and the provider rejects an over-window input with 400/20015 instead of
// truncating it.
- embeddings, err := embeddingModel.EmbedWithinLimit(ctx, modelModule.EmbedRequest{Texts: cleaned}, embeddingConfig, nil)
+ embeddings, err := embeddingModel.Embed(ctx, modelModule.EmbedRequest{Texts: cleaned}, embeddingConfig, nil)
if err != nil {
return nil, err
}
diff --git a/internal/service/graph/retrieval.go b/internal/service/graph/retrieval.go
index 34a02e0953..5abffb56ad 100644
--- a/internal/service/graph/retrieval.go
+++ b/internal/service/graph/retrieval.go
@@ -201,7 +201,7 @@ func buildSearchExprs(ctx context.Context, embModel *modelModule.EmbeddingModel,
embeddingConfig := &modelModule.EmbeddingConfig{Dimension: 0}
// Query: true — matchText is the search query (Python get_vector →
// encode_queries), not a document.
- embeddings, err := embModel.ModelDriver.Embed(ctx, embModel.ModelName, modelModule.EmbedRequest{Texts: []string{matchText.MatchingText}, Query: true}, embModel.APIConfig, embeddingConfig, nil)
+ embeddings, err := embModel.Embed(ctx, modelModule.EmbedRequest{Texts: []string{matchText.MatchingText}, Query: true}, embeddingConfig, nil)
if err != nil || len(embeddings) == 0 {
return []interface{}{matchText}
}
diff --git a/internal/service/graph/search.go b/internal/service/graph/search.go
index 1d5bc0e639..34c5ebc7b4 100644
--- a/internal/service/graph/search.go
+++ b/internal/service/graph/search.go
@@ -101,7 +101,7 @@ func buildDenseExpr(ctx context.Context, embModel *modelModule.EmbeddingModel, q
embCfg := &modelModule.EmbeddingConfig{Dimension: 0}
// Query: true — the KG search embeds the user's question (Python
// get_vector → encode_queries), not a document.
- embeddings, err := embModel.ModelDriver.Embed(ctx, embModel.ModelName, modelModule.EmbedRequest{Texts: []string{question}, Query: true}, embModel.APIConfig, embCfg, nil)
+ embeddings, err := embModel.Embed(ctx, modelModule.EmbedRequest{Texts: []string{question}, Query: true}, embCfg, nil)
if err != nil {
return nil, fmt.Errorf("KG entity embed failed: %w", err)
}
diff --git a/internal/service/memory.go b/internal/service/memory.go
index 521727be35..b6a0fb6570 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -1501,7 +1501,7 @@ func (s *MemoryService) memoryMessageDenseExpr(ctx context.Context, question str
embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Query: true — the memory store is searched by question (Python
// memory/services/query.py uses emb_mdl.encode_queries).
- embeddings, err := embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: []string{question}, Query: true}, embeddingModel.APIConfig, &models.EmbeddingConfig{Dimension: 0}, nil)
+ embeddings, err := embeddingModel.Embed(ctx, models.EmbedRequest{Texts: []string{question}, Query: true}, &models.EmbeddingConfig{Dimension: 0}, nil)
if err != nil {
return nil, err
}
diff --git a/internal/service/memory_message_service.go b/internal/service/memory_message_service.go
index 51c8637895..2d034fc36e 100644
--- a/internal/service/memory_message_service.go
+++ b/internal/service/memory_message_service.go
@@ -331,7 +331,7 @@ func (s *MemoryMessageService) embedAndSaveMessages(ctx context.Context, mem *Cr
embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Embed inside the model's window: memory contents are caller-supplied and
// unbounded, and the provider answers 400/20015 instead of truncating them.
- embeddings, err := embeddingModel.EmbedWithinLimit(ctx, models.EmbedRequest{Texts: contents}, &models.EmbeddingConfig{Dimension: 0}, nil)
+ embeddings, err := embeddingModel.Embed(ctx, models.EmbedRequest{Texts: contents}, &models.EmbeddingConfig{Dimension: 0}, nil)
if err != nil {
return fmt.Errorf("embed model: %w", err)
}
diff --git a/internal/service/model_call.go b/internal/service/model_call.go
index b8d8822499..17c3f39cfe 100644
--- a/internal/service/model_call.go
+++ b/internal/service/model_call.go
@@ -128,8 +128,8 @@ func (s *ModelCallService) EmbedText(ctx context.Context, modelRef, userID strin
return nil, common.CodeBadRequest, err
}
- modelName := target.ModelName
- embeddings, err := target.Driver.Embed(ctx, &modelName, modelModule.EmbedRequest{Texts: texts}, target.APIConfig, config, nil)
+ embeddingModel := modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
+ embeddings, err := embeddingModel.Embed(ctx, modelModule.EmbedRequest{Texts: texts}, config, nil)
if err != nil {
return nil, common.CodeServerError, err
}
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index 6a56f482e9..750daee019 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -962,7 +962,12 @@ func verifyProviderModel(ctx context.Context, driver modelModule.ModelDriver, pr
err = validateEmbeddingModel(model, requestedDimension, 1)
}
if err == nil {
- _, err = driver.Embed(ctx, &modelName, modelModule.EmbedRequest{Texts: []string{"test"}}, apiConfig, nil, nil)
+ maxTokens := 0
+ if model.MaxTokens != nil {
+ maxTokens = *model.MaxTokens
+ }
+ embeddingModel := modelModule.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
+ _, err = embeddingModel.Embed(ctx, modelModule.EmbedRequest{Texts: []string{"test"}}, nil, nil)
}
case "rerank":
rerankRequest := modelModule.RerankRequest{
diff --git a/internal/service/nav_embedder.go b/internal/service/nav_embedder.go
index ee4594ff99..c57066415e 100644
--- a/internal/service/nav_embedder.go
+++ b/internal/service/nav_embedder.go
@@ -83,23 +83,8 @@ func (e *NavEmbedder) encode(ctx context.Context, tenantID string, texts []strin
if len(nonEmpty) == 0 {
return nil, nil
}
- // Documents go through EmbedWithinLimit: the provider does not truncate, it
- // answers 400/20015, and a nav summary is not a short string - without a tree
- // product it is every entity line of the page-index graph joined into one. The
- // model makes the cut (and retries with a smaller budget when a calibrated count
- // undershoots), which is what Python gets from BaseEmbedding.encode.
- //
- // Queries stay on the driver. A query is short, so there is nothing to cut, and
- // EmbedWithinLimit refuses to run when the model declares a tokenizer whose asset
- // is missing - a refusal that belongs to the ingest path, not to a search, which
- // has to keep answering on a deployment that never provisioned the asset.
- var embeds []modelModule.EmbeddingData
- var err error
- if query {
- embeds, err = model.ModelDriver.Embed(ctx, model.ModelName, modelModule.EmbedRequest{Texts: nonEmpty, Query: true}, model.APIConfig, nil, nil)
- } else {
- embeds, err = model.EmbedWithinLimit(ctx, modelModule.EmbedRequest{Texts: nonEmpty}, nil, nil)
- }
+ request := modelModule.EmbedRequest{Texts: nonEmpty, Query: query}
+ embeds, err := model.Embed(ctx, request, nil, nil)
if err != nil {
return nil, err
}
diff --git a/internal/service/nlp/retrieval.go b/internal/service/nlp/retrieval.go
index a4b7c76217..290500c136 100644
--- a/internal/service/nlp/retrieval.go
+++ b/internal/service/nlp/retrieval.go
@@ -979,7 +979,7 @@ func (s *RetrievalService) GetVector(ctx context.Context, txt string, embModel *
// query encoding (Cohere search_query / Voyage query / Jina retrieval.query
// / NVIDIA query). Embedding it as a document would put the query vector in
// the wrong space for those providers.
- embeddings, err := embModel.ModelDriver.Embed(ctx, embModel.ModelName, models.EmbedRequest{Texts: []string{txt}, Query: true}, embModel.APIConfig, embeddingConfig, nil)
+ embeddings, err := embModel.Embed(ctx, models.EmbedRequest{Texts: []string{txt}, Query: true}, embeddingConfig, nil)
if err != nil {
return nil, err
}
diff --git a/internal/service/skill_indexer.go b/internal/service/skill_indexer.go
index b48a1a1b51..a85a32c36e 100644
--- a/internal/service/skill_indexer.go
+++ b/internal/service/skill_indexer.go
@@ -50,9 +50,6 @@ type FileSystemClient interface {
GetSkillContent(ctx context.Context, tenantID, skillName string) (*SkillVersionInfo, error)
}
-// defaultMaxLength is a safe default for embedding model max input length
-const defaultMaxLength = 8191
-
// SkillIndexerService handles skill indexing operations
type SkillIndexerService struct {
configDAO *dao.SkillSearchConfigDAO
@@ -929,15 +926,8 @@ func (s *SkillIndexerService) generateEmbedding(ctx context.Context, text, embdI
}
embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
- // Truncate text to prevent exceeding model's max input length
- maxLen := embeddingModel.MaxTokens
- if maxLen <= 0 {
- maxLen = defaultMaxLength
- }
- truncatedText := truncate(text, maxLen-10)
-
var response []models.EmbeddingData
- response, err = embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: []string{truncatedText}}, embeddingModel.APIConfig, nil, nil)
+ response, err = embeddingModel.Embed(ctx, models.EmbedRequest{Texts: []string{text}}, nil, nil)
if err != nil {
return nil, fmt.Errorf("failed to encode text: %w", err)
}
@@ -969,20 +959,10 @@ func (s *SkillIndexerService) generateEmbeddings(ctx context.Context, texts []st
}
embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
- // Truncate texts to prevent exceeding model's max input length
- maxLen := embeddingModel.MaxTokens
- if maxLen <= 0 {
- maxLen = defaultMaxLength
- }
- truncatedTexts := make([]string, len(texts))
- for i, text := range texts {
- truncatedTexts[i] = truncate(text, maxLen-10)
- }
-
- common.Info(fmt.Sprintf("Encoding %d texts", len(truncatedTexts)))
+ common.Info(fmt.Sprintf("Encoding %d texts", len(texts)))
// Use batch encode API (consistent with Python's encode(texts: list))
var response []models.EmbeddingData
- response, err = embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: truncatedTexts}, embeddingModel.APIConfig, nil, nil)
+ response, err = embeddingModel.Embed(ctx, models.EmbedRequest{Texts: texts}, nil, nil)
if err != nil {
common.Error(fmt.Sprintf("Failed to encode texts: %v", err), err)
return nil, fmt.Errorf("failed to encode texts: %w", err)
@@ -996,19 +976,6 @@ func (s *SkillIndexerService) generateEmbeddings(ctx context.Context, texts []st
return response, nil
}
-// truncate truncates text to maxLen characters
-// Similar to Python's truncate function in rag/llm/embedding_model.py
-func truncate(text string, maxLen int) string {
- if maxLen <= 0 {
- return text
- }
- runes := []rune(text)
- if len(runes) <= maxLen {
- return text
- }
- return string(runes[:maxLen])
-}
-
// getEmbeddingDimension gets the embedding dimension by calling the embedding API with test text
// This follows Python's approach: use actual embedding result to determine dimension
// If embedding API fails, returns error (cannot create table without knowing dimension)
@@ -1030,7 +997,7 @@ func (s *SkillIndexerService) getEmbeddingDimension(ctx context.Context, tenantI
// Use simple test text like Python does: embedding_model.encode(["ok"])
testText := "ok"
var response []models.EmbeddingData
- response, err = embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: []string{testText}}, embeddingModel.APIConfig, nil, nil)
+ response, err = embeddingModel.Embed(ctx, models.EmbedRequest{Texts: []string{testText}}, nil, nil)
if err != nil {
return 0, fmt.Errorf("failed to encode test text: %w", err)
}
diff --git a/internal/service/skill_search.go b/internal/service/skill_search.go
index 593c748efa..067c86d95d 100644
--- a/internal/service/skill_search.go
+++ b/internal/service/skill_search.go
@@ -673,17 +673,9 @@ func (s *SkillSearchService) getEmbedding(ctx context.Context, text, embdID, ten
}
embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
- // Truncate text to prevent exceeding model's max input length
- maxLen := embeddingModel.MaxTokens
- if maxLen <= 0 {
- maxLen = defaultMaxLength
- }
- truncatedText := truncate(text, maxLen-10)
-
- var response []models.EmbeddingData
// Query: true — getEmbedding is used only by the skill search legs
// (vectorSearch / hybridSearch) to embed the user's query.
- response, err = embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: []string{truncatedText}, Query: true}, embeddingModel.APIConfig, nil, nil)
+ response, err := embeddingModel.Embed(ctx, models.EmbedRequest{Texts: []string{text}, Query: true}, nil, nil)
if err != nil {
return nil, fmt.Errorf("failed to encode query: %w", err)
}
diff --git a/internal/tokenizer/embedlimit.go b/internal/tokenizer/embedlimit.go
index 795abebfdf..4398b623f1 100644
--- a/internal/tokenizer/embedlimit.go
+++ b/internal/tokenizer/embedlimit.go
@@ -534,7 +534,7 @@ func utf8Start(b byte) bool { return b&0xC0 != 0x80 }
// ---------------------------------------------------------------------------
// Over-limit handling: the marker set, the shrink ladder, and the refusal every
// embedder shares. The embedding side of this - the loop that trims, calls the
-// driver, and walks the ladder - is EmbeddingModel.EmbedWithinLimit in
+// driver, and walks the ladder - is EmbeddingModel.Embed in
// internal/entity/models, next to the RerankModel cut it mirrors.
// ---------------------------------------------------------------------------