RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
feat(parser): add MonkeyOCRv2-Parsing support (#18887)
Ziyang Zhangfd9f9e7f6123
diff --git a/common/parser_config_utils.py b/common/parser_config_utils.pyindex 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_rawlayout_recognizer = "MinerU"elif lowered.endswith("@paddleocr"):diff --git a/conf/models/monkeyocrv2.json b/conf/models/monkeyocrv2.jsonnew file mode 100644index 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.pynew file mode 100644index 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, tablesdiff --git a/internal/common/environments.go b/internal/common/environments.goindex 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.goindex 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[stringreturn NewAI302Model(baseURL, urlSuffix), nilcase "mineru":return NewMinerLocalUModel(baseURL, urlSuffix), nil+ case "monkeyocrv2":+ return NewMonkeyOCRv2Model(baseURL, urlSuffix), nilcase "futurmix":return NewFuturMixModel(baseURL, urlSuffix), nilcase "perplexity":diff --git a/internal/entity/models/model_test.go b/internal/entity/models/model_test.goindex 8affb6e2a1..b3caf44365 100644--- a/internal/entity/models/model_test.go+++ b/internal/entity/models/model_test.go@@ -17,6 +17,9 @@package modelsimport (+ "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.gonew file mode 100644index 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.goindex 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.goindex 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.goindex 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.goindex 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 = loadPDFVisionPromptpdfVisionPageRenderer = 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("", 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 falsediff --git a/internal/ingestion/component/pdf_vision_dispatch_test.go b/internal/ingestion/component/pdf_vision_dispatch_test.goindex 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 componentimport (+ "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":""}]}`))+ 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], " {+ 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.goindex 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 keysdiff --git a/internal/service/model_service_test.go b/internal/service/model_service_test.goindex 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 := 2048maxBatchSize := 128diff --git a/rag/app/naive.py b/rag/app/naive.pyindex 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, Jsonfrom deepdoc.parser.figure_parser import VisionFigureParser, vision_figure_parser_docx_wrapper_naive, vision_figure_parser_pdf_wrapperfrom deepdoc.parser.pdf_parser import PlainParser, VisionParserfrom deepdoc.parser.docling_parser import DoclingParser+from deepdoc.parser.monkeyocrv2_parser import MonkeyOCRv2Parserfrom deepdoc.parser.tcadp_parser import TCADPParserfrom common.float_utils import normalize_overlapped_percentfrom 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_NUMBERPARSERS = {"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.pynew file mode 100644index 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.pyindex 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"] = _ByDeepdocmodule.PARSERS["mineru"] = _ByMineru+ module.PARSERS["monkeyocrv2"] = _ByMonkeyOCRv2module.PARSERS["docling"] = _ByDoclingmodule.PARSERS["opendataloader"] = _ByOpenDataLoadermodule.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 dispatcherdiff --git a/web/src/components/layout-recognize-form-field.tsx b/web/src/components/layout-recognize-form-field.tsxindex 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,