Skip to content

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

fix(parser): preserve Markdown image references in chunk text (#21608)

jay777214b69a7f41cd0
diff --git a/internal/ingestion/component/chunker/general_test.go b/internal/ingestion/component/chunker/general_test.go
index d185c025bb..9a30dc02ec 100644
--- a/internal/ingestion/component/chunker/general_test.go
+++ b/internal/ingestion/component/chunker/general_test.go
@@ -37,6 +37,7 @@ import (
"ragflow/internal/entity"
"ragflow/internal/ingestion/component/schema"
"ragflow/internal/ingestion/task/indexdoc"
+ parserlib "ragflow/internal/parser/parser"
"ragflow/internal/parser/tableutil"
)
@@ -1542,3 +1543,45 @@ func TestGeneralContextSourceTextProjectsMergedRows(t *testing.T) {
})
}
}
+
+func TestGeneralChunkerMarkdownPreservesUnresolvedImageReferences(t *testing.T) {
+ markdown, err := parserlib.NewMarkdownParser(parserlib.GoMarkdown)
+ if err != nil {
+ t.Fatal(err)
+ }
+ source := "# Title\n\n![figure](images/fig-1.png)\n\n![](images/bare.png)\n\n" +
+ "| A | B |\n|---|---|\n| x | ![table](images/table.png) |\n"
+ parsed := markdown.ParseWithResult(t.Context(), "doc.md", []byte(source))
+ if parsed.Err != nil {
+ t.Fatalf("ParseWithResult: %v", parsed.Err)
+ }
+ comp, err := NewGeneralChunker(map[string]any{"chunk_token_size": 512})
+ if err != nil {
+ t.Fatal(err)
+ }
+ out, err := comp.Invoke(t.Context(), nil, map[string]any{
+ "name": "doc.md", "file_type": "md", "output_format": "json", "json": parsed.JSON,
+ })
+ if err != nil {
+ t.Fatalf("Invoke: %v", err)
+ }
+ chunks := outputChunks(t, out)
+ if len(chunks) == 0 {
+ t.Fatal("chunks are empty")
+ }
+ var text strings.Builder
+ for _, chunk := range chunks {
+ body, _ := chunk["text"].(string)
+ text.WriteString(body)
+ text.WriteByte('\n')
+ }
+ for _, want := range []string{
+ "![figure](images/fig-1.png)",
+ "![](images/bare.png)",
+ "![table](images/table.png)",
+ } {
+ if !strings.Contains(text.String(), want) {
+ t.Errorf("chunk text = %q, want it to contain %q", text.String(), want)
+ }
+ }
+}
diff --git a/internal/parser/parser/html_parser.go b/internal/parser/parser/html_parser.go
index 908f5d959b..a8f0d33e03 100644
--- a/internal/parser/parser/html_parser.go
+++ b/internal/parser/parser/html_parser.go
@@ -579,8 +579,14 @@ func htmlTableImages(table *html.Node, state *htmlWalkState) ([]htmlTableImage,
return
}
if state.resolveImage != nil {
+ // ParseTableHTML's cellText ignores <img>, so replace
+ // an unresolved table image with its Markdown reference.
alt := htmlAttribute(node, "alt")
- node.Type, node.Data, node.Attr = html.TextNode, alt, nil
+ replacement := alt
+ if shouldPreserveImageReference(src) {
+ replacement = "![" + alt + "](" + src + ")"
+ }
+ node.Type, node.Data, node.Attr = html.TextNode, replacement, nil
} else if media.IsHTMLDataImageSource(src) {
skippedInlineImages++
removeHTMLImageSource(node)
diff --git a/internal/parser/parser/markdown_parser.go b/internal/parser/parser/markdown_parser.go
index 466737f3d3..0112047a0b 100644
--- a/internal/parser/parser/markdown_parser.go
+++ b/internal/parser/parser/markdown_parser.go
@@ -880,10 +880,37 @@ func writeListItems(list *ast.List, buf *bytes.Buffer) {
}
}
+// shouldPreserveImageReference reports whether an image source should be kept
+// as a Markdown reference in text. Resolved remote images already carry an
+// image payload / img_id, and data URIs must stay out of text.
+func shouldPreserveImageReference(s string) bool {
+ s = strings.TrimSpace(s)
+ lower := strings.ToLower(s)
+ return !strings.HasPrefix(lower, "data:") &&
+ !strings.HasPrefix(lower, "http://") &&
+ !strings.HasPrefix(lower, "https://")
+}
+
func walkLeaf(n ast.Node, buf *bytes.Buffer) {
switch t := n.(type) {
case *ast.Text:
buf.Write(t.Literal)
+ case *ast.Image:
+ // Preserve the source reference so an unresolved local path survives
+ // text extraction. Data URIs stay out of text to avoid indexing base64.
+ if !shouldPreserveImageReference(string(t.Destination)) {
+ for _, c := range t.GetChildren() {
+ walkLeaf(c, buf)
+ }
+ return
+ }
+ buf.WriteString("![")
+ for _, c := range t.GetChildren() {
+ walkLeaf(c, buf)
+ }
+ buf.WriteString("](")
+ buf.Write(t.Destination)
+ buf.WriteByte(')')
case *ast.Code:
buf.Write(t.Literal)
case *ast.CodeBlock:
diff --git a/internal/parser/parser/markdown_parser_test.go b/internal/parser/parser/markdown_parser_test.go
index 9cdc4249e1..3752aadd90 100644
--- a/internal/parser/parser/markdown_parser_test.go
+++ b/internal/parser/parser/markdown_parser_test.go
@@ -223,6 +223,9 @@ func TestMarkdownParser_ParseWithResult_ImageDataURI(t *testing.T) {
// Find the image item
found := false
for _, item := range ItemsToMaps(res.JSON) {
+ if text, _ := item["text"].(string); strings.Contains(text, pixelB64) {
+ t.Errorf("data URI payload leaked into text: %q", text)
+ }
if kd, _ := item["doc_type_kwd"].(string); kd == "image" {
found = true
if img, ok := item["image"].(string); !ok || img != pixelB64 {
@@ -236,6 +239,101 @@ func TestMarkdownParser_ParseWithResult_ImageDataURI(t *testing.T) {
}
}
+func TestMarkdownParser_PreservesUnresolvedImageReferences(t *testing.T) {
+ p, err := NewMarkdownParser(GoMarkdown)
+ if err != nil {
+ t.Fatal(err)
+ }
+ md := "Before\n\n![figure](images/fig-1.png)\n\n![](images/bare.png)\n\n" +
+ "| A | B |\n|---|---|\n| x | ![table](images/table.png) |\n"
+ res := p.ParseWithResult(t.Context(), "test.md", []byte(md))
+ if res.Err != nil {
+ t.Fatalf("ParseWithResult: %v", res.Err)
+ }
+
+ var textItems []string
+ var table *entity.TableData
+ for _, item := range ItemsToMaps(res.JSON) {
+ if td, ok := item["table"].(*entity.TableData); ok {
+ table = td
+ continue
+ }
+ if text, _ := item["text"].(string); text != "" {
+ textItems = append(textItems, text)
+ }
+ }
+ texts := strings.Join(textItems, "\n")
+ if !strings.Contains(texts, "![figure](images/fig-1.png)") {
+ t.Errorf("image path missing from text items: %q", texts)
+ }
+ if !strings.Contains(texts, "![](images/bare.png)") {
+ t.Errorf("alt-less image reference missing from text items: %q", texts)
+ }
+ if table == nil {
+ t.Fatal("table item missing")
+ }
+ if got := table.Grid[1][1].Text; got != "![table](images/table.png)" {
+ t.Errorf("table image cell = %q, want the Markdown reference", got)
+ }
+}
+
+func TestMarkdownParser_TableDataURIWithLeadingSpace(t *testing.T) {
+ p, err := NewMarkdownParser(GoMarkdown)
+ if err != nil {
+ t.Fatal(err)
+ }
+ md := "| A | B |\n|---|---|\n| x | <img src=\" data:image/png;base64,aGVsbG8=\" alt=\"blob\"> |\n"
+ res := p.ParseWithResult(t.Context(), "test.md", []byte(md))
+ if res.Err != nil {
+ t.Fatalf("ParseWithResult: %v", res.Err)
+ }
+ for _, item := range ItemsToMaps(res.JSON) {
+ if table, ok := item["table"].(*entity.TableData); ok {
+ if got := table.Grid[1][1].Text; got != "blob" {
+ t.Errorf("table data URI cell = %q, want alt text only", got)
+ }
+ if strings.Contains(table.Grid[1][1].Text, "aGVsbG8=") {
+ t.Errorf("encoded data URI payload leaked into table text: %q", table.Grid[1][1].Text)
+ }
+ return
+ }
+ }
+ t.Fatal("table item missing")
+}
+
+func TestMarkdownParser_ResolvedRemoteImageKeepsAltOnly(t *testing.T) {
+ previous := ssrfAllowLoopback
+ ssrfAllowLoopback = true
+ t.Cleanup(func() { ssrfAllowLoopback = previous })
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ w.Header().Set("Content-Type", "image/png")
+ _, _ = w.Write([]byte("fake-png-data"))
+ }))
+ defer server.Close()
+
+ p, err := NewMarkdownParser(GoMarkdown)
+ if err != nil {
+ t.Fatal(err)
+ }
+ res := p.ParseWithResult(t.Context(), "test.md", []byte("![remote]("+server.URL+"/image.png)\n"))
+ if res.Err != nil {
+ t.Fatalf("ParseWithResult: %v", res.Err)
+ }
+ foundImage := false
+ for _, item := range ItemsToMaps(res.JSON) {
+ if text, _ := item["text"].(string); strings.Contains(text, server.URL) {
+ t.Errorf("resolved remote URL leaked into text: %q", text)
+ }
+ if kd, _ := item["doc_type_kwd"].(string); kd == "image" {
+ foundImage = true
+ }
+ }
+ if !foundImage {
+ t.Fatal("resolved remote image item missing")
+ }
+}
+
func TestMarkdownParser_ParseWithResult_NoImage(t *testing.T) {
ctx := t.Context()
p, _ := NewMarkdownParser(GoMarkdown)