Skip to content

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

Fix: mirror python when call llm to extract memory failed (#19863)

Lynnec09515de8e1
diff --git a/internal/service/memory_extractor.go b/internal/service/memory_extractor.go
index e5b08c3809..1c2d7a55a5 100644
--- a/internal/service/memory_extractor.go
+++ b/internal/service/memory_extractor.go
@@ -71,6 +71,18 @@ var (
var errPermanentMemoryTask = errors.New("memory: permanent task failure")
+// errMemoryChatCall marks a failed chat model call, for example an exhausted
+// quota. Python's chat models answer such failures in band ("**ERROR**: ..."),
+// which leaves the extraction empty and completes the task with
+// "No memory extracted from raw message." instead of failing it, so Go reports
+// the same outcome instead of retrying or failing the task. Embedding failures
+// are not marked: Python raises there and fails the task.
+var errMemoryChatCall = errors.New("memory: chat model call failed")
+
+// memoryNoExtractionProgress is the task progress message Python reports when
+// the extraction produced nothing, including after a failed model call.
+const memoryNoExtractionProgress = "No memory extracted from raw message."
+
// classifyMemoryTaskDependencyError marks confirmed missing or unusable
// dependencies as permanent while preserving transient lookup failures.
func classifyMemoryTaskDependencyError(err error) error {
@@ -358,6 +370,9 @@ func (s *MemoryMessageService) resumeMemoryTask(ctx context.Context, task *entit
if err := loadInput(); err != nil {
return err
}
+ // Python raises when the extraction cannot be embedded, so the
+ // task fails (and retries while attempts remain) instead of
+ // completing with an empty memory.
if err := s.storeMemoryTaskExtraction(ctx, task, msg); err != nil {
return err
}
@@ -373,7 +388,7 @@ func (s *MemoryMessageService) resumeMemoryTask(ctx context.Context, task *entit
case entity.MemoryTaskStateStored:
progressMsg := "Message saved successfully."
if len(task.Extraction) == 0 {
- progressMsg = "No memory extracted from raw message."
+ progressMsg = memoryNoExtractionProgress
}
completed, completeErr := s.memoryTaskDAO.Complete(ctx, dao.DB, task.TaskID, leaseOwner, progressMsg, memoryNow())
if completeErr != nil {
@@ -412,7 +427,14 @@ func (s *MemoryMessageService) extractMemoryTask(ctx context.Context, task *enti
extracted, err := s.extractByLLM(ctx, mem, extractTypes, msg, task.TaskID)
if err != nil {
- return nil, err
+ if !errors.Is(err, errMemoryChatCall) {
+ return nil, err
+ }
+ // A failed chat model call leaves nothing to extract, and Python
+ // reports it as "No memory extracted from raw message." instead of a
+ // task failure.
+ common.Warn(fmt.Sprintf("memory: chat model call failed while extracting task %s: %v", task.TaskID, err))
+ return []extractedMemory{}, nil
}
materialized := materializeMemoryExtraction(ctx, extracted, memoryNow())
return materialized, nil
@@ -484,15 +506,40 @@ func (s *MemoryMessageService) extractByLLM(ctx context.Context, mem *CreateMemo
temperature := mem.Temperature
resp, err := chatModel.ModelDriver.ChatWithMessages(ctx, target.ModelName, messages, target.APIConfig, &models.ChatConfig{Temperature: &temperature}, nil)
if err != nil {
- return nil, fmt.Errorf("chat model: %w", err)
+ return nil, fmt.Errorf("%w: chat model: %w", errMemoryChatCall, err)
}
if resp == nil || resp.Answer == nil {
- return nil, errors.New("empty response from chat model")
+ return nil, fmt.Errorf("%w: empty response from chat model", errMemoryChatCall)
+ }
+ if llmErr := memoryLLMError(*resp.Answer); llmErr != "" {
+ // The driver reports the failure as answer text, so the extraction is
+ // unusable: log it and report an empty extraction, the same outcome
+ // Python produces for the same payload.
+ common.Warn(fmt.Sprintf("memory: chat model failed for task %s: %s", taskID, llmErr))
+ return nil, nil
}
return parseMemoryExtraction(*resp.Answer, extractTypes), nil
}
+// memoryLLMError returns the failure a chat driver reports as answer text
+// instead of a Go error. Drivers mirror the Python convention of answering
+// with a "**ERROR**: <detail>" payload, which leaves no JSON to parse, so the
+// caller reports an empty extraction. An empty return means the answer carries
+// no error marker.
+func memoryLLMError(answer string) string {
+ const marker = "**ERROR**"
+ idx := strings.Index(answer, marker)
+ if idx < 0 {
+ return ""
+ }
+ detail := strings.TrimPrefix(strings.TrimSpace(answer[idx+len(marker):]), ":")
+ if strings.TrimSpace(detail) == "" {
+ return "chat model returned an error without detail"
+ }
+ return strings.TrimSpace(detail)
+}
+
// materializeMemoryExtraction assigns stable message ids and timestamp
// fallbacks before the extraction checkpoint is persisted.
func materializeMemoryExtraction(ctx context.Context, extracted []extractedMemory, now time.Time) []extractedMemory {
diff --git a/internal/service/memory_extractor_test.go b/internal/service/memory_extractor_test.go
index ea2c418e23..06a56e6340 100644
--- a/internal/service/memory_extractor_test.go
+++ b/internal/service/memory_extractor_test.go
@@ -1003,3 +1003,28 @@ func TestTypeInstructionsStayInLockstepWithPython(t *testing.T) {
}
}
}
+
+// TestMemoryLLMErrorDetectsInBandChatModelFailures pins the check that keeps a
+// driver-reported "**ERROR**: ..." answer out of the JSON parser: the failure is
+// logged and the extraction stays empty, so the task completes with the same
+// "No memory extracted from raw message." outcome Python reports.
+func TestMemoryLLMErrorDetectsInBandChatModelFailures(t *testing.T) {
+ cases := []struct {
+ name string
+ answer string
+ want string
+ }{
+ {name: "detail", answer: "**ERROR**: rate limit exceeded", want: "rate limit exceeded"},
+ {name: "no colon", answer: "**ERROR** quota exceeded", want: "quota exceeded"},
+ {name: "reasoning prefix", answer: "<think>ok</think>\n**ERROR**: upstream 503", want: "upstream 503"},
+ {name: "no detail", answer: "**ERROR**:", want: "chat model returned an error without detail"},
+ {name: "json answer", answer: `{"profile": []}`, want: ""},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ if got := memoryLLMError(tc.answer); got != tc.want {
+ t.Fatalf("memoryLLMError(%q) = %q, want %q", tc.answer, got, tc.want)
+ }
+ })
+ }
+}
diff --git a/internal/service/memory_message_service.go b/internal/service/memory_message_service.go
index 29083a7b48..fe6e696738 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)
embeddings, err := embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: contents}, embeddingModel.APIConfig, &models.EmbeddingConfig{Dimension: 0}, nil)
if err != nil {
- return err
+ return fmt.Errorf("embed model: %w", err)
}
if len(embeddings) != len(messages) {
return fmt.Errorf("embedding response count %d does not match message count %d", len(embeddings), len(messages))