RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
fix: route embeddings through model wrapper (#20378)
buua436b912faf964b8
diff --git a/internal/entity/models/embed_limit.go b/internal/entity/models/embed_limit.goindex 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.goindex 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 = 8192model := 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.goindex 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) ([]modelsreturn 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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.goindex 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, qembCfg := &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.goindex 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 strembeddingModel := 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.goindex 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 *CrembeddingModel := 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.goindex 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 strinreturn 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.goindex 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, prerr = 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.goindex 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 []strinif 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.goindex 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.goindex 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 operationstype 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 []streturn 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.goindex 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.goindex 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.// ---------------------------------------------------------------------------