Skip to content

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

fix(agent): apply cross_languages in Go Retrieval memory mode (#20328)

Denis Ermakov9a05499d0aaa
diff --git a/cmd/ragflow_server.go b/cmd/ragflow_server.go
index db462fe958..dcce2a8b94 100644
--- a/cmd/ragflow_server.go
+++ b/cmd/ragflow_server.go
@@ -1162,7 +1162,7 @@ func startServer(ctx context.Context, serverName string, arguments *serverArgs)
retrievalEnhancer,
)
agenttool.SetRetrievalService(retrievalAdapter)
- agenttool.SetMemoryRetrievalService(retrievalbridge.NewMemoryAdapter(memoryService))
+ agenttool.SetMemoryRetrievalService(retrievalbridge.NewMemoryAdapter(memoryService, retrievalEnhancer))
common.Info("agent: retrieval service adapter installed")
// The smart-reasoning agent's corpus tools (internal/agentic_rag): regex
diff --git a/internal/agent/retrievalbridge/memory.go b/internal/agent/retrievalbridge/memory.go
index ac3787f405..1f78b4e62a 100644
--- a/internal/agent/retrievalbridge/memory.go
+++ b/internal/agent/retrievalbridge/memory.go
@@ -23,21 +23,47 @@ import (
"ragflow/internal/agent/runtime"
agenttool "ragflow/internal/agent/tool"
+ "ragflow/internal/common"
"ragflow/internal/permission"
"ragflow/internal/service"
+ "go.uber.org/zap"
"gorm.io/gorm"
)
+// memoryMessageSearcher is the MemoryService surface the adapter searches.
+type memoryMessageSearcher interface {
+ SearchMessage(
+ ctx context.Context,
+ userID string,
+ filterDict, params map[string]any,
+ ) ([]map[string]any, common.ErrorCode, error)
+}
+
+// queryTranslator translates the query into the tool's cross_languages.
+type queryTranslator interface {
+ CrossLanguages(
+ ctx context.Context,
+ tenantID, query string,
+ languages []string,
+ ) (string, error)
+}
+
// MemoryAdapter exposes MemoryService.SearchMessage through the agent tool's
// retrieval interface.
type MemoryAdapter struct {
- svc *service.MemoryService
+ svc memoryMessageSearcher
+ translator queryTranslator
}
-// NewMemoryAdapter creates a memory retrieval adapter.
-func NewMemoryAdapter(svc *service.MemoryService) *MemoryAdapter {
- return &MemoryAdapter{svc: svc}
+// NewMemoryAdapter creates a memory retrieval adapter. The translator applies
+// the tool's cross_languages to the query, as the dataset path does.
+func NewMemoryAdapter(svc *service.MemoryService, translator queryTranslator) *MemoryAdapter {
+ adapter := &MemoryAdapter{translator: translator}
+ if svc != nil {
+ adapter.svc = svc
+ }
+ return adapter
}
// Search performs hybrid memory-message retrieval and translates messages to
@@ -66,6 +92,18 @@ func (a *MemoryAdapter) Search(
if err := agenttool.CheckCanvasDependencies(ctx, db, permission.ResourceKindMemory, memoryIDs); err != nil {
return nil, err
}
+ query := req.Query
+ if len(req.CrossLanguages) > 0 {
+ if a.translator == nil {
+ return nil, fmt.Errorf("memory retrieval: cross-language service is not configured")
+ }
+ translated, err := a.translator.CrossLanguages(ctx, req.TenantID, query, req.CrossLanguages)
+ if err != nil {
+ common.Warn("agent memory retrieval: cross-language query failed; using original query", zap.Error(err))
+ } else if strings.TrimSpace(translated) != "" {
+ query = translated
+ }
+ }
keywordWeight := 0.7
if req.KeywordsSimilarityWeight != nil {
keywordWeight = *req.KeywordsSimilarityWeight
@@ -79,7 +117,7 @@ func (a *MemoryAdapter) Search(
actorID,
filter,
map[string]any{
- "query": req.Query,
+ "query": query,
"similarity_threshold": req.SimilarityThreshold,
"keywords_similarity_weight": keywordWeight,
"top_n": req.TopN,
diff --git a/internal/agent/retrievalbridge/memory_test.go b/internal/agent/retrievalbridge/memory_test.go
new file mode 100644
index 0000000000..045eec4292
--- /dev/null
+++ b/internal/agent/retrievalbridge/memory_test.go
@@ -0,0 +1,152 @@
+//
+// Copyright 2026 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 retrievalbridge
+
+import (
+ "context"
+ "errors"
+ "reflect"
+ "testing"
+
+ agenttool "ragflow/internal/agent/tool"
+ "ragflow/internal/common"
+)
+
+type captureMessageSearcher struct {
+ userID string
+ params map[string]any
+}
+
+func (s *captureMessageSearcher) SearchMessage(
+ _ context.Context,
+ userID string,
+ _ map[string]any,
+ params map[string]any,
+) ([]map[string]any, common.ErrorCode, error) {
+ s.userID = userID
+ s.params = params
+ return nil, common.CodeSuccess, nil
+}
+
+type fakeQueryTranslator struct {
+ calls int
+ tenantID string
+ query string
+ languages []string
+ result string
+ err error
+}
+
+func (f *fakeQueryTranslator) CrossLanguages(
+ _ context.Context,
+ tenantID, query string,
+ languages []string,
+) (string, error) {
+ f.calls++
+ f.tenantID = tenantID
+ f.query = query
+ f.languages = languages
+ return f.result, f.err
+}
+
+func memoryRequest(languages ...string) agenttool.RetrievalRequest {
+ return agenttool.RetrievalRequest{
+ Query: "¿qué pasó ayer?",
+ MemoryIDs: []string{"mem-1"},
+ TenantID: "tenant-1",
+ CrossLanguages: languages,
+ }
+}
+
+func TestMemoryAdapterTranslatesQueryWithCrossLanguages(t *testing.T) {
+ searcher := &captureMessageSearcher{}
+ translator := &fakeQueryTranslator{result: "what happened yesterday?"}
+ adapter := &MemoryAdapter{svc: searcher, translator: translator}
+
+ if _, err := adapter.Search(t.Context(), nil, memoryRequest("English")); err != nil {
+ t.Fatal(err)
+ }
+ if translator.calls != 1 {
+ t.Fatalf("CrossLanguages calls = %d, want 1", translator.calls)
+ }
+ if translator.tenantID != "tenant-1" || translator.query != "¿qué pasó ayer?" ||
+ !reflect.DeepEqual(translator.languages, []string{"English"}) {
+ t.Fatalf("CrossLanguages args = (%q, %q, %#v)", translator.tenantID, translator.query, translator.languages)
+ }
+ if got := searcher.params["query"]; got != "what happened yesterday?" {
+ t.Fatalf("searched query = %#v, want the translated query", got)
+ }
+}
+
+func TestMemoryAdapterSkipsTranslationWithoutCrossLanguages(t *testing.T) {
+ searcher := &captureMessageSearcher{}
+ translator := &fakeQueryTranslator{result: "unused"}
+ adapter := &MemoryAdapter{svc: searcher, translator: translator}
+
+ if _, err := adapter.Search(t.Context(), nil, memoryRequest()); err != nil {
+ t.Fatal(err)
+ }
+ if translator.calls != 0 {
+ t.Fatalf("CrossLanguages calls = %d, want 0", translator.calls)
+ }
+ if got := searcher.params["query"]; got != "¿qué pasó ayer?" {
+ t.Fatalf("searched query = %#v, want the original query", got)
+ }
+}
+
+func TestMemoryAdapterKeepsOriginalQueryWhenTranslationFails(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ translator *fakeQueryTranslator
+ }{
+ {name: "error", translator: &fakeQueryTranslator{err: errors.New("no default chat model")}},
+ {name: "blank result", translator: &fakeQueryTranslator{result: " "}},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ searcher := &captureMessageSearcher{}
+ adapter := &MemoryAdapter{svc: searcher, translator: tc.translator}
+
+ if _, err := adapter.Search(t.Context(), nil, memoryRequest("English")); err != nil {
+ t.Fatal(err)
+ }
+ if got := searcher.params["query"]; got != "¿qué pasó ayer?" {
+ t.Fatalf("searched query = %#v, want the original query", got)
+ }
+ })
+ }
+}
+
+func TestNewMemoryAdapterWithoutServiceReportsMissingService(t *testing.T) {
+ adapter := NewMemoryAdapter(nil, &fakeQueryTranslator{})
+
+ _, err := adapter.Search(t.Context(), nil, memoryRequest("English"))
+ if !errors.Is(err, agenttool.ErrMemoryRetrievalServiceMissing) {
+ t.Fatalf("err = %v, want ErrMemoryRetrievalServiceMissing", err)
+ }
+}
+
+func TestMemoryAdapterRejectsCrossLanguagesWithoutTranslator(t *testing.T) {
+ searcher := &captureMessageSearcher{}
+ adapter := &MemoryAdapter{svc: searcher}
+
+ if _, err := adapter.Search(t.Context(), nil, memoryRequest("English")); err == nil {
+ t.Fatal("expected an error when cross_languages is set and no translator is configured")
+ }
+ if searcher.params != nil {
+ t.Fatal("memory search must not run with an untranslated query")
+ }
+}