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
test(nlp): cover OB/VB local rerank scoring (#21541)
ZZZZY88321d6aad99
diff --git a/internal/service/nlp/retrieval.go b/internal/service/nlp/retrieval.goindex 57aa4d04b5..29e3555519 100644--- a/internal/service/nlp/retrieval.go+++ b/internal/service/nlp/retrieval.go@@ -465,7 +465,7 @@ func (s *RetrievalService) scoreSearchResult(ctx context.Context, req *RetrievalvtWeight := *req.VectorSimilarityWeighttkWeight := 1.0 - vtWeightqb := GetQueryBuilder()- useInfinity := engine.GetEngineType() == "infinity"+ useInfinity := s.docEngine.GetType() == string(engine.EngineInfinity)useOceanBase := engine.IsOceanBaseFamily(s.docEngine.GetType())// Vastbase fusion returns a single fused score per chunk, so the// tsim/vsim decomposition below needs the local rerank — same as OB.@@ -806,7 +806,7 @@ func (s *RetrievalService) Search(ctx context.Context, req *RetrievalSearchReque// Build source with vector column for ESsearchSrc := make([]string, len(searchRequest.SelectFields))copy(searchSrc, searchRequest.SelectFields)- if engine.GetEngineType() == "elasticsearch" || engine.IsOceanBaseFamily(engine.GetEngineType()) || engine.IsVastbase(engine.GetEngineType()) {+ if s.docEngine.GetType() == string(engine.EngineElasticsearch) || engine.IsOceanBaseFamily(s.docEngine.GetType()) || engine.IsVastbase(s.docEngine.GetType()) {searchSrc = append(searchSrc, matchDense.VectorColumnName)}diff --git a/internal/service/nlp/retrieval_score_test.go b/internal/service/nlp/retrieval_score_test.gonew file mode 100644index 0000000000..b86d6e6b9f--- /dev/null+++ b/internal/service/nlp/retrieval_score_test.go@@ -0,0 +1,155 @@+//+// Copyright 2025 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package nlp++import (+ "context"+ "math"+ "testing"++ "ragflow/internal/common"+ "ragflow/internal/engine"+)++// localRerankDocEngine records whether scoreSearchResult takes the engine's+// KNN path. The embedded interface satisfies the rest of engine.DocEngine and+// is never called by the local-rerank branches.+type localRerankDocEngine struct {+ engine.DocEngine+ engineType string+ knnCalls int+ scoreCalls int+}++func (e *localRerankDocEngine) GetType() string { return e.engineType }++func (e *localRerankDocEngine) KNNScores(context.Context, []map[string]interface{}, []float64, int) (map[string]interface{}, error) {+ e.knnCalls+++ return map[string]interface{}{}, nil+}++func (e *localRerankDocEngine) GetScores(map[string]interface{}) map[string]float64 {+ e.scoreCalls+++ return nil+}++func TestRerankStandardIncludesQuestionTks(t *testing.T) {+ qb := NewQueryBuilder()+ withQuestions := map[string]interface{}{+ "content_ltks": "alpha",+ "question_tks": "epsilon",+ }+ withoutQuestions := map[string]interface{}{+ "content_ltks": "alpha",+ }++ _, withTsim, _ := RerankStandard(+ []map[string]interface{}{withQuestions}, nil, nil, "epsilon",+ 0.3, 0.7, "content_ltks", qb, nil, "",+ )+ _, withoutTsim, _ := RerankStandard(+ []map[string]interface{}{withoutQuestions}, nil, nil, "epsilon",+ 0.3, 0.7, "content_ltks", qb, nil, "",+ )++ if len(withTsim) != 1 || len(withoutTsim) != 1 {+ t.Fatalf("tsim lengths = %d/%d, want 1/1", len(withTsim), len(withoutTsim))+ }+ if withTsim[0] <= withoutTsim[0] {+ t.Fatalf("question_tks did not increase tsim: with=%v without=%v", withTsim[0], withoutTsim[0])+ }+}++func TestScoreSearchResultLocalRerankOceanBaseAndVastbase(t *testing.T) {+ oldQueryBuilder := globalQueryBuilder+ globalQueryBuilder = NewQueryBuilder()+ defer func() { globalQueryBuilder = oldQueryBuilder }()++ const (+ tkWeight = 0.3+ vtWeight = 0.7+ )+ weight := vtWeight+ rankFeature := map[string]float64{common.PAGERANK_FLD: 10}++ result := &RetrievalSearchResult{+ Chunks: []map[string]interface{}{+ {+ "id": "a",+ "content_ltks": "alpha",+ "_score": 0.99,+ common.PAGERANK_FLD: 0.5,+ "q_2_vec": []float64{1, 0},+ },+ {+ "id": "b",+ "content_ltks": "beta",+ "_score": 0.99,+ "q_2_vec": []float64{0, 1},+ },+ },+ Total: 2,+ QueryVector: []float64{1, 0},+ IDs: []string{"a", "b"},+ // Field carries deliberately different values: the OceanBase and+ // Vastbase branches must rerank from Chunks, not from Field.+ Field: map[string]map[string]interface{}{+ "a": {"_score": 0.99, common.PAGERANK_FLD: 100.0},+ "b": {"_score": 0.99, common.PAGERANK_FLD: 100.0},+ },+ }++ for _, tc := range []struct {+ name string+ engineType string+ }{+ {name: "oceanbase", engineType: string(engine.EngineOceanBase)},+ {name: "vastbase", engineType: string(engine.EngineVastbase)},+ } {+ t.Run(tc.name, func(t *testing.T) {+ docEngine := &localRerankDocEngine{engineType: tc.engineType}+ service := NewRetrievalService(docEngine, nil)++ sim, tsim, vsim, err := service.scoreSearchResult(t.Context(), &RetrievalRequest{+ Question: "alpha",+ VectorSimilarityWeight: &weight,+ RankFeature: &rankFeature,+ }, result)+ if err != nil {+ t.Fatalf("scoreSearchResult failed: %v", err)+ }+ if docEngine.knnCalls != 0 || docEngine.scoreCalls != 0 {+ t.Fatalf("KNN path called: KNNScores=%d GetScores=%d", docEngine.knnCalls, docEngine.scoreCalls)+ }+ if len(sim) != 2 || len(tsim) != 2 || len(vsim) != 2 {+ t.Fatalf("score lengths = %d/%d/%d, want 2/2/2", len(sim), len(tsim), len(vsim))+ }++ if math.Abs(vsim[0]-1) > 1e-9 || math.Abs(vsim[1]) > 1e-9 {+ t.Fatalf("vsim = %v, want [1 0] from Chunks vectors", vsim)+ }++ pageranks := []float64{0.5, 0}+ for i := range sim {+ want := tkWeight*tsim[i] + vtWeight*vsim[i] + pageranks[i]+ if math.Abs(sim[i]-want) > 1e-9 {+ t.Fatalf("sim[%d] = %v, want %v (tsim=%v vsim=%v)", i, sim[i], want, tsim, vsim)+ }+ }+ })+ }+}