Skip to content

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

feat(parser): add MonkeyOCRv2-Parsing support (#18887)

Ziyang Zhangfd9f9e7f6123
diff --git a/common/parser_config_utils.py b/common/parser_config_utils.py
index 7f8bda2b6d..aa202786eb 100644
--- a/common/parser_config_utils.py
+++ b/common/parser_config_utils.py
@@ -16,7 +16,6 @@
from typing import Any
-
# Parser-specific option keys. ``_has_mineru_options`` uses these to detect
# whether the operator clearly intended the MinerU parser (issue #17114).
MINERU_OPTION_KEYS: tuple[str, ...] = (
@@ -45,7 +44,10 @@ def normalize_layout_recognizer(layout_recognizer_raw: Any) -> tuple[Any, str |
if isinstance(layout_recognizer_raw, str):
lowered = layout_recognizer_raw.lower()
- if lowered.endswith("@mineru"):
+ if lowered.endswith("@monkeyocrv2"):
+ parser_model_name = layout_recognizer_raw
+ layout_recognizer = "MonkeyOCRv2"
+ elif lowered.endswith("@mineru"):
parser_model_name = layout_recognizer_raw
layout_recognizer = "MinerU"
elif lowered.endswith("@paddleocr"):
diff --git a/conf/models/monkeyocrv2.json b/conf/models/monkeyocrv2.json
new file mode 100644
index 0000000000..5de92771c1
--- /dev/null
+++ b/conf/models/monkeyocrv2.json
@@ -0,0 +1,15 @@
+{
+ "name": "MonkeyOCRv2",
+ "url_suffix": {
+ "doc_parse": "parse"
+ },
+ "class": "local",
+ "models": [
+ {
+ "name": "MonkeyOCRv2-Parsing",
+ "model_types": [
+ "ocr"
+ ]
+ }
+ ]
+}
diff --git a/deepdoc/parser/monkeyocrv2_parser.py b/deepdoc/parser/monkeyocrv2_parser.py
new file mode 100644
index 0000000000..bef682bbe4
--- /dev/null
+++ b/deepdoc/parser/monkeyocrv2_parser.py
@@ -0,0 +1,163 @@
+"""Client for the MonkeyOCRv2 ZIP API."""
+
+import io
+import json
+import re
+import zipfile
+from pathlib import Path
+
+import requests
+from PIL import Image
+
+
+class MonkeyOCRv2Parser:
+ _MAX_RESPONSE_BYTES = 512 * 1024 * 1024
+ _MAX_ZIP_MEMBERS = 10000
+ _MAX_UNCOMPRESSED_BYTES = 2 * 1024 * 1024 * 1024
+
+ def __init__(self, server_url: str, timeout: int = 1800):
+ self.server_url = server_url.rstrip("/")
+ self.timeout = timeout
+
+ def check_installation(self):
+ """Return whether the configured MonkeyOCRv2 service is reachable."""
+ try:
+ return requests.get(f"{self.server_url}/health", timeout=10).ok
+ except requests.RequestException:
+ return False
+
+ def crop(self, _text, ZM=1, need_position=False):
+ """Compatibility hook used by RAGFlow's PDF chunk tokenizer.
+
+ MonkeyOCRv2 returns already-rendered layout content and image
+ artifacts; it does not retain a local PDF canvas for post-hoc crops.
+ Returning no crop is preferable to failing chunk generation.
+ """
+ del ZM
+ positions = self.extract_positions(_text)
+ return (None, positions) if need_position else None
+
+ @staticmethod
+ def remove_tag(text):
+ """Return text unchanged; native layout tags are already normalized."""
+ return re.sub(r"@@[\t0-9.-]+?##", "", text)
+
+ @staticmethod
+ def extract_positions(text):
+ positions = []
+ for tag in re.findall(r"@@[0-9-]+\t[0-9.\t]+##", text):
+ page, left, right, top, bottom = tag.strip("#").strip("@").split("\t")
+ positions.append((int(page) - 1, float(left), float(right), float(top), float(bottom)))
+ return positions
+
+ def parse_pdf(self, filepath, binary=None, callback=None, page_from=0, page_to=99999, **_kwargs):
+ """Upload one document and convert the service's ZIP response."""
+ payload = binary if binary is not None else Path(filepath).read_bytes()
+ response = requests.post(
+ f"{self.server_url}/parse", files={"files": (Path(filepath).name, payload, "application/pdf")}, data={"start_page_id": page_from, "end_page_id": page_to}, timeout=self.timeout, stream=True
+ )
+ try:
+ response.raise_for_status()
+ chunks = []
+ size = 0
+ if hasattr(response, "iter_content"):
+ for chunk in response.iter_content(1024 * 1024):
+ if chunk:
+ size += len(chunk)
+ if size > self._MAX_RESPONSE_BYTES:
+ raise RuntimeError(f"MonkeyOCRv2 response exceeds {self._MAX_RESPONSE_BYTES} bytes")
+ chunks.append(chunk)
+ archive_bytes = b"".join(chunks)
+ else:
+ archive_bytes = response.content
+ if len(archive_bytes) > self._MAX_RESPONSE_BYTES:
+ raise RuntimeError(f"MonkeyOCRv2 response exceeds {self._MAX_RESPONSE_BYTES} bytes")
+ finally:
+ if hasattr(response, "close"):
+ response.close()
+ if "zip" not in response.headers.get("content-type", "").lower() and not zipfile.is_zipfile(io.BytesIO(archive_bytes)):
+ raise RuntimeError("MonkeyOCRv2 /parse did not return a ZIP archive")
+ try:
+ result = self._convert_zip(archive_bytes)
+ except (zipfile.BadZipFile, OSError, ValueError, TypeError, KeyError, IndexError) as exc:
+ raise RuntimeError("Invalid MonkeyOCRv2 parse response") from exc
+ return result
+
+ def _convert_zip(self, archive_bytes):
+ """Convert native JSON layout records to RAGFlow sections and tables."""
+ sections, tables = [], []
+ with zipfile.ZipFile(io.BytesIO(archive_bytes)) as archive:
+ names = archive.namelist()
+ infos = archive.infolist()
+ if len(infos) > self._MAX_ZIP_MEMBERS or sum(info.file_size for info in infos) > self._MAX_UNCOMPRESSED_BYTES:
+ raise ValueError("MonkeyOCRv2 ZIP exceeds safety limits")
+ image_data = {}
+ for info in infos:
+ if info.filename.lower().endswith((".png", ".jpg", ".jpeg", ".webp")):
+ image_data[Path(info.filename).name] = archive.read(info)
+ roots = {
+ name.split("/", 1)[0]
+ for name in names
+ if "/" in name
+ and (name.endswith(".md") or name.endswith("/all_results.json") or name == f"{name.split('/', 1)[0]}/{name.split('/', 1)[0]}.json" or (name.endswith(".json") and "/jsons/" in name))
+ }
+ for root in roots:
+ canonical = f"{root}/{root}.json"
+ candidates = [canonical] if canonical in names else []
+ if not candidates:
+ candidates = [n for n in names if n.startswith(root + "/jsons/") and n.endswith(".json")]
+ records = []
+ for name in candidates:
+ try:
+ records.append(json.loads(archive.read(name)))
+ except (ValueError, UnicodeDecodeError):
+ pass
+ if not records:
+ summary = f"{root}/all_results.json"
+ if summary in names:
+ try:
+ records = json.loads(archive.read(summary))
+ if isinstance(records, dict):
+ records = [records]
+ except (ValueError, UnicodeDecodeError):
+ records = []
+ for document in records if isinstance(records, list) else [records]:
+ if not isinstance(document, dict):
+ continue
+ layouts = document.get("layouts", [])
+ if not isinstance(layouts, list):
+ continue
+ for layout in layouts:
+ if not isinstance(layout, dict):
+ continue
+ raw_text = layout.get("content")
+ if not isinstance(raw_text, str):
+ continue
+ text = raw_text.strip()
+ if not text:
+ continue
+ try:
+ page = max(0, int(layout.get("page_num", 1)) - 1)
+ except (TypeError, ValueError):
+ continue
+ bbox = layout.get("bbox", [0, 0, 0, 0])
+ if not isinstance(bbox, (list, tuple)) or len(bbox) != 4:
+ continue
+ tag = f"@@{page + 1}\t{bbox[0]}\t{bbox[2]}\t{bbox[1]}\t{bbox[3]}##"
+ label = str(layout.get("label", "")).lower()
+ if label in {"picture", "figure", "image"}:
+ match = re.search(r"!\[[^]]*\]\(([^)]+)\)", text)
+ if match:
+ image = image_data.get(Path(match.group(1).strip().strip("\"'")).name)
+ if image:
+ try:
+ media = Image.open(io.BytesIO(image)).copy()
+ tables.append(((media, [""]), [(page, bbox[0], bbox[2], bbox[1], bbox[3])]))
+ except OSError:
+ pass
+ continue
+ if label == "table":
+ tables.append(((None, text), [(page, bbox[0], bbox[2], bbox[1], bbox[3])]))
+ else:
+ sections.append((text, tag))
+ return sections, tables
diff --git a/internal/common/environments.go b/internal/common/environments.go
index 910565fc84..a54b3b37d0 100644
--- a/internal/common/environments.go
+++ b/internal/common/environments.go
@@ -160,6 +160,8 @@ const (
EnvMineruAPIServer = "MINERU_APISERVER"
EnvMineruAPIKey = "MINERU_API_KEY"
EnvMineruBackend = "MINERU_BACKEND"
+ EnvMonkeyOCRv2ServerURL = "MONKEYOCRV2_SERVER_URL"
+ EnvMonkeyOCRv2Timeout = "MONKEYOCRV2_TIMEOUT"
EnvOpenDataLoaderAPIServer = "OPENDATALOADER_APISERVER"
EnvOpenDataLoaderAPIKey = "OPENDATALOADER_API_KEY"
EnvPaddleOCRBaseUrl = "PADDLEOCR_BASE_URL"
diff --git a/internal/entity/models/factory.go b/internal/entity/models/factory.go
index efb6e1d662..63101bcfd8 100644
--- a/internal/entity/models/factory.go
+++ b/internal/entity/models/factory.go
@@ -141,6 +141,8 @@ func (f *ModelFactory) CreateModelDriver(providerName string, baseURL map[string
return NewAI302Model(baseURL, urlSuffix), nil
case "mineru":
return NewMinerLocalUModel(baseURL, urlSuffix), nil
+ case "monkeyocrv2":
+ return NewMonkeyOCRv2Model(baseURL, urlSuffix), nil
case "futurmix":
return NewFuturMixModel(baseURL, urlSuffix), nil
case "perplexity":
diff --git a/internal/entity/models/model_test.go b/internal/entity/models/model_test.go
index 8affb6e2a1..b3caf44365 100644
--- a/internal/entity/models/model_test.go
+++ b/internal/entity/models/model_test.go
@@ -17,6 +17,9 @@
package models
import (
+ "context"
+ "net/http"
+ "net/http/httptest"
"os"
"path/filepath"
"strings"
@@ -151,7 +154,7 @@ func TestBedrockConfigPreservesEmbeddingMaxTokens(t *testing.T) {
}
func TestLocalOCRProviderConfigsLoadLocalDrivers(t *testing.T) {
- dir, restore := setupProviderTestDir(t, "mineru_local.json", "paddleocr_local.json")
+ dir, restore := setupProviderTestDir(t, "mineru_local.json", "monkeyocrv2.json", "paddleocr_local.json")
defer restore()
err := InitProviderManager(dir)
@@ -172,6 +175,17 @@ func TestLocalOCRProviderConfigsLoadLocalDrivers(t *testing.T) {
t.Errorf("MinerU doc_parse suffix=%q", minerU.URLSuffix.DocumentParse)
}
+ monkeyOCRv2 := pm.FindProvider("MonkeyOCRv2")
+ if monkeyOCRv2 == nil {
+ t.Fatal("MonkeyOCRv2 provider not found")
+ }
+ if _, ok := monkeyOCRv2.ModelDriver.(*MonkeyOCRv2Model); !ok {
+ t.Fatalf("MonkeyOCRv2 ModelDriver=%T, want *models.MonkeyOCRv2Model", monkeyOCRv2.ModelDriver)
+ }
+ if monkeyOCRv2.URLSuffix.DocumentParse != "parse" {
+ t.Errorf("MonkeyOCRv2 doc_parse suffix=%q", monkeyOCRv2.URLSuffix.DocumentParse)
+ }
+
paddleOCR := pm.FindProvider("PaddleOCR.local")
if paddleOCR == nil {
t.Fatal("PaddleOCR.local provider not found")
@@ -184,6 +198,37 @@ func TestLocalOCRProviderConfigsLoadLocalDrivers(t *testing.T) {
}
}
+func TestModelFactoryCreatesMonkeyOCRv2Driver(t *testing.T) {
+ driver, err := NewModelFactory().CreateModelDriver("MonkeyOCRv2", map[string]string{"default": "http://localhost:8000"}, URLSuffix{})
+ if err != nil {
+ t.Fatal(err)
+ }
+ if driver.Name() != "monkeyocrv2" {
+ t.Fatalf("driver.Name()=%q", driver.Name())
+ }
+}
+
+func TestMonkeyOCRv2DriverVerifiesNativeParseEndpoint(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+ if request.URL.Path != "/openapi.json" {
+ t.Fatalf("path=%q", request.URL.Path)
+ }
+ _, _ = w.Write([]byte(`{"paths":{"/parse":{}}}`))
+ }))
+ defer server.Close()
+
+ driver := NewMonkeyOCRv2Model(map[string]string{"default": server.URL}, URLSuffix{})
+ if _, err := driver.OCRFile(context.Background(), nil, nil, nil, &APIConfig{}, nil, nil); err != nil {
+ t.Fatal(err)
+ }
+
+ driver = NewMonkeyOCRv2Model(nil, URLSuffix{})
+ apiKey := `{"MONKEYOCRV2_SERVER_URL":"` + server.URL + `"}`
+ if err := driver.CheckConnection(context.Background(), &APIConfig{ApiKey: &apiKey}); err != nil {
+ t.Fatalf("environment-provisioned API config: %v", err)
+ }
+}
+
func TestProviderConfigsLoadURLSuffixKeys(t *testing.T) {
dir, restore := setupProviderTestDir(t, "cohere.json", "xai.json")
defer restore()
diff --git a/internal/entity/models/monkeyocrv2.go b/internal/entity/models/monkeyocrv2.go
new file mode 100644
index 0000000000..35c5178a8b
--- /dev/null
+++ b/internal/entity/models/monkeyocrv2.go
@@ -0,0 +1,95 @@
+// 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.
+package models
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "net/http"
+ "strings"
+
+ "ragflow/internal/common"
+)
+
+// MonkeyOCRv2Model reuses the local document-parser model surface while
+// identifying the provider independently from MinerU. The ingestion dispatch
+// owns MonkeyOCRv2's native synchronous ZIP protocol.
+type MonkeyOCRv2Model struct {
+ *MinerULocalModel
+}
+
+func NewMonkeyOCRv2Model(baseURL map[string]string, urlSuffix URLSuffix) *MonkeyOCRv2Model {
+ return &MonkeyOCRv2Model{MinerULocalModel: NewMinerLocalUModel(baseURL, urlSuffix)}
+}
+
+func (m *MonkeyOCRv2Model) NewInstance(baseURL map[string]string) ModelDriver {
+ return NewMonkeyOCRv2Model(baseURL, m.baseModel.URLSuffix)
+}
+
+func (m *MonkeyOCRv2Model) Name() string {
+ return "monkeyocrv2"
+}
+
+// OCRFile performs the lightweight capability check expected by the generic
+// OCR-provider verification path. Document parsing itself is owned by the
+// ingestion dispatch because MonkeyOCRv2 returns a ZIP archive.
+func (m *MonkeyOCRv2Model) OCRFile(ctx context.Context, _ *string, _ []byte, _ *string, apiConfig *APIConfig, _ *OCRConfig, _ *common.ModelUsage) (*OCRFileResponse, error) {
+ if err := m.CheckConnection(ctx, apiConfig); err != nil {
+ return nil, err
+ }
+ return &OCRFileResponse{}, nil
+}
+
+func (m *MonkeyOCRv2Model) CheckConnection(ctx context.Context, apiConfig *APIConfig) error {
+ baseURL, err := m.baseModel.GetBaseURL(apiConfig)
+ if err != nil {
+ baseURL = monkeyOCRv2BaseURLFromAPIKey(apiConfig)
+ if baseURL == "" {
+ return err
+ }
+ }
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, strings.TrimRight(baseURL, "/")+"/openapi.json", nil)
+ if err != nil {
+ return err
+ }
+ resp, err := m.baseModel.httpClient.Do(req)
+ if err != nil {
+ return fmt.Errorf("MonkeyOCRv2 connection failed: %w", err)
+ }
+ defer resp.Body.Close()
+ if resp.StatusCode != http.StatusOK {
+ return fmt.Errorf("MonkeyOCRv2 OpenAPI returned HTTP %d", resp.StatusCode)
+ }
+ var spec struct {
+ Paths map[string]json.RawMessage `json:"paths"`
+ }
+ if err := json.NewDecoder(resp.Body).Decode(&spec); err != nil {
+ return fmt.Errorf("invalid MonkeyOCRv2 OpenAPI response: %w", err)
+ }
+ if _, ok := spec.Paths["/parse"]; !ok {
+ return fmt.Errorf("MonkeyOCRv2 server does not expose /parse")
+ }
+ return nil
+}
+
+func monkeyOCRv2BaseURLFromAPIKey(apiConfig *APIConfig) string {
+ if apiConfig == nil || apiConfig.ApiKey == nil || strings.TrimSpace(*apiConfig.ApiKey) == "" {
+ return ""
+ }
+ var config map[string]any
+ if err := json.Unmarshal([]byte(*apiConfig.ApiKey), &config); err != nil {
+ return ""
+ }
+ if nested, ok := config["api_key"].(map[string]any); ok {
+ config = nested
+ }
+ for _, key := range []string{"monkeyocrv2_server_url", common.EnvMonkeyOCRv2ServerURL} {
+ if value, ok := config[key].(string); ok && strings.TrimSpace(value) != "" {
+ return strings.TrimRight(strings.TrimSpace(value), "/")
+ }
+ }
+ return ""
+}
diff --git a/internal/ingestion/component/parser.go b/internal/ingestion/component/parser.go
index 3a6b430d99..946d1da930 100644
--- a/internal/ingestion/component/parser.go
+++ b/internal/ingestion/component/parser.go
@@ -202,7 +202,7 @@ func (c *ParserComponent) Check() error {
}
pmLower := strings.ToLower(pm)
pdfWhitelist := []string{
- "deepdoc", "plain_text", "mineru", "docling",
+ "deepdoc", "plain_text", "mineru", "monkeyocrv2", "docling",
"opendataloader", "tcadp parser", "paddleocr", "somark",
}
if !containsString(pdfWhitelist, pmLower) {
diff --git a/internal/ingestion/component/parser_check_test.go b/internal/ingestion/component/parser_check_test.go
index c205ccd9ca..109a59818b 100644
--- a/internal/ingestion/component/parser_check_test.go
+++ b/internal/ingestion/component/parser_check_test.go
@@ -72,6 +72,10 @@ func TestParserComponent_Check(t *testing.T) {
name: "pdf: paddleocr (whitelist) without lang → pass",
setups: map[string]schema.ParserSetup{"pdf": {"parse_method": "paddleocr"}},
},
+ {
+ name: "pdf: monkeyocrv2 (whitelist) without lang → pass",
+ setups: map[string]schema.ParserSetup{"pdf": {"parse_method": "monkeyocrv2"}},
+ },
// --- image family (parser.py:283-287) ---
{
diff --git a/internal/ingestion/component/parser_dispatch_test.go b/internal/ingestion/component/parser_dispatch_test.go
index e259896c30..16375ae71b 100644
--- a/internal/ingestion/component/parser_dispatch_test.go
+++ b/internal/ingestion/component/parser_dispatch_test.go
@@ -802,6 +802,63 @@ func TestDispatch_PDFMinerUMarkdown_UsesConfiguredBackend(t *testing.T) {
}
}
+func TestDispatch_PDFMonkeyOCRv2Markdown_UsesNativeParseEndpoint(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Method != http.MethodPost || r.URL.Path != "/parse" {
+ http.NotFound(w, r)
+ return
+ }
+ if err := r.ParseMultipartForm(1 << 20); err != nil {
+ t.Fatal(err)
+ }
+ if r.FormValue("start_page_id") != "0" || r.FormValue("end_page_id") != "99999" {
+ t.Fatalf("page range = %q:%q", r.FormValue("start_page_id"), r.FormValue("end_page_id"))
+ }
+ file, _, err := r.FormFile("files")
+ if err != nil {
+ t.Fatal(err)
+ }
+ _ = file.Close()
+
+ var output bytes.Buffer
+ archive := zip.NewWriter(&output)
+ entry, _ := archive.Create("sample/jsons/sample.json")
+ _, _ = entry.Write([]byte(`[{"label":"Title","content":"MonkeyOCRv2 title"}]`))
+ _ = archive.Close()
+ w.Header().Set("Content-Type", "application/zip")
+ _, _ = w.Write(output.Bytes())
+ }))
+ defer server.Close()
+
+ original := resolveTenantOCRModelByProvider
+ t.Cleanup(func() { resolveTenantOCRModelByProvider = original })
+ resolveTenantOCRModelByProvider = func(_ context.Context, _ *gorm.DB, tenantID, providerName string) (models.ModelDriver, string, *models.APIConfig, int, error) {
+ if tenantID != "test-tenant" || providerName != "MonkeyOCRv2" {
+ t.Fatalf("tenant=%q provider=%q", tenantID, providerName)
+ }
+ return &monkeyOCRv2FakeDriver{}, "MonkeyOCRv2-Parsing", &models.APIConfig{BaseURL: &server.URL}, 0, nil
+ }
+
+ component, err := NewParserComponent(map[string]any{
+ "pdf": map[string]any{"parse_method": "monkeyocrv2", "output_format": "markdown"},
+ })
+ if err != nil {
+ t.Fatalf("NewParserComponent: %v", err)
+ }
+ out, err := component.Invoke(t.Context(), nil, map[string]any{
+ "binary": []byte("%PDF-1.4"),
+ "file_type": "pdf",
+ "name": "sample.pdf",
+ "tenant_id": "test-tenant",
+ })
+ if err != nil {
+ t.Fatalf("Invoke: %v", err)
+ }
+ if out["output_format"] != "markdown" || out["markdown"] != "MonkeyOCRv2 title" {
+ t.Fatalf("output=%#v", out)
+ }
+}
+
// mineruTestDriver is a minimal ModelDriver mock whose Name() returns "mineru".
type mineruTestDriver struct{}
diff --git a/internal/ingestion/component/pdf_vision_dispatch.go b/internal/ingestion/component/pdf_vision_dispatch.go
index 3c20d01a7a..40265d9451 100644
--- a/internal/ingestion/component/pdf_vision_dispatch.go
+++ b/internal/ingestion/component/pdf_vision_dispatch.go
@@ -4,13 +4,18 @@ import (
"archive/zip"
"bytes"
"context"
+ "encoding/base64"
"encoding/json"
"fmt"
"io"
+ "mime"
"mime/multipart"
"net/http"
"os"
+ "path"
"path/filepath"
+ "regexp"
+ "strconv"
"strings"
"sync"
"time"
@@ -32,6 +37,16 @@ type pdfVisionPage struct {
ImageURL string
}
+const (
+ monkeyOCRv2MaxResponseBytes = 512 << 20
+ monkeyOCRv2MaxZIPMembers = 10000
+ monkeyOCRv2MaxUncompressedBytes = 2 << 30
+ monkeyOCRv2MaxImageBytes = 64 << 20
+ monkeyOCRv2DefaultTimeout = 600 * time.Second
+)
+
+var monkeyOCRv2ImagePattern = regexp.MustCompile(`!\[([^]]*)\]\(([^)]+)\)`)
+
var (
pdfVisionPromptLoader = loadPDFVisionPrompt
pdfVisionPageRenderer = defaultRenderPDFVisionPages
@@ -65,9 +80,31 @@ func maybeDispatchPDFVision(
method := getStringOr(setup, "parse_method", "")
layout := getStringOr(setup, "layout_recognizer", "")
tenantID := getStringOr(inputs, "tenant_id", "")
+ layoutLower := strings.ToLower(strings.TrimSpace(layout))
+
+ monkeySelector := layout
+ if strings.TrimSpace(monkeySelector) == "" {
+ monkeySelector = method
+ }
+ isMonkeyMatch := strings.EqualFold(strings.TrimSpace(method), "monkeyocrv2") ||
+ strings.HasPrefix(layoutLower, "monkeyocrv2") ||
+ strings.Contains(layoutLower, "@monkeyocrv2")
+ isMonkeyByUUID := false
+ if !isMonkeyMatch && tenantID != "" && strings.TrimSpace(monkeySelector) != "" && !isNamedPDFParseMethod(monkeySelector) {
+ isMonkeyByUUID = isMonkeyOCRv2LayoutModelID(ctx, db, tenantID, monkeySelector)
+ }
+ if isMonkeyMatch || isMonkeyByUUID {
+ modelRef := ""
+ if isMonkeyByUUID {
+ modelRef = monkeySelector
+ } else if strings.Contains(monkeySelector, "@") {
+ modelRef = monkeySelector
+ }
+ res, err := dispatchMonkeyOCRv2PDF(ctx, db, filename, binary, tenantID, setup, modelRef)
+ return res, true, err
+ }
// MinerU dispatch: parse_method "mineru" or layout_recognizer "@MinerU"
- layoutLower := strings.ToLower(strings.TrimSpace(layout))
if strings.EqualFold(strings.TrimSpace(method), "mineru") ||
strings.HasPrefix(layoutLower, "mineru") ||
strings.Contains(layoutLower, "@mineru") {
@@ -145,6 +182,264 @@ func maybeDispatchPDFVision(
return res, true, nil
}
+func dispatchMonkeyOCRv2PDF(ctx context.Context, db *gorm.DB, filename string, binary []byte, tenantID string, setup schema.ParserSetup, modelRef string) (parserDispatchResult, error) {
+ baseURL := strings.TrimRight(getStringOr(setup, "monkeyocrv2_server_url", os.Getenv(common.EnvMonkeyOCRv2ServerURL)), "/")
+ timeout := monkeyOCRv2RequestTimeout(setup, nil)
+ if tenantID != "" {
+ var driver modelModule.ModelDriver
+ var apiConfig *modelModule.APIConfig
+ var err error
+ if modelRef != "" {
+ driver, _, apiConfig, _, err = resolveModelConfig(ctx, db, tenantID, entity.ModelTypeOCR, modelRef)
+ } else {
+ driver, _, apiConfig, _, err = resolveTenantOCRModelByProvider(ctx, db, tenantID, "MonkeyOCRv2")
+ }
+ if err == nil {
+ if !strings.EqualFold(driver.Name(), "monkeyocrv2") {
+ return parserDispatchResult{}, fmt.Errorf("parser: MonkeyOCRv2 requires a MonkeyOCRv2 OCR model; found %q", driver.Name())
+ }
+ if apiConfig != nil && apiConfig.BaseURL != nil && strings.TrimSpace(*apiConfig.BaseURL) != "" {
+ baseURL = strings.TrimRight(*apiConfig.BaseURL, "/")
+ } else if configuredURL := monkeyOCRv2APIConfigValue(apiConfig, "monkeyocrv2_server_url", common.EnvMonkeyOCRv2ServerURL); configuredURL != "" {
+ baseURL = strings.TrimRight(configuredURL, "/")
+ }
+ timeout = monkeyOCRv2RequestTimeout(setup, apiConfig)
+ } else if baseURL == "" {
+ return parserDispatchResult{}, fmt.Errorf("parser: MonkeyOCRv2 model: %w", err)
+ }
+ }
+ if baseURL == "" {
+ return parserDispatchResult{}, fmt.Errorf("parser: MonkeyOCRv2 requires monkeyocrv2_server_url or MONKEYOCRV2_SERVER_URL")
+ }
+ zipBytes, err := monkeyOCRv2ParseRequest(ctx, baseURL+"/parse", filename, binary, timeout)
+ if err != nil {
+ return parserDispatchResult{}, err
+ }
+ sections, err := monkeyOCRv2ExtractSections(zipBytes)
+ if err != nil {
+ return parserDispatchResult{}, err
+ }
+ return parserDispatchResult{OutputFormat: "markdown", Markdown: strings.Join(sections, "\n\n")}, nil
+}
+
+var isMonkeyOCRv2LayoutModelID = defaultIsMonkeyOCRv2LayoutModelID
+
+func defaultIsMonkeyOCRv2LayoutModelID(ctx context.Context, db *gorm.DB, tenantID, modelID string) bool {
+ if db == nil || strings.TrimSpace(modelID) == "" {
+ return false
+ }
+ driver, _, _, _, err := resolveModelConfigByID(ctx, db, tenantID, entity.ModelTypeOCR, modelID)
+ return err == nil && strings.EqualFold(driver.Name(), "monkeyocrv2")
+}
+
+func monkeyOCRv2ParseRequest(ctx context.Context, apiURL, filename string, binary []byte, timeout time.Duration) ([]byte, error) {
+ var body bytes.Buffer
+ writer := multipart.NewWriter(&body)
+ part, err := writer.CreateFormFile("files", filepath.Base(filename))
+ if err != nil {
+ return nil, err
+ }
+ if _, err = part.Write(binary); err != nil {
+ return nil, err
+ }
+ _ = writer.WriteField("start_page_id", "0")
+ _ = writer.WriteField("end_page_id", "99999")
+ if err = writer.Close(); err != nil {
+ return nil, err
+ }
+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, &body)
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Content-Type", writer.FormDataContentType())
+ client := *http.DefaultClient
+ client.Timeout = timeout
+ resp, err := client.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("MonkeyOCRv2 request: %w", err)
+ }
+ defer resp.Body.Close()
+ data, err := io.ReadAll(io.LimitReader(resp.Body, monkeyOCRv2MaxResponseBytes+1))
+ if err != nil {
+ return nil, err
+ }
+ if len(data) > monkeyOCRv2MaxResponseBytes {
+ return nil, fmt.Errorf("MonkeyOCRv2 response exceeds %d bytes", monkeyOCRv2MaxResponseBytes)
+ }
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("MonkeyOCRv2 HTTP %d: %s", resp.StatusCode, string(data))
+ }
+ return data, nil
+}
+
+func monkeyOCRv2APIConfigValue(apiConfig *modelModule.APIConfig, keys ...string) string {
+ if apiConfig == nil || apiConfig.ApiKey == nil || strings.TrimSpace(*apiConfig.ApiKey) == "" {
+ return ""
+ }
+ var config map[string]any
+ if err := json.Unmarshal([]byte(*apiConfig.ApiKey), &config); err != nil {
+ return ""
+ }
+ if nested, ok := config["api_key"].(map[string]any); ok {
+ config = nested
+ }
+ for _, key := range keys {
+ if value, ok := config[key]; ok && value != nil {
+ return strings.TrimSpace(fmt.Sprint(value))
+ }
+ }
+ return ""
+}
+
+func monkeyOCRv2RequestTimeout(setup schema.ParserSetup, apiConfig *modelModule.APIConfig) time.Duration {
+ value := ""
+ if raw, ok := setup["monkeyocrv2_timeout"]; ok {
+ value = strings.TrimSpace(fmt.Sprint(raw))
+ }
+ if value == "" {
+ value = monkeyOCRv2APIConfigValue(apiConfig, "monkeyocrv2_timeout", common.EnvMonkeyOCRv2Timeout)
+ }
+ if value == "" {
+ value = os.Getenv(common.EnvMonkeyOCRv2Timeout)
+ }
+ seconds, err := strconv.Atoi(value)
+ if err != nil || seconds <= 0 {
+ return monkeyOCRv2DefaultTimeout
+ }
+ return time.Duration(seconds) * time.Second
+}
+
+func monkeyOCRv2ExtractSections(zipBytes []byte) ([]string, error) {
+ reader, err := zip.NewReader(bytes.NewReader(zipBytes), int64(len(zipBytes)))
+ if err != nil {
+ return nil, fmt.Errorf("MonkeyOCRv2 returned invalid ZIP: %w", err)
+ }
+ if len(reader.File) > monkeyOCRv2MaxZIPMembers {
+ return nil, fmt.Errorf("MonkeyOCRv2 ZIP contains too many files")
+ }
+ var uncompressed uint64
+ for _, file := range reader.File {
+ uncompressed += file.UncompressedSize64
+ if uncompressed > monkeyOCRv2MaxUncompressedBytes {
+ return nil, fmt.Errorf("MonkeyOCRv2 ZIP is too large after extraction")
+ }
+ }
+ var canonicalJSON, legacyJSON []*zip.File
+ images := make(map[string]*zip.File)
+ for _, file := range reader.File {
+ if strings.HasPrefix(strings.ToLower(mime.TypeByExtension(path.Ext(file.Name))), "image/") {
+ images[path.Base(file.Name)] = file
+ }
+ cleanName := strings.TrimPrefix(path.Clean(file.Name), "./")
+ parts := strings.Split(cleanName, "/")
+ if len(parts) == 2 && parts[1] == parts[0]+".json" {
+ canonicalJSON = append(canonicalJSON, file)
+ }
+ if strings.Contains("/"+file.Name, "/jsons/") && strings.HasSuffix(file.Name, ".json") {
+ legacyJSON = append(legacyJSON, file)
+ }
+ }
+ candidates := canonicalJSON
+ if len(candidates) == 0 {
+ candidates = legacyJSON
+ }
+ if len(candidates) == 0 {
+ for _, file := range reader.File {
+ if strings.HasSuffix(file.Name, "all_results.json") {
+ candidates = append(candidates, file)
+ }
+ }
+ }
+ var sections []string
+ for _, file := range candidates {
+ rc, openErr := file.Open()
+ if openErr != nil {
+ return nil, openErr
+ }
+ data, readErr := io.ReadAll(rc)
+ rc.Close()
+ if readErr != nil {
+ return nil, readErr
+ }
+ var raw any
+ if err = json.Unmarshal(data, &raw); err != nil {
+ return nil, fmt.Errorf("parse %s: %w", file.Name, err)
+ }
+ sections = append(sections, monkeyOCRv2Texts(raw, images)...)
+ }
+ if len(sections) == 0 {
+ return nil, fmt.Errorf("MonkeyOCRv2 ZIP contains no textual layouts")
+ }
+ return sections, nil
+}
+
+func monkeyOCRv2Texts(raw any, images map[string]*zip.File) []string {
+ if object, ok := raw.(map[string]any); ok {
+ for _, key := range []string{"layouts", "content_list", "results", "items"} {
+ if value, exists := object[key]; exists {
+ return monkeyOCRv2Texts(value, images)
+ }
+ }
+ label := strings.ToLower(strings.ReplaceAll(getAnyString(object, "type", "label"), "_", "-"))
+ switch label {
+ case "page-header", "page-footer", "page-number", "discarded":
+ return nil
+ }
+ if label == "picture" || label == "figure" || label == "image" {
+ return monkeyOCRv2EmbeddedImage(getAnyString(object, "text", "content", "markdown"), images)
+ }
+ for _, key := range []string{"text", "content", "markdown", "table_body"} {
+ if text, ok := object[key].(string); ok && strings.TrimSpace(text) != "" {
+ return []string{text}
+ }
+ }
+ return nil
+ }
+ items, ok := raw.([]any)
+ if !ok {
+ return nil
+ }
+ var result []string
+ for _, item := range items {
+ result = append(result, monkeyOCRv2Texts(item, images)...)
+ }
+ return result
+}
+
+func monkeyOCRv2EmbeddedImage(markdown string, images map[string]*zip.File) []string {
+ match := monkeyOCRv2ImagePattern.FindStringSubmatch(markdown)
+ if len(match) != 3 {
+ return nil
+ }
+ file := images[path.Base(strings.Trim(strings.TrimSpace(match[2]), `"'`))]
+ if file == nil || file.UncompressedSize64 > monkeyOCRv2MaxImageBytes {
+ return nil
+ }
+ rc, err := file.Open()
+ if err != nil {
+ return nil
+ }
+ data, err := io.ReadAll(io.LimitReader(rc, monkeyOCRv2MaxImageBytes+1))
+ rc.Close()
+ if err != nil || len(data) > monkeyOCRv2MaxImageBytes {
+ return nil
+ }
+ mediaType := mime.TypeByExtension(path.Ext(file.Name))
+ if mediaType == "" {
+ mediaType = http.DetectContentType(data)
+ }
+ return []string{fmt.Sprintf("![%s](data:%s;base64,%s)", match[1], mediaType, base64.StdEncoding.EncodeToString(data))}
+}
+
+func getAnyString(object map[string]any, keys ...string) string {
+ for _, key := range keys {
+ if value, ok := object[key].(string); ok {
+ return value
+ }
+ }
+ return ""
+}
+
// dispatchMinerUPDF submits a PDF to the tenant's MinerU OCR model
// via the streaming /file_parse endpoint and returns parsed sections.
// Mirrors Python's mineru_parser.py:parse_PDF which POSTs with
@@ -565,7 +860,7 @@ func resolvePDFVisionModelID(setup schema.ParserSetup) (string, bool) {
func isNamedPDFParseMethod(raw string) bool {
method := strings.ToLower(strings.TrimSpace(raw))
switch method {
- case "deepdoc", "plain_text", "mineru", "docling", "opendataloader", "tcadp parser", "paddleocr", "somark":
+ case "deepdoc", "plain_text", "mineru", "monkeyocrv2", "docling", "opendataloader", "tcadp parser", "paddleocr", "somark":
return true
}
return false
diff --git a/internal/ingestion/component/pdf_vision_dispatch_test.go b/internal/ingestion/component/pdf_vision_dispatch_test.go
index 9008db90ee..78d2cfacd8 100644
--- a/internal/ingestion/component/pdf_vision_dispatch_test.go
+++ b/internal/ingestion/component/pdf_vision_dispatch_test.go
@@ -16,17 +16,137 @@
package component
import (
+ "archive/zip"
+ "bytes"
"context"
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "strings"
"testing"
+ "time"
"ragflow/internal/common"
"ragflow/internal/dao"
+ "ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
"ragflow/internal/ingestion/component/schema"
"gorm.io/gorm"
)
+func TestMonkeyOCRv2ExtractSectionsUsesNativeJSON(t *testing.T) {
+ var buffer bytes.Buffer
+ writer := zip.NewWriter(&buffer)
+ file, err := writer.Create("sample/sample.json")
+ if err != nil {
+ t.Fatal(err)
+ }
+ payload, _ := json.Marshal(map[string]any{"layouts": []map[string]any{{"label": "Page-header", "content": "ignored"}, {"label": "Title", "content": "Heading"}, {"label": "Formula", "content": "x^2"}}})
+ _, _ = file.Write(payload)
+ _ = writer.Close()
+ sections, err := monkeyOCRv2ExtractSections(buffer.Bytes())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(sections) != 2 || sections[0] != "Heading" || sections[1] != "x^2" {
+ t.Fatalf("sections=%v", sections)
+ }
+}
+
+func TestMonkeyOCRv2ExtractSectionsEmbedsZIPImage(t *testing.T) {
+ var buffer bytes.Buffer
+ writer := zip.NewWriter(&buffer)
+ jsonFile, _ := writer.Create("sample/sample.json")
+ _, _ = jsonFile.Write([]byte(`{"layouts":[{"label":"Picture","content":"![figure](images/figure.png)"}]}`))
+ imageFile, _ := writer.Create("sample/images/figure.png")
+ _, _ = imageFile.Write([]byte("png-data"))
+ _ = writer.Close()
+
+ sections, err := monkeyOCRv2ExtractSections(buffer.Bytes())
+ if err != nil {
+ t.Fatal(err)
+ }
+ if len(sections) != 1 || !strings.HasPrefix(sections[0], "![figure](data:image/png;base64,") {
+ t.Fatalf("sections=%v", sections)
+ }
+}
+
+func TestMonkeyOCRv2RequestTimeoutUsesSetupAndAPIConfig(t *testing.T) {
+ if got := monkeyOCRv2RequestTimeout(schema.ParserSetup{"monkeyocrv2_timeout": 12}, nil); got != 12*time.Second {
+ t.Fatalf("setup timeout=%v", got)
+ }
+ apiKey := `{"MONKEYOCRV2_TIMEOUT":"34"}`
+ if got := monkeyOCRv2RequestTimeout(nil, &modelModule.APIConfig{ApiKey: &apiKey}); got != 34*time.Second {
+ t.Fatalf("API config timeout=%v", got)
+ }
+}
+
+func TestDispatchMonkeyOCRv2PDFPostsNativeParseRequest(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+ if request.URL.Path != "/parse" {
+ t.Fatalf("path=%s", request.URL.Path)
+ }
+ if err := request.ParseMultipartForm(1 << 20); err != nil {
+ t.Fatal(err)
+ }
+ if request.FormValue("start_page_id") != "0" || request.FormValue("end_page_id") != "99999" {
+ t.Fatalf("page range missing")
+ }
+ var output bytes.Buffer
+ archive := zip.NewWriter(&output)
+ file, _ := archive.Create("sample/sample.json")
+ _, _ = file.Write([]byte(`{"layouts":[{"label":"Text","content":"hello"}]}`))
+ _ = archive.Close()
+ w.Header().Set("Content-Type", "application/zip")
+ _, _ = w.Write(output.Bytes())
+ }))
+ defer server.Close()
+ result, err := dispatchMonkeyOCRv2PDF(context.Background(), nil, "sample.pdf", []byte("pdf"), "", schema.ParserSetup{"monkeyocrv2_server_url": server.URL}, "")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result.OutputFormat != "markdown" || result.Markdown != "hello" {
+ t.Fatalf("result=%+v", result)
+ }
+}
+
+type monkeyOCRv2FakeDriver struct {
+ modelModule.ModelDriver
+}
+
+func (d *monkeyOCRv2FakeDriver) Name() string { return "monkeyocrv2" }
+
+func TestDispatchMonkeyOCRv2PDFUsesSelectedCompositeModel(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ var output bytes.Buffer
+ archive := zip.NewWriter(&output)
+ file, _ := archive.Create("sample/all_results.json")
+ _, _ = file.Write([]byte(`[{"label":"Text","content":"selected"}]`))
+ _ = archive.Close()
+ _, _ = w.Write(output.Bytes())
+ }))
+ defer server.Close()
+
+ original := resolveModelConfig
+ t.Cleanup(func() { resolveModelConfig = original })
+ selected := "MonkeyOCRv2-Parsing@custom@MonkeyOCRv2"
+ resolveModelConfig = func(_ context.Context, _ *gorm.DB, tenantID string, _ entity.ModelType, modelRef string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
+ if tenantID != "tenant-1" || modelRef != selected {
+ t.Fatalf("tenant=%q modelRef=%q", tenantID, modelRef)
+ }
+ return &monkeyOCRv2FakeDriver{}, "MonkeyOCRv2-Parsing", &modelModule.APIConfig{BaseURL: &server.URL}, 0, nil
+ }
+
+ result, err := dispatchMonkeyOCRv2PDF(context.Background(), nil, "sample.pdf", []byte("pdf"), "tenant-1", schema.ParserSetup{}, selected)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if result.Markdown != "selected" {
+ t.Fatalf("result=%+v", result)
+ }
+}
+
// paddleOCRFakeDriver embeds the ModelDriver interface and only implements
// the OCRFile method needed by dispatchPaddleOCRPdf.
type paddleOCRFakeDriver struct {
@@ -121,7 +241,7 @@ func TestIsNamedPDFParseMethodWhitelistAligned(t *testing.T) {
// Values that MUST be recognized (subset of the Check() whitelist,
// case-insensitive).
named := []string{
- "deepdoc", "plain_text", "mineru", "docling",
+ "deepdoc", "plain_text", "mineru", "monkeyocrv2", "docling",
"opendataloader", "tcadp parser", "paddleocr", "somark",
"DeepDoc", "PLAIN_TEXT", "MinerU", "DocLing",
"OpenDataLoader", "TCADP Parser", "PaddleOCR", "SoMark",
@@ -158,6 +278,7 @@ func TestIsNamedPDFParseMethodWhitelistAligned(t *testing.T) {
func TestIsNamedPDFParseMethodLayoutSuffixes(t *testing.T) {
suffixed := []string{
"foo@mineru", "@mineru",
+ "foo@monkeyocrv2", "@monkeyocrv2",
"foo@paddleocr", "@paddleocr",
"foo@somark", "@somark",
"foo@opendataloader", "@opendataloader",
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index d7bfc7188e..ea5a3c6c30 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -1593,6 +1593,7 @@ func (m *ModelProviderService) ListTenantAddedModels(ctx context.Context, userID
// Mirror Python's ensure_*_from_env calls.
_ = m.ensureMineruFromEnv(ctx, tenantID)
+ _ = m.ensureMonkeyOCRv2FromEnv(ctx, tenantID)
_ = m.ensurePaddleOCREnabledFromEnv(ctx, tenantID)
_ = m.ensureOpenDataLoaderFromEnv(ctx, tenantID)
@@ -1837,8 +1838,13 @@ func (m *ModelProviderService) ensureOpenDataLoaderFromEnv(ctx context.Context,
return m.ensureOCRProviderFromEnv(ctx, tenantID, "OpenDataLoader", "opendataloader-from-env", config)
}
-// env key / default config tables for the three OCR providers.
-// Mirrors common/constants.py MINERU_ENV_KEYS, PADDLEOCR_ENV_KEYS, OPENDATALOADER_ENV_KEYS.
+// ensureMonkeyOCRv2FromEnv mirrors Python's ensure_monkeyocrv2_from_env.
+func (m *ModelProviderService) ensureMonkeyOCRv2FromEnv(ctx context.Context, tenantID string) error {
+ config := collectEnvConfig(monkeyOCRv2EnvKeys, monkeyOCRv2DefaultConfig)
+ return m.ensureOCRProviderFromEnv(ctx, tenantID, "MonkeyOCRv2", "monkeyocrv2-from-env", config)
+}
+
+// Environment-key/default tables mirror the Python OCR provider settings.
var (
mineruEnvKeys = []string{
common.EnvMineruAPIServer,
@@ -1872,6 +1878,14 @@ var (
openDataLoaderDefaultConfig = map[string]interface{}{
common.EnvOpenDataLoaderAPIServer: "",
}
+ monkeyOCRv2EnvKeys = []string{
+ common.EnvMonkeyOCRv2ServerURL,
+ common.EnvMonkeyOCRv2Timeout,
+ }
+ monkeyOCRv2DefaultConfig = map[string]interface{}{
+ common.EnvMonkeyOCRv2ServerURL: "",
+ common.EnvMonkeyOCRv2Timeout: 600,
+ }
)
// collectEnvConfig collects environment variable values for the given keys
diff --git a/internal/service/model_service_test.go b/internal/service/model_service_test.go
index 33d04cdb7e..e2c601d034 100644
--- a/internal/service/model_service_test.go
+++ b/internal/service/model_service_test.go
@@ -83,6 +83,19 @@ func TestValidateBedrockAPIKeyAuth(t *testing.T) {
}
}
+func TestMonkeyOCRv2EnvConfig(t *testing.T) {
+ t.Setenv(common.EnvMonkeyOCRv2ServerURL, "http://monkeyocrv2:8000")
+ t.Setenv(common.EnvMonkeyOCRv2Timeout, "120")
+
+ config := collectEnvConfig(monkeyOCRv2EnvKeys, monkeyOCRv2DefaultConfig)
+ if config[common.EnvMonkeyOCRv2ServerURL] != "http://monkeyocrv2:8000" {
+ t.Fatalf("server URL = %#v", config[common.EnvMonkeyOCRv2ServerURL])
+ }
+ if config[common.EnvMonkeyOCRv2Timeout] != "120" {
+ t.Fatalf("timeout = %#v", config[common.EnvMonkeyOCRv2Timeout])
+ }
+}
+
func TestValidateEmbeddingModel(t *testing.T) {
maxDimension := 2048
maxBatchSize := 128
diff --git a/rag/app/naive.py b/rag/app/naive.py
index 494d677e85..3f4c8498ab 100644
--- a/rag/app/naive.py
+++ b/rag/app/naive.py
@@ -46,6 +46,7 @@ from deepdoc.parser import DocxParser, EpubParser, ExcelParser, HtmlParser, Json
from deepdoc.parser.figure_parser import VisionFigureParser, vision_figure_parser_docx_wrapper_naive, vision_figure_parser_pdf_wrapper
from deepdoc.parser.pdf_parser import PlainParser, VisionParser
from deepdoc.parser.docling_parser import DoclingParser
+from deepdoc.parser.monkeyocrv2_parser import MonkeyOCRv2Parser
from deepdoc.parser.tcadp_parser import TCADPParser
from common.float_utils import normalize_overlapped_percent
from common.parser_config_utils import has_mineru_options, normalize_layout_recognizer
@@ -293,6 +294,15 @@ def by_mineru(
raise RuntimeError("MinerU model not found or not configured.")
+def by_monkeyocrv2(filename, binary=None, from_page=0, to_page=MAXIMUM_PAGE_NUMBER, lang="Chinese", callback=None, pdf_cls=None, **kwargs):
+ server_url = kwargs.get("monkeyocrv2_server_url") or os.environ.get("MONKEYOCRV2_SERVER_URL", "")
+ if not server_url:
+ raise RuntimeError("MONKEYOCRV2_SERVER_URL is not configured")
+ parser = MonkeyOCRv2Parser(server_url)
+ sections, tables = parser.parse_pdf(filename, binary=binary, callback=callback, page_from=from_page, page_to=min(to_page, MAXIMUM_PAGE_NUMBER))
+ return sections, tables, parser
+
+
def by_docling(filename, binary=None, from_page=0, to_page=MAXIMUM_PAGE_NUMBER, lang="Chinese", callback=None, pdf_cls=None, **kwargs):
pdf_parser = DoclingParser()
parse_method = kwargs.get("parse_method", "raw")
@@ -540,6 +550,7 @@ def by_plaintext(filename, binary=None, from_page=0, to_page=MAXIMUM_PAGE_NUMBER
PARSERS = {
"deepdoc": by_deepdoc,
"mineru": by_mineru,
+ "monkeyocrv2": by_monkeyocrv2,
"docling": by_docling,
"opendataloader": by_opendataloader,
"tcadp parser": by_tcadp,
@@ -1206,7 +1217,7 @@ def chunk(filename, binary=None, from_page=0, to_page=MAXIMUM_PAGE_NUMBER, lang=
sections,
tables,
image_context_size,
- section_page_offset=from_page if name == "mineru" else 0,
+ section_page_offset=from_page if name in {"mineru", "monkeyocrv2"} else 0,
)
if name in ["tcadp", "docling", "mineru", "paddleocr", "opendataloader", "somark", "mistral ocr"]:
diff --git a/test/unit_test/deepdoc/parser/test_monkeyocrv2_parser.py b/test/unit_test/deepdoc/parser/test_monkeyocrv2_parser.py
new file mode 100644
index 0000000000..d9a3bb5e1b
--- /dev/null
+++ b/test/unit_test/deepdoc/parser/test_monkeyocrv2_parser.py
@@ -0,0 +1,109 @@
+import io
+import json
+import zipfile
+
+import pytest
+
+from deepdoc.parser.monkeyocrv2_parser import MonkeyOCRv2Parser
+
+
+class Response:
+ def __init__(self, content):
+ self.headers = {"content-type": "application/zip"}
+ self.content = content
+
+ def raise_for_status(self):
+ pass
+
+
+def make_zip(name, text, *, label="Text", include_markdown=True):
+ out = io.BytesIO()
+ with zipfile.ZipFile(out, "w") as z:
+ if include_markdown:
+ z.writestr(f"{name}/{name}.md", text)
+ z.writestr(f"{name}/jsons/{name}.json", json.dumps({"layouts": [{"label": label, "content": text, "bbox": [1, 2, 30, 40], "page_num": 2}]}))
+ return out.getvalue()
+
+
+def test_converts_native_layout_to_sections(monkeypatch):
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(make_zip("doc", "hello")))
+ sections, tables = MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf", page_from=1, page_to=3)
+ assert sections == [("hello", "@@2\t1\t30\t2\t40##")]
+ assert tables == []
+
+
+def test_converts_json_only_archive_without_markdown(monkeypatch):
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(make_zip("doc", "json only", include_markdown=False)))
+ sections, tables = MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf")
+ assert sections == [("json only", "@@2\t1\t30\t2\t40##")]
+ assert tables == []
+
+
+def test_converts_canonical_root_json_archive(monkeypatch):
+ out = io.BytesIO()
+ with zipfile.ZipFile(out, "w") as archive:
+ archive.writestr(
+ "doc/doc.json",
+ json.dumps({"layouts": [{"label": "Text", "content": "canonical", "bbox": [1, 2, 30, 40], "page_num": 1}]}),
+ )
+
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(out.getvalue()))
+ sections, tables = MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf")
+ assert sections == [("canonical", "@@1\t1\t30\t2\t40##")]
+ assert tables == []
+
+
+def test_converts_all_results_only_archive(monkeypatch):
+ out = io.BytesIO()
+ with zipfile.ZipFile(out, "w") as archive:
+ archive.writestr(
+ "doc/all_results.json",
+ json.dumps({"layouts": [{"label": "Text", "content": "summary", "bbox": [1, 2, 30, 40], "page_num": 2}]}),
+ )
+
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(out.getvalue()))
+ sections, tables = MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf")
+ assert sections == [("summary", "@@2\t1\t30\t2\t40##")]
+ assert tables == []
+
+
+def test_converts_table_layout_with_position(monkeypatch):
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(make_zip("doc", "a | b", label="Table")))
+ sections, tables = MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf")
+ assert sections == []
+ assert tables == [((None, "a | b"), [(1, 1, 30, 2, 40)])]
+
+
+def test_skips_malformed_layout_records(monkeypatch):
+ out = io.BytesIO()
+ with zipfile.ZipFile(out, "w") as archive:
+ archive.writestr("doc/jsons/doc.json", json.dumps({"layouts": [None, {"content": "bad", "page_num": None, "bbox": [1]}, {"content": "ok", "page_num": 1, "bbox": [1, 2, 3, 4]}]}))
+
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(out.getvalue()))
+ sections, tables = MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf")
+ assert sections == [("ok", "@@1\t1\t3\t2\t4##")]
+ assert tables == []
+
+
+def test_emits_slice_relative_page_numbers(monkeypatch):
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(make_zip("doc", "page", include_markdown=False)))
+ sections, _ = MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf", page_from=4)
+ assert sections == [("page", "@@2\t1\t30\t2\t40##")]
+
+
+def test_wraps_malformed_zip_response(monkeypatch):
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", lambda *a, **k: Response(b"not a zip archive"))
+ with pytest.raises(RuntimeError, match="Invalid MonkeyOCRv2 parse response"):
+ MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf")
+
+
+def test_sends_page_range_and_accepts_binary(monkeypatch):
+ seen = {}
+
+ def post(url, **kwargs):
+ seen.update(kwargs)
+ return Response(make_zip("doc", "ok"))
+
+ monkeypatch.setattr("deepdoc.parser.monkeyocrv2_parser.requests.post", post)
+ MonkeyOCRv2Parser("http://parser").parse_pdf("doc.pdf", binary=b"pdf", page_from=4, page_to=9)
+ assert seen["data"] == {"start_page_id": 4, "end_page_id": 9}
diff --git a/test/unit_test/rag/test_naive_dispatch.py b/test/unit_test/rag/test_naive_dispatch.py
index 0f5f30c71f..b56ce74608 100644
--- a/test/unit_test/rag/test_naive_dispatch.py
+++ b/test/unit_test/rag/test_naive_dispatch.py
@@ -90,6 +90,7 @@ def test_normalize_layout_recognizer_passes_through_known_keywords():
def test_normalize_layout_recognizer_strips_known_provider_suffix():
+ assert normalize_layout_recognizer("my-llm@my-instance@my-provider@monkeyocrv2") == ("MonkeyOCRv2", "my-llm@my-instance@my-provider@monkeyocrv2")
assert normalize_layout_recognizer("my-llm@my-instance@my-provider@mineru") == ("MinerU", "my-llm@my-instance@my-provider@mineru")
assert normalize_layout_recognizer("my-llm@my-instance@my-provider@paddleocr") == ("PaddleOCR", "my-llm@my-instance@my-provider@paddleocr")
assert normalize_layout_recognizer("my-llm@my-instance@my-provider@opendataloader") == ("OpenDataLoader", "my-llm@my-instance@my-provider@opendataloader")
@@ -146,6 +147,10 @@ class _ByMineru(_Parser):
pass
+class _ByMonkeyOCRv2(_Parser):
+ pass
+
+
class _ByDocling(_Parser):
pass
@@ -195,6 +200,7 @@ def naive_module():
_stub("deepdoc.parser.figure_parser", VisionFigureParser=_Parser, vision_figure_parser_docx_wrapper_naive=lambda *a, **k: None, vision_figure_parser_pdf_wrapper=lambda *a, **k: None)
_stub("deepdoc.parser.pdf_parser", PlainParser=_ByPlaintext, VisionParser=_Parser, RAGFlowPdfParser=_Parser)
_stub("deepdoc.parser.docling_parser", DoclingParser=_ByDocling)
+ _stub("deepdoc.parser.monkeyocrv2_parser", MonkeyOCRv2Parser=_Parser)
_stub("deepdoc.parser.tcadp_parser", TCADPParser=_Parser)
_stub("deepdoc.parser.utils", extract_pdf_outlines=lambda *a, **k: [])
@@ -269,6 +275,7 @@ def naive_module():
# so assertions can identify which parser the dispatch selected.
module.PARSERS["deepdoc"] = _ByDeepdoc
module.PARSERS["mineru"] = _ByMineru
+ module.PARSERS["monkeyocrv2"] = _ByMonkeyOCRv2
module.PARSERS["docling"] = _ByDocling
module.PARSERS["opendataloader"] = _ByOpenDataLoader
module.PARSERS["plaintext"] = _ByPlaintext
@@ -292,6 +299,14 @@ def _dispatch(naive_module, layout_recognize, parser_config=None):
return naive_module._dispatch_pdf_parser(cfg)
+def test_dispatch_uses_single_monkeyocrv2_name(naive_module):
+ parser, name, layout_recognizer, _op, model = _dispatch(naive_module, "MonkeyOCRv2")
+ assert parser is _ByMonkeyOCRv2
+ assert name == "monkeyocrv2"
+ assert layout_recognizer == "MonkeyOCRv2"
+ assert model is None
+
+
# CodeRabbit review #3: don't fall back to MinerU for known keywords.
def test_dispatch_does_not_fall_back_to_mineru_for_plain_text_with_mineru_options(naive_module):
"""layout_recognize='Plain Text' is a known keyword — the dispatcher
diff --git a/web/src/components/layout-recognize-form-field.tsx b/web/src/components/layout-recognize-form-field.tsx
index edfff7ceb5..e0ff99021d 100644
--- a/web/src/components/layout-recognize-form-field.tsx
+++ b/web/src/components/layout-recognize-form-field.tsx
@@ -38,6 +38,7 @@ export const enum ParseDocumentType {
Docling = 'Docling',
OpenDataLoader = 'OpenDataLoader',
TCADPParser = 'TCADP Parser',
+ MonkeyOCRv2 = 'MonkeyOCRv2',
}
export function LayoutRecognizeFormField({
@@ -77,6 +78,7 @@ export function LayoutRecognizeFormField({
ParseDocumentType.Docling,
ParseDocumentType.OpenDataLoader,
ParseDocumentType.TCADPParser,
+ ParseDocumentType.MonkeyOCRv2,
].map((x) => ({
label: x === ParseDocumentType.PlainText ? t(camelCase(x)) : x,
value: x,