Skip to content

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

fix(sdk-messages): correct message API behavior (#21744)

Sbaaoui Idriss5e9f6415344b
diff --git a/internal/engine/elasticsearch/chunk.go b/internal/engine/elasticsearch/chunk.go
index f27dfef5ae..65b9b4efa6 100644
--- a/internal/engine/elasticsearch/chunk.go
+++ b/internal/engine/elasticsearch/chunk.go
@@ -2324,6 +2324,13 @@ func buildBoolQueryFromConditionRaw(filter map[string]interface{}, kbIDs []strin
if v == nil || v == "" {
continue
}
+ if isMemoryIndex && k == "session_id_contains" {
+ if text, ok := v.(string); ok {
+ pattern := strings.NewReplacer(`\`, `\\`, "*", `\*`, "?", `\?`).Replace(text)
+ filterClauses = append(filterClauses, map[string]interface{}{"wildcard": map[string]interface{}{"session_id": "*" + pattern + "*"}})
+ }
+ continue
+ }
if isMemoryIndex && k == "session_id" {
if strVal, ok := v.(string); ok && strVal != "" {
filterClauses = append(filterClauses, map[string]interface{}{
diff --git a/internal/engine/elasticsearch/message_contract_test.go b/internal/engine/elasticsearch/message_contract_test.go
new file mode 100644
index 0000000000..a45c0c9ca5
--- /dev/null
+++ b/internal/engine/elasticsearch/message_contract_test.go
@@ -0,0 +1,30 @@
+//
+// 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 elasticsearch
+
+import (
+ "reflect"
+ "testing"
+)
+
+func TestMessageSubstringEscapesWildcardCharacters(t *testing.T) {
+ got := buildBoolQueryFromConditionRaw(map[string]interface{}{"session_id_contains": `a*b?c\d`}, nil, false, true)
+ want := map[string]interface{}{"filter": []interface{}{map[string]interface{}{"wildcard": map[string]interface{}{"session_id": `*a\*b\?c\\d*`}}}}
+ if !reflect.DeepEqual(got, map[string]interface{}{"bool": want}) {
+ t.Fatalf("query = %#v, want %#v", got, want)
+ }
+}
diff --git a/internal/engine/infinity/chunk.go b/internal/engine/infinity/chunk.go
index 5bf11a6ca9..619fc1fe39 100644
--- a/internal/engine/infinity/chunk.go
+++ b/internal/engine/infinity/chunk.go
@@ -19,6 +19,7 @@ package infinity
import (
"context"
"encoding/json"
+ "errors"
"fmt"
"hash/fnv"
"maps"
@@ -1085,6 +1086,7 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.S
}
orderBy := req.OrderBy
+ mergeMemoryOrder := isMemoryIndex && !hasTextMatch && !hasVectorMatch && orderBy != nil && len(orderBy.Fields) > 0
var rankFeature map[string]float64
if req.RankFeature != nil {
rankFeature = req.RankFeature
@@ -1198,8 +1200,11 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.S
}
}
tableOutputColumns := outputColumns
+ if mergeMemoryOrder {
+ tableOutputColumns = unionSortColumns(tableOutputColumns, orderBy)
+ }
if wildcardSelect {
- tableOutputColumns = expandSelectWildcards(outputColumns, tableColumns)
+ tableOutputColumns = expandSelectWildcards(tableOutputColumns, tableColumns)
}
tableFilterParts := append([]string(nil), filterParts...)
if len(filterCopy) > 0 {
@@ -1387,9 +1392,13 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.S
}
// Set limit and offset
- table = table.Limit(pageSize)
- if offset > 0 {
- table = table.Offset(offset)
+ if mergeMemoryOrder {
+ table = table.Limit(pageSize + offset)
+ } else {
+ table = table.Limit(pageSize)
+ if offset > 0 {
+ table = table.Offset(offset)
+ }
}
// Request total_hits_count from Infinity
@@ -1493,6 +1502,10 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.S
allResults = sortByScore(allResults, len(allResults))
}
+ if mergeMemoryOrder {
+ sortChunksByFields(allResults, orderBy)
+ allResults = allResults[min(offset, len(allResults)):]
+ }
if len(allResults) > pageSize {
allResults = allResults[:pageSize]
}
@@ -1848,6 +1861,12 @@ func (e *Engine) GetChunk(ctx context.Context, tableName, chunkID string, datase
for _, tblName := range tableNames {
table, err := db.GetTable(tblName)
if err != nil {
+ if isMemoryIndexName(tableName) {
+ var infinityErr *infinity.InfinityException
+ if !errors.As(err, &infinityErr) || infinity.ErrorCode(infinityErr.ErrorCode) != infinity.ErrorCodeTableNotExist {
+ return nil, fmt.Errorf("failed to open message table: %w", err)
+ }
+ }
continue
}
@@ -1855,11 +1874,17 @@ func (e *Engine) GetChunk(ctx context.Context, tableName, chunkID string, datase
filter := fmt.Sprintf("id = '%s'", chunkID)
result, err := table.Output([]string{"*"}).Filter(filter).ToResult()
if err != nil {
+ if isMemoryIndexName(tableName) {
+ return nil, fmt.Errorf("failed to read message: %w", err)
+ }
continue
}
qr, ok := result.(*infinity.QueryResult)
if !ok {
+ if isMemoryIndexName(tableName) {
+ return nil, fmt.Errorf("unexpected message query result %T", result)
+ }
continue
}
@@ -2176,6 +2201,12 @@ func mapMemoryMessageStorageFields(row map[string]interface{}) {
// to the logical fields the memory service reads.
func normalizeMemoryMessageRows(rows []map[string]interface{}) {
for _, row := range rows {
+ for field, value := range row {
+ if vectorColumnPattern.MatchString(field) {
+ row["content_embed"] = value
+ delete(row, field)
+ }
+ }
if val, ok := row["message_type_kwd"]; ok {
row["message_type"] = val
delete(row, "message_type_kwd")
@@ -3134,6 +3165,13 @@ func equivalentConditionToStrRaw(condition map[string]interface{}, tableColumns
continue
}
+ if memIndex && k == "session_id_contains" {
+ if text, ok := v.(string); ok {
+ pattern := strings.NewReplacer("'", `\x27`, `"`, `\x22`).Replace(regexp.QuoteMeta(text))
+ cond = append(cond, infinity.RegexFilter("session_id", pattern))
+ }
+ continue
+ }
// Handle must_not specially
if k == "must_not" {
if m, ok := v.(map[string]interface{}); ok {
diff --git a/internal/engine/infinity/message_contract_integration_test.go b/internal/engine/infinity/message_contract_integration_test.go
new file mode 100644
index 0000000000..08ea52069e
--- /dev/null
+++ b/internal/engine/infinity/message_contract_integration_test.go
@@ -0,0 +1,110 @@
+//go:build integration
+
+//
+// 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 infinity
+
+import (
+ "fmt"
+ "os"
+ "strings"
+ "testing"
+ "time"
+
+ "ragflow/internal/common"
+ "ragflow/internal/engine/types"
+ "ragflow/internal/server/config"
+
+ sdk "github.com/infiniflow/infinity-go-sdk"
+)
+
+func TestMessageSubstringLiteralAndReadErrors(t *testing.T) {
+ if err := common.InitLogger("error", common.FileOutput{}, "sdk_message_contract"); err != nil {
+ t.Fatal(err)
+ }
+ uri := os.Getenv("RAGFLOW_INFINITY_URI")
+ if uri == "" {
+ uri = "localhost:23817"
+ }
+ e, err := NewEngine(t.Context(), config.InfinityConfig{URI: uri, DBName: "sdk_source_contract"})
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _ = e.Close() })
+ db, release, err := e.client.checkoutDatabase(t.Context(), "message_contract_test")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer release()
+ base := fmt.Sprintf("memory_contract_%d", time.Now().UnixNano())
+ name := base + "_test"
+ table, err := db.CreateTable(name, sdk.TableSchema{&sdk.ColumnDefinition{Name: "id", DataType: "varchar"}, &sdk.ColumnDefinition{Name: "session_id", DataType: "varchar"}, &sdk.ColumnDefinition{Name: "valid_at", DataType: "varchar"}}, sdk.ConflictTypeError)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _, _ = db.DropTable(name, sdk.ConflictTypeIgnore) })
+ for i, part := range []string{"middle", "a'b", `a"b`, `both'"quotes`, `slash\path`, "a_%b", "x OR 1=1"} {
+ id := fmt.Sprint(i)
+ if _, err := table.Insert([]map[string]interface{}{{"id": id, "session_id": "prefix" + part + "suffix", "valid_at": "2026-01-01"}}); err != nil {
+ t.Fatal(err)
+ }
+ filter := equivalentConditionToStrRaw(map[string]interface{}{"session_id_contains": part}, nil, true)
+ result, err := table.Output([]string{"id"}).Filter(filter).ToResult()
+ if err != nil {
+ t.Fatalf("%q: %v", part, err)
+ }
+ ids := result.(*sdk.QueryResult).Data["id"]
+ if len(ids) != 1 || ids[0] != id {
+ t.Fatalf("part=%q rows=%v filter=%s", part, ids, filter)
+ }
+ }
+
+ laterName := base + "_later"
+ later, err := db.CreateTable(laterName, sdk.TableSchema{&sdk.ColumnDefinition{Name: "id", DataType: "varchar"}, &sdk.ColumnDefinition{Name: "valid_at", DataType: "varchar"}}, sdk.ConflictTypeError)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() { _, _ = db.DropTable(laterName, sdk.ConflictTypeIgnore) })
+ if _, err := later.Insert([]map[string]interface{}{{"id": "newest", "valid_at": "2026-02-01"}}); err != nil {
+ t.Fatal(err)
+ }
+ for offset, expected := range []string{"newest", "2026-01-01"} {
+ result, err := e.Search(t.Context(), &types.SearchRequest{IndexNames: []string{base}, KbIDs: []string{"test", "later"}, SelectFields: []string{"id", "q_*_vec"}, Limit: 1, Offset: offset, OrderBy: (&types.OrderByExpr{}).Desc("valid_at")})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(result.Chunks) != 1 {
+ t.Fatalf("offset=%d result=%+v", offset, result)
+ }
+ field := "id"
+ if offset > 0 {
+ field = "valid_at"
+ }
+ if result.Chunks[0][field] != expected {
+ t.Fatalf("offset=%d rows=%v", offset, result.Chunks)
+ }
+ }
+ if _, err := table.DropColumns([]string{"id"}); err != nil {
+ t.Fatal(err)
+ }
+ if _, err := e.GetChunk(t.Context(), base, "missing", []string{"test"}); err == nil || !strings.Contains(err.Error(), "failed to read message") {
+ t.Fatalf("query error masked: %v", err)
+ }
+ if value, err := e.GetChunk(t.Context(), base, "missing", []string{"absent"}); err != nil || value != nil {
+ t.Fatalf("absent table=%v,%v", value, err)
+ }
+}
diff --git a/internal/engine/infinity/message_contract_test.go b/internal/engine/infinity/message_contract_test.go
new file mode 100644
index 0000000000..15680fcd6e
--- /dev/null
+++ b/internal/engine/infinity/message_contract_test.go
@@ -0,0 +1,43 @@
+//
+// 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 infinity
+
+import (
+ "strings"
+ "testing"
+)
+
+func TestMessageSubstringFilterKeepsExactFilters(t *testing.T) {
+ got := equivalentConditionToStrRaw(map[string]interface{}{"session_id_contains": "part_%'x", "agent_id": "exact"}, nil, true)
+ if !strings.Contains(got, "regex(session_id") || !strings.Contains(got, `part_%\x27x`) || !strings.Contains(got, "agent_id='exact'") {
+ t.Fatal(got)
+ }
+ exact := buildFilterFromConditionRaw(map[string]interface{}{"session_id": "part"}, nil)
+ if strings.Contains(exact, "LIKE") {
+ t.Fatal(exact)
+ }
+}
+func TestMemoryEmbeddingPublicField(t *testing.T) {
+ row := map[string]interface{}{"q_3_vec": []float32{1, 2, 3}, "message_type_kwd": "raw"}
+ normalizeMemoryMessageRows([]map[string]interface{}{row})
+ if _, ok := row["q_3_vec"]; ok {
+ t.Fatal(row)
+ }
+ if row["content_embed"] == nil || row["message_type"] != "raw" {
+ t.Fatal(row)
+ }
+}
diff --git a/internal/engine/oceanbase/filter.go b/internal/engine/oceanbase/filter.go
index 0c5f3225f3..e006510f8f 100644
--- a/internal/engine/oceanbase/filter.go
+++ b/internal/engine/oceanbase/filter.go
@@ -40,6 +40,11 @@ func buildFilter(condition map[string]interface{}, kind string) (string, []inter
if isEmptyFilterValue(value) {
continue
}
+ if kind == "memory" && key == "session_id_contains" {
+ parts = append(parts, "INSTR(`session_id`, ?) > 0")
+ args = append(args, value)
+ continue
+ }
switch key {
case "exists":
column, ok := value.(string)
diff --git a/internal/engine/oceanbase/message_contract_test.go b/internal/engine/oceanbase/message_contract_test.go
new file mode 100644
index 0000000000..11326cbbe9
--- /dev/null
+++ b/internal/engine/oceanbase/message_contract_test.go
@@ -0,0 +1,53 @@
+//
+// 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 oceanbase
+
+import (
+ "reflect"
+ "strings"
+ "testing"
+)
+
+func TestMessageSubstringFilterKeepsExactFilters(t *testing.T) {
+ got, args, err := buildFilter(map[string]interface{}{"session_id_contains": "part_%'x"}, "memory")
+ if err != nil || got != "INSTR(`session_id`, ?) > 0" || !reflect.DeepEqual(args, []interface{}{"part_%'x"}) {
+ t.Fatalf("%s %v %v", got, args, err)
+ }
+ exact, _, err := buildFilter(map[string]interface{}{"session_id": "part"}, "memory")
+ if err != nil || !strings.Contains(exact, " = ?") {
+ t.Fatal(exact, err)
+ }
+}
+
+func TestMemoryMessageIDsDecodeAsIntegers(t *testing.T) {
+ for _, tc := range []struct {
+ stored string
+ want int64
+ }{{"42", 42}, {"9223372036854775807", 9223372036854775807}} {
+ row := decodeLogicalRow(map[string]interface{}{"message_id": tc.stored}, "memory")
+ if row["message_id"] != tc.want {
+ t.Fatalf("message_id = %#v, want %d", row["message_id"], tc.want)
+ }
+ }
+}
+
+func TestMemoryContentIncludesUnsetForgetTime(t *testing.T) {
+ row := decodeLogicalRow(map[string]interface{}{"message_id": "42", "content_ltks": "content"}, "memory")
+ if value, ok := row["forget_at"]; !ok || value != nil {
+ t.Fatalf("unset forget_at = %#v, present=%v", value, ok)
+ }
+}
diff --git a/internal/engine/oceanbase/rows.go b/internal/engine/oceanbase/rows.go
index 1908e8b909..aa6f61757e 100644
--- a/internal/engine/oceanbase/rows.go
+++ b/internal/engine/oceanbase/rows.go
@@ -21,6 +21,7 @@ import (
"database/sql"
"encoding/json"
"fmt"
+ "strconv"
"strings"
)
@@ -62,6 +63,9 @@ func (e *Engine) queryRows(ctx context.Context, query string, args ...interface{
func decodeLogicalRow(row map[string]interface{}, kind string) map[string]interface{} {
result := make(map[string]interface{}, len(row))
+ if kind == "memory" {
+ result["forget_at"] = nil
+ }
for rawColumn, value := range row {
column := rawColumn
if kind == "memory" {
@@ -74,6 +78,13 @@ func decodeLogicalRow(row map[string]interface{}, kind string) map[string]interf
if kind == "chunk" && column == "_order_id" {
column = "chunk_order_int"
}
+ if kind == "memory" && column == "message_id" {
+ if text, ok := value.(string); ok {
+ if id, err := strconv.ParseInt(text, 10, 64); err == nil {
+ value = id
+ }
+ }
+ }
if kind == "memory" && column == "status" {
switch status := value.(type) {
case int64:
diff --git a/internal/engine/oceanbase/schema.go b/internal/engine/oceanbase/schema.go
index 59e4536368..df9dbeba8f 100644
--- a/internal/engine/oceanbase/schema.go
+++ b/internal/engine/oceanbase/schema.go
@@ -231,8 +231,12 @@ func (e *Engine) ensureTableWithLock(ctx context.Context, tableName string, colu
for _, column := range columns {
definitions = append(definitions, quoteIdentifier(column.name)+" "+column.typeSQL)
}
- query := fmt.Sprintf("CREATE TABLE %s (%s) DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci ORGANIZATION=heap",
- quoteIdentifier(tableName), strings.Join(definitions, ", "))
+ collation := "utf8mb4_unicode_ci"
+ if e.engineType == "seekdb" {
+ collation = "utf8mb4_general_ci"
+ }
+ query := fmt.Sprintf("CREATE TABLE %s (%s) DEFAULT CHARSET=utf8mb4 COLLATE=%s ORGANIZATION=heap",
+ quoteIdentifier(tableName), strings.Join(definitions, ", "), collation)
_, err := e.db.ExecContext(ctx, query)
return err
})
diff --git a/internal/engine/oceanbase/schema_test.go b/internal/engine/oceanbase/schema_test.go
index 611247a770..673591461e 100644
--- a/internal/engine/oceanbase/schema_test.go
+++ b/internal/engine/oceanbase/schema_test.go
@@ -159,3 +159,26 @@ func TestFindVectorColumnUsesExpectedColumn(t *testing.T) {
t.Fatal(err)
}
}
+
+func TestTableCollationMatchesEngine(t *testing.T) {
+ for _, tc := range []struct{ engine, collation string }{{"oceanbase", "utf8mb4_unicode_ci"}, {"seekdb", "utf8mb4_general_ci"}} {
+ t.Run(tc.engine, func(t *testing.T) {
+ db, mock, err := sqlmock.New()
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer db.Close()
+ engine := newEngineWithDB(tc.engine, "test", db)
+ query := regexp.QuoteMeta("SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?")
+ mock.ExpectQuery(query).WithArgs("test", "memory_test").WillReturnRows(sqlmock.NewRows([]string{"COUNT(*)"}).AddRow(0))
+ mock.ExpectExec(regexp.QuoteMeta("CREATE TABLE `memory_test` (`id` VARCHAR(32)) DEFAULT CHARSET=utf8mb4 COLLATE=" + tc.collation + " ORGANIZATION=heap")).WillReturnResult(sqlmock.NewResult(0, 0))
+ mock.ExpectQuery(query).WithArgs("test", "memory_test").WillReturnRows(sqlmock.NewRows([]string{"COUNT(*)"}).AddRow(1))
+ if err := engine.ensureTable(t.Context(), "memory_test", []columnDefinition{{name: "id", typeSQL: "VARCHAR(32)"}}, "test_"); err != nil {
+ t.Fatal(err)
+ }
+ if err := mock.ExpectationsWereMet(); err != nil {
+ t.Fatal(err)
+ }
+ })
+ }
+}
diff --git a/internal/handler/memory.go b/internal/handler/memory.go
index 5faf2a7d8a..2075c25f74 100644
--- a/internal/handler/memory.go
+++ b/internal/handler/memory.go
@@ -22,6 +22,7 @@ package handler
import (
"encoding/json"
"errors"
+ "math"
"net/http"
"strconv"
"strings"
@@ -830,8 +831,16 @@ func (h *MemoryHandler) SearchMessage(c *gin.Context) {
query := c.Query("query")
- similarityThreshold, _ := strconv.ParseFloat(c.DefaultQuery("similarity_threshold", "0.2"), 64)
- keywordsSimilarityWeight, _ := strconv.ParseFloat(c.DefaultQuery("keywords_similarity_weight", "0.7"), 64)
+ similarityThreshold, err := strconv.ParseFloat(c.DefaultQuery("similarity_threshold", "0.2"), 64)
+ if err != nil || math.IsNaN(similarityThreshold) || math.IsInf(similarityThreshold, 0) || similarityThreshold < 0 || similarityThreshold > 1 {
+ common.ErrorWithCode(c, common.CodeArgumentError, "similarity_threshold must be a finite number between 0 and 1")
+ return
+ }
+ keywordsSimilarityWeight, err := strconv.ParseFloat(c.DefaultQuery("keywords_similarity_weight", "0.7"), 64)
+ if err != nil || math.IsNaN(keywordsSimilarityWeight) || math.IsInf(keywordsSimilarityWeight, 0) || keywordsSimilarityWeight < 0 || keywordsSimilarityWeight > 1 {
+ common.ErrorWithCode(c, common.CodeArgumentError, "keywords_similarity_weight must be a finite number between 0 and 1")
+ return
+ }
topN, _ := strconv.Atoi(c.DefaultQuery("top_n", "5"))
if topN <= 0 || topN > 100 {
common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "top_n must be between 1 and 100")
diff --git a/internal/handler/memory_message_test.go b/internal/handler/memory_message_test.go
index 9f4f4b6388..9e295009e1 100644
--- a/internal/handler/memory_message_test.go
+++ b/internal/handler/memory_message_test.go
@@ -91,3 +91,24 @@ func TestForgetMessageRejectsMalformedPath(t *testing.T) {
t.Fatalf("code = %v, want %v; body=%s", code, common.CodeArgumentError, w.Body.String())
}
}
+
+func TestSearchMessageRejectsInvalidSimilarity(t *testing.T) {
+ for _, field := range []string{"similarity_threshold", "keywords_similarity_weight"} {
+ for _, value := range []string{"-0.1", "1.1", "invalid", "nan", "inf"} {
+ t.Run(field+value, func(t *testing.T) {
+ w := httptest.NewRecorder()
+ c, _ := gin.CreateTestContext(w)
+ c.Set("user", &entity.User{ID: "user-1"})
+ c.Request = httptest.NewRequest("GET", "/messages/search?"+field+"="+value, nil)
+ (&MemoryHandler{}).SearchMessage(c)
+ var payload struct{ Code int }
+ if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
+ t.Fatal(err)
+ }
+ if payload.Code != 101 {
+ t.Fatalf("response=%s", w.Body.String())
+ }
+ })
+ }
+ }
+}
diff --git a/internal/service/memory.go b/internal/service/memory.go
index e7f8c5e33a..30a6e0ade5 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -21,6 +21,7 @@ import (
"context"
"errors"
"fmt"
+ "math"
"ragflow/internal/common"
"ragflow/internal/entity"
"ragflow/internal/entity/models"
@@ -1151,6 +1152,16 @@ func (s *MemoryService) UpdateMessageStatus(ctx context.Context, userID, memoryI
}
messageDocID := fmt.Sprintf("%s_%d", memoryID, messageID)
+ message, err := s.docEngine.GetChunk(ctx, MemoryIndexName(memory.TenantID), messageDocID, []string{memoryID})
+ if err != nil {
+ if isMessageDocumentNotFound(err) {
+ return false, &ResourceNotFoundError{Resource: "Message", ID: messageDocID}
+ }
+ return false, fmt.Errorf("failed to load message before status update: %w", err)
+ }
+ if message == nil {
+ return false, &ResourceNotFoundError{Resource: "Message", ID: messageDocID}
+ }
statusValue := 0
if status {
statusValue = 1
@@ -1206,6 +1217,14 @@ func (s *MemoryService) GetMessageContent(ctx context.Context, userID, memoryID
}
func (s *MemoryService) SearchMessage(ctx context.Context, userID string, filterDict, params map[string]interface{}) ([]map[string]interface{}, common.ErrorCode, error) {
+ for _, field := range []string{"similarity_threshold", "keywords_similarity_weight"} {
+ if value, exists := params[field]; exists {
+ number := memoryFloatParam(value, math.NaN())
+ if math.IsNaN(number) || math.IsInf(number, 0) || number < 0 || number > 1 {
+ return nil, common.CodeArgumentError, fmt.Errorf("%s must be a finite number between 0 and 1", field)
+ }
+ }
+ }
memoryIDs := splitFilterValues(filterDict["memory_id"])
memories, err := s.filterAccessibleMemories(ctx, userID, memoryIDs)
if err != nil {
@@ -1869,7 +1888,7 @@ func (s *MemoryService) listMemoryMessages(ctx context.Context, memory *entity.M
filter["agent_id"] = agentIDs
}
if keywords = strings.TrimSpace(keywords); keywords != "" {
- filter["session_id"] = keywords
+ filter["session_id_contains"] = keywords
}
filter["memory_id"] = []string{memoryID}
indexNames := memorySearchIndexNames([]*entity.Memory{memory}, s.docEngine)
@@ -1881,7 +1900,7 @@ func (s *MemoryService) listMemoryMessages(ctx context.Context, memory *entity.M
SelectFields: selectFields,
Filter: filter,
MatchExprs: []interface{}{},
- OrderBy: (&enginetypes.OrderByExpr{}).Desc("valid_at"),
+ OrderBy: (&enginetypes.OrderByExpr{}).Desc("valid_at").Desc("message_id"),
}
rawResult, err := s.docEngine.Search(ctx, rawReq)
if err != nil {
diff --git a/internal/service/memory_message_test.go b/internal/service/memory_message_test.go
index 979c06a3f2..277e03d124 100644
--- a/internal/service/memory_message_test.go
+++ b/internal/service/memory_message_test.go
@@ -137,6 +137,9 @@ type memoryMessageDocEngine struct {
updateID string
}
+func (e *memoryMessageDocEngine) GetChunk(context.Context, string, string, []string) (interface{}, error) {
+ return map[string]interface{}{"id": "present"}, nil
+}
func (e *memoryMessageDocEngine) Search(ctx context.Context, req *enginetypes.SearchRequest) (*enginetypes.SearchResult, error) {
e.searchReq = req
if e.searchResp != nil {
@@ -1042,3 +1045,43 @@ func TestUpdateMessageUpdatesStatusByMessageDocID(t *testing.T) {
t.Fatalf("status update = %+v, want status 1", docEngine.updateValue)
}
}
+
+type missingMessageEngine struct {
+ memoryMessageDocEngine
+ getErr error
+}
+
+func (e *missingMessageEngine) GetChunk(context.Context, string, string, []string) (interface{}, error) {
+ return nil, e.getErr
+}
+func TestUpdateMessageRejectsMissingAndFailedReads(t *testing.T) {
+ for _, readErr := range []error{nil, enginetypes.ErrDocumentNotFound, errors.New("database unavailable")} {
+ setupMemoryMessageTestDB(t)
+ seedMemoryMessages(t)
+ e := &missingMessageEngine{getErr: readErr}
+ svc := &MemoryService{memoryDAO: dao.NewMemoryDAO(), db: dao.DB, docEngine: e}
+ ok, err := svc.UpdateMessage(serviceTestContext(t, "user-1", "user-1"), "user-1", "mem-owned", 42, true)
+ if ok || err == nil || e.updateCond != nil {
+ t.Fatalf("ok=%v error=%v update=%v", ok, err, e.updateCond)
+ }
+ var missing *ResourceNotFoundError
+ if readErr != nil && !errors.Is(readErr, enginetypes.ErrDocumentNotFound) {
+ if !errors.Is(err, readErr) {
+ t.Fatal(err)
+ }
+ } else if !errors.As(err, &missing) {
+ t.Fatalf("expected missing, got%v", err)
+ }
+ }
+}
+
+func TestMemorySearchRejectsInvalidSimilarityBeforeStorage(t *testing.T) {
+ for _, field := range []string{"similarity_threshold", "keywords_similarity_weight"} {
+ for _, value := range []interface{}{-0.1, 1.1, "invalid", math.NaN(), math.Inf(1), nil} {
+ _, code, err := (&MemoryService{}).SearchMessage(t.Context(), "user", nil, map[string]interface{}{field: value})
+ if code != common.CodeArgumentError || err == nil {
+ t.Fatalf("%s=%v code=%v err=%v", field, value, code, err)
+ }
+ }
+ }
+}
diff --git a/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py b/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py
index 8a9b00af6b..b075f95739 100644
--- a/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py
+++ b/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py
@@ -43,8 +43,6 @@ class TestGetMessageContent:
assert content["status"] is True, content
def test_get_message_content_embedding(self, populated_memory, doc_engine):
- if doc_engine == "infinity":
- pytest.skip("Go Infinity GetChunk returns q_<dimension>_vec without mapping it to documented content_embed (internal/engine/infinity/chunk.go:1907-1911,2177).")
memory = populated_memory["memory"]
content = memory.get_message_content(populated_memory["rows"][0]["message_id"])
vector = content["content_embed"]
diff --git a/test/testcases/test_sdk_api/test_message_management/test_list_message.py b/test/testcases/test_sdk_api/test_message_management/test_list_message.py
index 99f11b2d48..27de3f4fc6 100644
--- a/test/testcases/test_sdk_api/test_message_management/test_list_message.py
+++ b/test/testcases/test_sdk_api/test_message_management/test_list_message.py
@@ -92,8 +92,6 @@ class TestMessageList:
_assert_messages(result, populated_memory, expected)
def test_search_keyword_substring(self, populated_memory, doc_engine):
- if doc_engine in {"infinity", "oceanbase", "seekdb"}:
- pytest.skip("Go Infinity/OceanBase session_id filters use equality, contrary to Python SDK docs' fuzzy session-ID contract (infinity/chunk.go, oceanbase/filter.go)")
expected = populated_memory["rows"][2:3]
keyword = expected[0]["session_id"][4:]
assert keyword != expected[0]["session_id"]
diff --git a/test/testcases/test_sdk_api/test_message_management/test_search_message.py b/test/testcases/test_sdk_api/test_message_management/test_search_message.py
index da6bed53b4..e4fe0d47d1 100644
--- a/test/testcases/test_sdk_api/test_message_management/test_search_message.py
+++ b/test/testcases/test_sdk_api/test_message_management/test_search_message.py
@@ -137,9 +137,6 @@ class TestSearchMessage:
)
assert_matches(messages, populated_memory, range(5))
- @pytest.mark.skip(
- reason="Go MemoryHandler.SearchMessage parses float parameters without checking errors or documented [0,1] ranges (internal/handler/memory.go); invalid values reach search instead of returning argument errors"
- )
@pytest.mark.parametrize("field", ["similarity_threshold", "keywords_similarity_weight"])
@pytest.mark.parametrize("value", [-0.1, 1.1, "invalid", "nan", "inf"])
def test_invalid_similarity_parameters(self, client, populated_memory, field, value):
diff --git a/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py b/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py
index f0ff5b8b2d..66fb58c652 100644
--- a/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py
+++ b/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py
@@ -82,10 +82,6 @@ class TestUpdateMessageStatus:
populated_memory["memory"].update_message_status(message_id, False)
def test_nonexistent_message(self, populated_memory, doc_engine):
- if doc_engine == "infinity":
- pytest.skip("Infinity UpdateChunks discards the update result and succeeds for a missing message (internal/engine/infinity/chunk.go:743-758); status update must report missing Message.")
- if doc_engine in ("oceanbase", "seekdb"):
- pytest.skip("OceanBase UpdateChunks ignores SQL affected rows and succeeds for a missing message (internal/engine/oceanbase/crud.go:292-294); status update must report missing Message.")
with pytest.raises(Exception, match="Message .*not found"):
populated_memory["memory"].update_message_status(9223372036854775807, False)