lfx-docling 0.1.0__py3-none-any.whl

lfx_docling/__init__.py

@@ -0,0 +1,13 @@
+"""lfx-docling: Docling document processing components."""
+
+from lfx_docling.components.docling.chunk_docling_document import ChunkDoclingDocumentComponent
+from lfx_docling.components.docling.docling_inline import DoclingInlineComponent
+from lfx_docling.components.docling.docling_remote import DoclingRemoteComponent
+from lfx_docling.components.docling.export_docling_document import ExportDoclingDocumentComponent
+
+__all__ = [
+    "ChunkDoclingDocumentComponent",
+    "DoclingInlineComponent",
+    "DoclingRemoteComponent",
+    "ExportDoclingDocumentComponent",
+]

lfx_docling/components/docling/__init__.py

@@ -0,0 +1,11 @@
+from .chunk_docling_document import ChunkDoclingDocumentComponent
+from .docling_inline import DoclingInlineComponent
+from .docling_remote import DoclingRemoteComponent
+from .export_docling_document import ExportDoclingDocumentComponent
+
+__all__ = [
+    "ChunkDoclingDocumentComponent",
+    "DoclingInlineComponent",
+    "DoclingRemoteComponent",
+    "ExportDoclingDocumentComponent",
+]

lfx_docling/components/docling/chunk_docling_document.py

@@ -0,0 +1,224 @@
+import json
+from typing import Any
+
+from lfx.base.data.docling_utils import extract_docling_documents
+from lfx.custom import Component
+from lfx.io import BoolInput, DropdownInput, HandleInput, IntInput, MessageTextInput, Output, StrInput
+from lfx.schema import Data, DataFrame
+
+_CHUNKING_INSTALL_HINT = (
+    "Install them with `uv pip install 'lfx-docling[chunking]'`, "
+    "`uv pip install 'langflow[docling-chunking]'`, or "
+    "`uv pip install 'docling-core[chunking]' tiktoken`."
+)
+
+
+def _load_docling_chunker_dependencies() -> tuple[type[Any], type[Any]]:
+    try:
+        from docling_core.transforms.chunker.doc_chunk import DocMeta as DocMetaCls
+        from docling_core.transforms.chunker.hierarchical_chunker import HierarchicalChunker as HierarchicalChunkerCls
+    except (ImportError, RuntimeError) as e:
+        msg = f"Docling chunking dependencies are not installed. {_CHUNKING_INSTALL_HINT}"
+        raise ImportError(msg) from e
+    return DocMetaCls, HierarchicalChunkerCls
+
+
+class ChunkDoclingDocumentComponent(Component):
+    display_name: str = "Chunk DoclingDocument"
+    description: str = "Use DoclingDocument chunkers to split the document into chunks."
+    documentation = "https://docling-project.github.io/docling/concepts/chunking/"
+    icon = "Docling"
+    name = "ChunkDoclingDocument"
+
+    inputs = [
+        HandleInput(
+            name="data_inputs",
+            display_name="JSON or Table",
+            info="The data with documents to split in chunks.",
+            input_types=["Data", "JSON", "DataFrame", "Table"],
+            required=True,
+        ),
+        DropdownInput(
+            name="chunker",
+            display_name="Chunker",
+            options=["HybridChunker", "HierarchicalChunker"],
+            info=("Which chunker to use."),
+            value="HybridChunker",
+            real_time_refresh=True,
+            input_types=["Message"],
+        ),
+        DropdownInput(
+            name="provider",
+            display_name="Provider",
+            options=["Hugging Face", "OpenAI"],
+            info=("Which tokenizer provider."),
+            value="Hugging Face",
+            show=True,
+            real_time_refresh=True,
+            advanced=True,
+            dynamic=True,
+        ),
+        StrInput(
+            name="hf_model_name",
+            display_name="HF model name",
+            info=(
+                "Model name of the tokenizer to use with the HybridChunker when Hugging Face is chosen as a tokenizer."
+            ),
+            value="sentence-transformers/all-MiniLM-L6-v2",
+            show=True,
+            advanced=True,
+            dynamic=True,
+        ),
+        StrInput(
+            name="openai_model_name",
+            display_name="OpenAI model name",
+            info=("Model name of the tokenizer to use with the HybridChunker when OpenAI is chosen as a tokenizer."),
+            value="gpt-4o",
+            show=False,
+            advanced=True,
+            dynamic=True,
+        ),
+        IntInput(
+            name="max_tokens",
+            display_name="Maximum tokens",
+            info=("Maximum number of tokens for the HybridChunker."),
+            show=True,
+            required=False,
+            advanced=True,
+            dynamic=True,
+            input_types=["Message"],
+        ),
+        BoolInput(
+            name="merge_peers",
+            display_name="Merge peers",
+            info="Merge undersized chunks sharing the same relevant metadata.",
+            value=True,
+            show=True,
+            advanced=True,
+            dynamic=True,
+        ),
+        BoolInput(
+            name="always_emit_headings",
+            display_name="Always emit headings",
+            info="Emit headings even for empty sections.",
+            value=False,
+            show=True,
+            advanced=True,
+            dynamic=True,
+        ),
+        MessageTextInput(
+            name="doc_key",
+            display_name="Doc Key",
+            info="The key to use for the DoclingDocument column.",
+            value="doc",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Table", name="dataframe", method="chunk_documents"),
+    ]
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
+        """Update build_config to show/hide fields based on chunker and provider selection."""
+        if field_name == "chunker":
+            provider_type = build_config["provider"]["value"]
+            is_hf = provider_type == "Hugging Face"
+            is_openai = provider_type == "OpenAI"
+            if field_value == "HybridChunker":
+                build_config["provider"]["show"] = True
+                build_config["hf_model_name"]["show"] = is_hf
+                build_config["openai_model_name"]["show"] = is_openai
+                build_config["max_tokens"]["show"] = True
+                build_config["merge_peers"]["show"] = True
+                build_config["always_emit_headings"]["show"] = True
+            else:
+                build_config["provider"]["show"] = False
+                build_config["hf_model_name"]["show"] = False
+                build_config["openai_model_name"]["show"] = False
+                build_config["max_tokens"]["show"] = False
+                build_config["merge_peers"]["show"] = False
+                build_config["always_emit_headings"]["show"] = False
+        elif field_name == "provider" and build_config["chunker"]["value"] == "HybridChunker":
+            if field_value == "Hugging Face":
+                build_config["hf_model_name"]["show"] = True
+                build_config["openai_model_name"]["show"] = False
+            elif field_value == "OpenAI":
+                build_config["hf_model_name"]["show"] = False
+                build_config["openai_model_name"]["show"] = True
+
+        return build_config
+
+    def _docs_to_data(self, docs) -> list[Data]:
+        return [Data(text=doc.page_content, data=doc.metadata) for doc in docs]
+
+    def chunk_documents(self) -> DataFrame:
+        documents, warning = extract_docling_documents(self.data_inputs, self.doc_key)
+        if warning:
+            self.status = warning
+
+        doc_meta_cls, hierarchical_chunker_cls = _load_docling_chunker_dependencies()
+        chunker: Any
+        if self.chunker == "HybridChunker":
+            try:
+                from docling_core.transforms.chunker.hybrid_chunker import HybridChunker
+            except (ImportError, RuntimeError) as e:
+                msg = f"HybridChunker is not installed. {_CHUNKING_INSTALL_HINT}"
+                raise ImportError(msg) from e
+            max_tokens: int | None = self.max_tokens if self.max_tokens else None
+            if self.provider == "Hugging Face":
+                try:
+                    from docling_core.transforms.chunker.tokenizer.huggingface import HuggingFaceTokenizer
+                except (ImportError, RuntimeError) as e:
+                    msg = f"HuggingFaceTokenizer is not installed. {_CHUNKING_INSTALL_HINT}"
+                    raise ImportError(msg) from e
+                tokenizer = HuggingFaceTokenizer.from_pretrained(
+                    model_name=self.hf_model_name,
+                    max_tokens=max_tokens,
+                )
+            elif self.provider == "OpenAI":
+                try:
+                    import tiktoken
+                    from docling_core.transforms.chunker.tokenizer.openai import OpenAITokenizer
+                except (ImportError, RuntimeError) as e:
+                    msg = f"OpenAITokenizer is not installed. {_CHUNKING_INSTALL_HINT}"
+                    raise ImportError(msg) from e
+                if max_tokens is None:
+                    max_tokens = 128 * 1024  # context window length required for OpenAI tokenizers
+                tokenizer = OpenAITokenizer(
+                    tokenizer=tiktoken.encoding_for_model(self.openai_model_name), max_tokens=max_tokens
+                )
+            chunker = HybridChunker(
+                tokenizer=tokenizer,
+                merge_peers=bool(self.merge_peers),
+                always_emit_headings=bool(self.always_emit_headings),
+            )
+
+        elif self.chunker == "HierarchicalChunker":
+            chunker = hierarchical_chunker_cls()
+        else:
+            msg = f"Unknown chunker: {self.chunker}"
+            raise ValueError(msg)
+
+        results: list[Data] = []
+        try:
+            for doc in documents:
+                for chunk in chunker.chunk(dl_doc=doc):
+                    enriched_text = chunker.contextualize(chunk=chunk)
+                    meta = doc_meta_cls.model_validate(chunk.meta)
+
+                    results.append(
+                        Data(
+                            data={
+                                "text": enriched_text,
+                                "document_id": f"{doc.origin.binary_hash}",
+                                "doc_items": json.dumps([item.self_ref for item in meta.doc_items]),
+                            }
+                        )
+                    )
+
+        except Exception as e:
+            msg = f"Error splitting text: {e}"
+            raise TypeError(msg) from e
+
+        return DataFrame(results)

lfx_docling/components/docling/docling_inline.py

@@ -0,0 +1,350 @@
+import json
+import subprocess
+import sys
+import textwrap
+import time
+
+from lfx.base.data import BaseFileComponent
+from lfx.base.data.docling_utils import _serialize_pydantic_model
+from lfx.inputs import BoolInput, DropdownInput, HandleInput, StrInput
+from lfx.schema import Data, DataFrame
+
+
+class DoclingInlineComponent(BaseFileComponent):
+    display_name = "Docling"
+    description = "Uses Docling to process input documents running the Docling models locally."
+    documentation = "https://docling-project.github.io/docling/"
+    trace_type = "tool"
+    icon = "Docling"
+    name = "DoclingInline"
+
+    # https://docling-project.github.io/docling/usage/supported_formats/
+    VALID_EXTENSIONS = [
+        "adoc",
+        "asciidoc",
+        "asc",
+        "bmp",
+        "csv",
+        "dotx",
+        "dotm",
+        "docm",
+        "docx",
+        "htm",
+        "html",
+        "jpeg",
+        "json",
+        "md",
+        "pdf",
+        "png",
+        "potx",
+        "ppsx",
+        "pptm",
+        "potm",
+        "ppsm",
+        "pptx",
+        "tiff",
+        "txt",
+        "xls",
+        "xlsx",
+        "xhtml",
+        "xml",
+        "webp",
+    ]
+
+    inputs = [
+        *BaseFileComponent.get_base_inputs(),
+        DropdownInput(
+            name="pipeline",
+            display_name="Pipeline",
+            info="Docling pipeline to use",
+            options=["standard", "vlm"],
+            value="standard",
+        ),
+        DropdownInput(
+            name="ocr_engine",
+            display_name="OCR Engine",
+            info="OCR engine to use. None will disable OCR.",
+            options=["None", "easyocr", "tesserocr", "rapidocr", "ocrmac"],
+            value="None",
+        ),
+        BoolInput(
+            name="do_picture_classification",
+            display_name="Picture classification",
+            info="If enabled, the Docling pipeline will classify the pictures type.",
+            value=False,
+        ),
+        HandleInput(
+            name="pic_desc_llm",
+            display_name="Picture description LLM",
+            info="If connected, the model to use for running the picture description task.",
+            input_types=["LanguageModel"],
+            required=False,
+        ),
+        StrInput(
+            name="pic_desc_prompt",
+            display_name="Picture description prompt",
+            value="Describe the image in three sentences. Be concise and accurate.",
+            info="The user prompt to use when invoking the model.",
+            advanced=True,
+        ),
+        # TODO: expose more Docling options
+    ]
+
+    outputs = [
+        *BaseFileComponent.get_base_outputs(),
+    ]
+
+    def build(self) -> DataFrame:
+        # Static bundle validation cannot see BaseFileComponent's inherited output method.
+        return self.load_files()
+
+    # ------------------------------------------------------------------ #
+    # Child script that runs Docling in a separate OS process.            #
+    # Uses subprocess.Popen (same pattern as Read File advanced mode)     #
+    # instead of multiprocessing/threading so that:                       #
+    #   1. It works reliably under Gunicorn's fork-based workers          #
+    #   2. The parent's event loop stays free for SSE heartbeats          #
+    #   3. No pickling / signal-handler conflicts                         #
+    # ------------------------------------------------------------------ #
+    _CHILD_SCRIPT: str = textwrap.dedent(r"""
+        import json, sys
+
+        def main():
+            cfg = json.loads(sys.stdin.read())
+            file_paths      = cfg["file_paths"]
+            pipeline        = cfg["pipeline"]
+            ocr_engine      = cfg["ocr_engine"]
+            do_picture_cls  = cfg["do_picture_classification"]
+            pic_desc_config = cfg.get("pic_desc_config")
+            pic_desc_prompt = cfg.get("pic_desc_prompt", "")
+
+            try:
+                from docling.datamodel.base_models import ConversionStatus, InputFormat
+                from docling.datamodel.pipeline_options import PdfPipelineOptions
+                from docling.document_converter import DocumentConverter, FormatOption, PdfFormatOption
+            except ImportError as e:
+                print(json.dumps({"ok": False, "error": f"Docling is not installed: {e}"}))
+                return
+
+            # --- build converter ------------------------------------------------
+            try:
+                pipe = PdfPipelineOptions()
+                pipe.do_ocr = ocr_engine not in ("", "None")
+                if pipe.do_ocr:
+                    try:
+                        from docling.models.factories import get_ocr_factory
+                        fac = get_ocr_factory(allow_external_plugins=False)
+                        pipe.ocr_options = fac.create_options(kind=ocr_engine)
+                    except Exception:
+                        pipe.do_ocr = False
+
+                pipe.do_picture_classification = do_picture_cls
+
+                if pic_desc_config:
+                    try:
+                        import importlib
+                        from pydantic import TypeAdapter
+                        try:
+                            from langchain_docling.picture_description import PictureDescriptionLangChainOptions
+                        except ImportError:
+                            print(json.dumps({
+                                "ok": False,
+                                "error": (
+                                    "langchain-docling is not installed. Install it with "
+                                    "`uv pip install 'langflow[docling-image-description]'` or "
+                                    "`uv pip install 'lfx-docling[image-description]'`."
+                                )
+                            }))
+                            return
+                        mod_name, cls_name = pic_desc_config["__class_path__"].rsplit(".", 1)
+                        mod = importlib.import_module(mod_name)
+                        cls = getattr(mod, cls_name)
+                        adapter = TypeAdapter(cls)
+                        llm = adapter.validate_python(pic_desc_config["config"])
+                        pipe.do_picture_description = True
+                        pipe.allow_external_plugins = True
+                        pipe.picture_description_options = PictureDescriptionLangChainOptions(
+                            llm=llm, prompt=pic_desc_prompt,
+                        )
+                    except Exception as e:
+                        print(json.dumps({"ok": False, "error": f"Picture description setup failed: {e}"}))
+                        return
+
+                if pipeline == "vlm":
+                    try:
+                        from docling.datamodel.pipeline_options import VlmPipelineOptions
+                        from docling.pipeline.vlm_pipeline import VlmPipeline
+                        vlm_opts = VlmPipelineOptions()
+                        if sys.platform == "darwin":
+                            try:
+                                from docling.datamodel.vlm_model_specs import GRANITEDOCLING_MLX
+                                vlm_opts.vlm_options = GRANITEDOCLING_MLX
+                            except ImportError:
+                                from docling.datamodel.vlm_model_specs import GRANITEDOCLING_TRANSFORMERS
+                                vlm_opts.vlm_options = GRANITEDOCLING_TRANSFORMERS
+                        fmt = {}
+                        if hasattr(InputFormat, "PDF"):
+                            fmt[InputFormat.PDF] = PdfFormatOption(
+                                pipeline_cls=VlmPipeline, pipeline_options=vlm_opts,
+                            )
+                        if hasattr(InputFormat, "IMAGE"):
+                            fmt[InputFormat.IMAGE] = PdfFormatOption(
+                                pipeline_cls=VlmPipeline, pipeline_options=vlm_opts,
+                            )
+                        converter = DocumentConverter(format_options=fmt)
+                    except Exception as e:
+                        print(json.dumps({"ok": False, "error": f"VLM pipeline setup failed: {e}"}))
+                        return
+                else:
+                    pdf_opt = PdfFormatOption(pipeline_options=pipe)
+                    fmt = {}
+                    if hasattr(InputFormat, "PDF"):
+                        fmt[InputFormat.PDF] = pdf_opt
+                    if hasattr(InputFormat, "IMAGE"):
+                        fmt[InputFormat.IMAGE] = pdf_opt
+                    converter = DocumentConverter(format_options=fmt)
+            except Exception as e:
+                print(json.dumps({"ok": False, "error": f"Converter creation failed: {e}"}))
+                return
+
+            # --- process files --------------------------------------------------
+            results = []
+            for fp in file_paths:
+                try:
+                    res = converter.convert(fp)
+                    ok = False
+                    if hasattr(res, "status"):
+                        try:
+                            ok = res.status == ConversionStatus.SUCCESS
+                        except Exception:
+                            ok = str(res.status).lower() == "success"
+                    if not ok and getattr(res, "document", None) is not None:
+                        ok = True
+                    if ok and res.document is not None:
+                        doc_json = res.document.export_to_dict()
+                        results.append({
+                            "document": doc_json,
+                            "file_path": str(fp),
+                            "status": "SUCCESS",
+                        })
+                    else:
+                        results.append(None)
+                except Exception as e:
+                    sys.stderr.write(f"Error processing {fp}: {e}\n")
+                    results.append(None)
+
+            print(json.dumps({"ok": True, "results": results}))
+
+        if __name__ == "__main__":
+            main()
+    """)
+
+    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        # Check that docling is installed without actually importing it.
+        # The real import (PyTorch, transformers, etc.) happens in the child
+        # subprocess.  Importing it here would spike memory and get the
+        # Gunicorn worker SIGKILL'd by the OOM killer.
+        import importlib.util
+
+        if importlib.util.find_spec("docling") is None:
+            msg = (
+                "Docling is an optional dependency. Install with `uv pip install 'langflow[docling]'` or "
+                "`uv pip install 'lfx-docling[local]'`."
+            )
+            raise ImportError(msg)
+
+        file_paths = [str(file.path) for file in file_list if file.path]
+
+        if not file_paths:
+            self.log("No files to process.")
+            return file_list
+
+        pic_desc_config: dict | None = None
+        if self.pic_desc_llm is not None:
+            pic_desc_config = _serialize_pydantic_model(self.pic_desc_llm)
+
+        args = {
+            "file_paths": file_paths,
+            "pipeline": self.pipeline,
+            "ocr_engine": self.ocr_engine,
+            "do_picture_classification": self.do_picture_classification,
+            "pic_desc_config": pic_desc_config,
+            "pic_desc_prompt": self.pic_desc_prompt,
+        }
+
+        # Use Popen with a polling loop (same pattern as Read File advanced mode).
+        # This avoids multiprocessing/threading issues under Gunicorn and keeps the
+        # SSE event stream alive via periodic heartbeat logs.
+        docling_timeout = 600  # 10 minutes
+        poll_interval = 5
+
+        # Use a temporary file for stdout to avoid pipe buffer deadlocks.
+        # Docling (and its transitive imports: PyTorch, transformers, etc.) can
+        # write large amounts of output.  With subprocess.PIPE the OS pipe
+        # buffer (~16 KB on macOS) fills up, the child blocks on write, and the
+        # parent - which only reads *after* the child exits - waits forever.
+        import tempfile
+
+        with tempfile.TemporaryFile() as stdout_file, tempfile.TemporaryFile() as stderr_file:
+            proc = subprocess.Popen(  # noqa: S603
+                [sys.executable, "-u", "-c", self._CHILD_SCRIPT],
+                stdin=subprocess.PIPE,
+                stdout=stdout_file,
+                stderr=stderr_file,
+            )
+            proc.stdin.write(json.dumps(args).encode("utf-8"))
+            proc.stdin.close()
+
+            start = time.monotonic()
+            while proc.poll() is None:
+                elapsed = time.monotonic() - start
+                if elapsed >= docling_timeout:
+                    proc.kill()
+                    proc.wait()
+                    msg = (
+                        f"Docling processing timed out after {docling_timeout}s. Try processing fewer or smaller files."
+                    )
+                    raise TimeoutError(msg)
+                self.log(f"Docling processing in progress ({int(elapsed)}s elapsed)...")
+                time.sleep(poll_interval)
+
+            stdout_file.seek(0)
+            stderr_file.seek(0)
+            stdout_bytes = stdout_file.read()
+            stderr_bytes = stderr_file.read()
+
+        if not stdout_bytes:
+            err_msg = stderr_bytes.decode("utf-8", errors="replace") if stderr_bytes else "no output"
+            msg = f"Docling subprocess error: {err_msg}"
+            raise RuntimeError(msg)
+
+        try:
+            payload = json.loads(stdout_bytes.decode("utf-8"))
+        except Exception as e:
+            err_msg = stderr_bytes.decode("utf-8", errors="replace")
+            msg = f"Invalid JSON from Docling subprocess: {e}. stderr={err_msg}"
+            raise RuntimeError(msg) from e
+
+        if not payload.get("ok"):
+            error_msg = payload.get("error", "Unknown Docling error")
+            if "not installed" in error_msg.lower():
+                raise ImportError(error_msg)
+            raise RuntimeError(error_msg)
+
+        # Reconstruct DoclingDocument objects from JSON dicts returned by the child
+        from docling_core.types.doc import DoclingDocument
+
+        raw_results = payload.get("results", [])
+        processed_data: list[Data | None] = []
+        for r in raw_results:
+            if r is None:
+                processed_data.append(None)
+                continue
+            try:
+                doc = DoclingDocument.model_validate(r["document"])
+            except Exception:  # noqa: BLE001
+                # Fall back to keeping the raw dict if validation fails
+                doc = r["document"]
+            processed_data.append(Data(data={"doc": doc, "file_path": r["file_path"]}))
+
+        return self.rollup_data(file_list, processed_data)

lfx_docling/components/docling/docling_remote.py

@@ -0,0 +1,353 @@
+from __future__ import annotations
+
+import base64
+import json
+import time
+from concurrent.futures import Future, ThreadPoolExecutor
+from pathlib import Path  # noqa: TC003
+from typing import Any
+
+import httpx
+from lfx.base.data import BaseFileComponent
+from lfx.base.data.docling_utils import coerce_docling_document
+from lfx.inputs import IntInput, NestedDictInput, StrInput, TableInput
+from lfx.inputs.inputs import FloatInput
+from lfx.schema import Data, DataFrame, dotdict
+from lfx.utils.util import transform_localhost_url
+
+
+class DoclingRemoteComponent(BaseFileComponent):
+    display_name = "Docling Serve"
+    description = "Uses Docling to process input documents connecting to your instance of Docling Serve."
+    documentation = "https://docling-project.github.io/docling/"
+    trace_type = "tool"
+    icon = "Docling"
+    name = "DoclingRemote"
+
+    MAX_500_RETRIES = 5
+
+    # https://docling-project.github.io/docling/usage/supported_formats/
+    VALID_EXTENSIONS = [
+        "adoc",
+        "asciidoc",
+        "asc",
+        "bmp",
+        "csv",
+        "dotx",
+        "dotm",
+        "docm",
+        "docx",
+        "htm",
+        "html",
+        "jpeg",
+        "jpg",
+        "json",
+        "md",
+        "pdf",
+        "png",
+        "potx",
+        "ppsx",
+        "pptm",
+        "potm",
+        "ppsm",
+        "pptx",
+        "tiff",
+        "txt",
+        "xls",
+        "xlsx",
+        "xhtml",
+        "xml",
+        "webp",
+    ]
+
+    inputs = [
+        *BaseFileComponent.get_base_inputs(),
+        StrInput(
+            name="api_url",
+            display_name="Server address",
+            info="URL of the Docling Serve instance.",
+            required=True,
+        ),
+        StrInput(
+            name="task_id",
+            display_name="Task ID",
+            info=(
+                "Optional task ID from a previous Docling Serve upload. "
+                "If provided, file input is ignored and the component polls for this task's results."
+            ),
+            required=False,
+        ),
+        IntInput(
+            name="max_concurrency",
+            display_name="Concurrency",
+            info="Maximum number of concurrent requests for the server.",
+            advanced=True,
+            value=2,
+            input_types=["Message"],
+        ),
+        FloatInput(
+            name="max_poll_timeout",
+            display_name="Maximum poll time",
+            info="Maximum waiting time for the document conversion to complete.",
+            advanced=True,
+            value=3600,
+            input_types=["Message"],
+        ),
+        TableInput(
+            name="api_headers",
+            display_name="HTTP headers",
+            advanced=True,
+            required=False,
+            info=("Optional headers required for connecting to Docling Serve."),
+            table_schema=[
+                {
+                    "name": "key",
+                    "display_name": "Key",
+                    "type": "string",
+                    "description": "Key name",
+                },
+                {
+                    "name": "value",
+                    "display_name": "Value",
+                    "load_from_db": True,
+                    "type": "string",
+                    "description": "Value of the header",
+                },
+            ],
+            value=[],
+            real_time_refresh=True,
+            input_types=["Data", "JSON"],
+        ),
+        NestedDictInput(
+            name="docling_serve_opts",
+            display_name="Docling options",
+            advanced=True,
+            required=False,
+            info=(
+                "Optional dictionary of additional options. "
+                "See https://github.com/docling-project/docling-serve/blob/main/docs/usage.md for more information."
+            ),
+            input_types=["Message"],
+        ),
+    ]
+
+    outputs = [
+        *BaseFileComponent.get_base_outputs(),
+    ]
+
+    def build(self) -> DataFrame:
+        # Static bundle validation cannot see BaseFileComponent's inherited output method.
+        return self.load_files()
+
+    @staticmethod
+    def _add_header(headers: dict[str, str], key: Any, value: Any) -> None:
+        key_str = str(key).strip()
+        if not key_str or key_str == "None":
+            return
+        headers[key_str] = str(value)
+
+    def _process_headers_input(self, headers_input: Any, component_headers_dict: dict[str, str]) -> None:
+        if not headers_input:
+            return
+
+        items = headers_input if isinstance(headers_input, list) else [headers_input]
+
+        for item in items:
+            if not item:
+                continue
+
+            # Case 1: Data object
+            if hasattr(item, "data") and isinstance(item.data, dict):
+                data = item.data
+                if "key" in data and "value" in data:
+                    self._add_header(component_headers_dict, data["key"], data["value"])
+                else:
+                    # Fallback: merge all keys from Data object
+                    for k, v in data.items():
+                        if k not in ("text_key", "default_value"):
+                            self._add_header(component_headers_dict, k, v)
+
+            # Case 2: Dictionary (Table row)
+            elif isinstance(item, dict):
+                if "key" in item and "value" in item:
+                    self._add_header(component_headers_dict, item["key"], item["value"])
+                else:
+                    # Fallback: merge all keys
+                    for k, v in item.items():
+                        self._add_header(component_headers_dict, k, v)
+
+            # Case 3: Message object
+            elif hasattr(item, "text") and isinstance(item.text, str):
+                try:
+                    parsed = json.loads(item.text)
+                    if isinstance(parsed, dict):
+                        for k, v in parsed.items():
+                            self._add_header(component_headers_dict, k, v)
+                except json.JSONDecodeError:
+                    pass
+
+    def _process_headers(self) -> dict[str, str]:
+        """Process the headers input into a valid dictionary."""
+        component_headers_dict: dict[str, str] = {}
+        self._process_headers_input(self.api_headers, component_headers_dict)
+        return component_headers_dict
+
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+        if field_name == "api_headers":
+            if isinstance(field_value, dict):
+                build_config["api_headers"]["value"] = [{"key": k, "value": v} for k, v in field_value.items()]
+                return build_config
+            if field_value is None:
+                build_config["api_headers"]["value"] = []
+                return build_config
+
+        # Default behavior
+        return super().update_build_config(build_config, field_value, field_name)
+
+    def _poll_and_fetch_result(
+        self, client: httpx.Client, base_url: str, task_id: str, file_path: str | None = None
+    ) -> Data | None:
+        """Poll for task completion and fetch the result.
+
+        Args:
+            client: The HTTP client to use for requests.
+            base_url: The base URL of the Docling Serve API.
+            task_id: The task ID to poll for.
+            file_path: Optional file path to include in the result data.
+
+        Returns:
+            Data object with the DoclingDocument, or None if processing failed.
+        """
+        http_failures = 0
+        retry_status_start = 500
+        retry_status_end = 600
+        start_wait_time = time.monotonic()
+
+        task_status = None
+        while task_status not in ("success", "failure"):
+            processing_time = time.monotonic() - start_wait_time
+            if processing_time >= self.max_poll_timeout:
+                msg = (
+                    f"Processing time {processing_time=} exceeds the maximum poll timeout {self.max_poll_timeout=}."
+                    "Please increase the max_poll_timeout parameter or review why the processing "
+                    "takes long on the server."
+                )
+                self.log(msg)
+                raise RuntimeError(msg)
+
+            response = client.get(f"{base_url}/status/poll/{task_id}")
+
+            if retry_status_start <= response.status_code < retry_status_end:
+                http_failures += 1
+                if http_failures > self.MAX_500_RETRIES:
+                    self.log(f"The status requests got a http response {response.status_code} too many times.")
+                    return None
+                time.sleep(2)
+                continue
+
+            response.raise_for_status()
+            task = response.json()
+            task_status = task["task_status"]
+            if task_status not in ("success", "failure"):
+                time.sleep(2)
+
+        result_resp = client.get(f"{base_url}/result/{task_id}")
+        result_resp.raise_for_status()
+        result = result_resp.json()
+
+        if result.get("status") == "failure" or result.get("errors"):
+            errors = result.get("errors", [])
+            err_msg_list = []
+            for err in errors:
+                if isinstance(err, dict) and "error_message" in err:
+                    err_msg_list.append(err["error_message"])
+                elif isinstance(err, str):
+                    err_msg_list.append(err)
+
+            err_details = "; ".join(err_msg_list) if err_msg_list else "Unknown Docling processing error"
+
+            msg = f"Docling processing failed: {err_details}"
+            raise ValueError(msg)
+
+        if "json_content" not in result["document"] or result["document"]["json_content"] is None:
+            self.log("No JSON DoclingDocument found in the result.")
+            return None
+
+        try:
+            doc = coerce_docling_document(result["document"]["json_content"])
+            data_dict: dict[str, Any] = {"doc": doc}
+            if file_path:
+                data_dict["file_path"] = file_path
+            return Data(data=data_dict)
+        except Exception as e:  # noqa: BLE001
+            self.log(f"Error validating the document. {e}")
+            return None
+
+    def _process_task_id(self) -> list[Data]:
+        """Process an existing task by polling for status and retrieving results.
+
+        Returns:
+            List containing the result Data object, or empty list if processing failed.
+        """
+        transformed_url = transform_localhost_url(self.api_url)
+        base_url = f"{transformed_url}/v1"
+
+        with httpx.Client(headers=self._process_headers()) as client:
+            result = self._poll_and_fetch_result(client, base_url, self.task_id)
+            return [result] if result else []
+
+    def load_files_base(self) -> list[Data]:
+        """Load and process files, or poll an existing task if task_id is provided.
+
+        Returns:
+            list[Data]: Parsed data from the processed files or task.
+        """
+        if self.task_id:
+            return self._process_task_id()
+        return super().load_files_base()
+
+    def process_files(self, file_list: list[BaseFileComponent.BaseFile]) -> list[BaseFileComponent.BaseFile]:
+        transformed_url = transform_localhost_url(self.api_url)
+        base_url = f"{transformed_url}/v1"
+
+        def _convert_document(client: httpx.Client, file_path: Path, options: dict[str, Any]) -> Data | None:
+            encoded_doc = base64.b64encode(file_path.read_bytes()).decode()
+            payload = {
+                "options": options,
+                "sources": [{"kind": "file", "base64_string": encoded_doc, "filename": file_path.name}],
+            }
+
+            response = client.post(f"{base_url}/convert/source/async", json=payload)
+            response.raise_for_status()
+            task = response.json()
+
+            return self._poll_and_fetch_result(client, base_url, task["task_id"], str(file_path))
+
+        docling_options = {
+            "to_formats": ["json"],
+            "image_export_mode": "placeholder",
+            **(self.docling_serve_opts or {}),
+        }
+
+        processed_data: list[Data | None] = []
+        with (
+            httpx.Client(headers=self._process_headers()) as client,
+            ThreadPoolExecutor(max_workers=self.max_concurrency) as executor,
+        ):
+            futures: list[tuple[int, Future]] = []
+            for i, file in enumerate(file_list):
+                if file.path is None:
+                    processed_data.append(None)
+                    continue
+
+                futures.append((i, executor.submit(_convert_document, client, file.path, docling_options)))
+
+            for _index, future in futures:
+                try:
+                    result_data = future.result()
+                    processed_data.append(result_data)
+                except (httpx.HTTPStatusError, httpx.RequestError, KeyError, ValueError) as exc:
+                    self.log(f"Docling remote processing failed: {exc}")
+                    raise
+
+        return self.rollup_data(file_list, processed_data)

lfx_docling/components/docling/export_docling_document.py

@@ -0,0 +1,137 @@
+from typing import Any
+
+from lfx.base.data.docling_utils import coerce_docling_document, extract_docling_documents, get_docling_image_ref_mode
+from lfx.custom import Component
+from lfx.io import DropdownInput, HandleInput, MessageTextInput, Output, StrInput
+from lfx.schema import Data, DataFrame
+
+
+class ExportDoclingDocumentComponent(Component):
+    display_name: str = "Export DoclingDocument"
+    description: str = "Export DoclingDocument to markdown, html or other formats."
+    documentation = "https://docling-project.github.io/docling/"
+    icon = "Docling"
+    name = "ExportDoclingDocument"
+
+    inputs = [
+        HandleInput(
+            name="data_inputs",
+            display_name="JSON or Table",
+            info="The data with documents to export.",
+            input_types=["Data", "JSON", "DataFrame", "Table"],
+            required=True,
+        ),
+        DropdownInput(
+            name="export_format",
+            display_name="Export format",
+            options=["Markdown", "HTML", "Plaintext", "DocTags"],
+            info="Select the export format to convert the input.",
+            value="Markdown",
+            real_time_refresh=True,
+        ),
+        DropdownInput(
+            name="image_mode",
+            display_name="Image export mode",
+            options=["placeholder", "embedded"],
+            info=(
+                "Specify how images are exported in the output. Placeholder will replace the images with a string, "
+                "whereas Embedded will include them as base64 encoded images."
+            ),
+            value="placeholder",
+        ),
+        StrInput(
+            name="md_image_placeholder",
+            display_name="Image placeholder",
+            info="Specify the image placeholder for markdown exports.",
+            value="<!-- image -->",
+            advanced=True,
+        ),
+        StrInput(
+            name="md_page_break_placeholder",
+            display_name="Page break placeholder",
+            info="Add this placeholder between pages in the markdown output.",
+            value="",
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="doc_key",
+            display_name="Doc Key",
+            info="The key to use for the DoclingDocument column.",
+            value="doc",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Exported data", name="data", method="export_document"),
+        Output(display_name="Table", name="dataframe", method="as_dataframe"),
+    ]
+
+    def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
+        if field_name == "export_format" and field_value == "Markdown":
+            build_config["md_image_placeholder"]["show"] = True
+            build_config["md_page_break_placeholder"]["show"] = True
+            build_config["image_mode"]["show"] = True
+        elif field_name == "export_format" and field_value == "HTML":
+            build_config["md_image_placeholder"]["show"] = False
+            build_config["md_page_break_placeholder"]["show"] = False
+            build_config["image_mode"]["show"] = True
+        elif field_name == "export_format" and field_value in {"Plaintext", "DocTags"}:
+            build_config["md_image_placeholder"]["show"] = False
+            build_config["md_page_break_placeholder"]["show"] = False
+            build_config["image_mode"]["show"] = False
+
+        return build_config
+
+    def _get_image_mode(self) -> Any:
+        return get_docling_image_ref_mode(self.image_mode)
+
+    @staticmethod
+    def _coerce_exportable_document(doc: Any) -> Any:
+        return coerce_docling_document(doc)
+
+    def export_document(self) -> list[Data]:
+        documents, warning = extract_docling_documents(self.data_inputs, self.doc_key)
+        if warning:
+            self.status = warning
+
+        results: list[Data] = []
+        try:
+            image_mode = self._get_image_mode()
+            for raw_doc in documents:
+                doc = self._coerce_exportable_document(raw_doc)
+                content = ""
+                if self.export_format == "Markdown":
+                    content = doc.export_to_markdown(
+                        image_mode=image_mode,
+                        image_placeholder=self.md_image_placeholder,
+                        page_break_placeholder=self.md_page_break_placeholder,
+                    )
+                elif self.export_format == "HTML":
+                    content = doc.export_to_html(image_mode=image_mode)
+                elif self.export_format == "Plaintext":
+                    content = doc.export_to_text()
+                elif self.export_format == "DocTags":
+                    content = doc.export_to_doctags()
+
+                # Preserve metadata from the DoclingDocument
+                metadata: dict = {"export_format": self.export_format}
+                if hasattr(doc, "name") and doc.name:
+                    metadata["name"] = doc.name
+                if hasattr(doc, "origin") and doc.origin is not None:
+                    if hasattr(doc.origin, "filename") and doc.origin.filename:
+                        metadata["filename"] = doc.origin.filename
+                    if hasattr(doc.origin, "binary_hash") and doc.origin.binary_hash:
+                        metadata["document_id"] = str(doc.origin.binary_hash)
+                    if hasattr(doc.origin, "mimetype") and doc.origin.mimetype:
+                        metadata["mimetype"] = doc.origin.mimetype
+
+                results.append(Data(text=content, data={"text": content, **metadata}))
+        except Exception as e:
+            msg = f"Error exporting document: {e}"
+            raise TypeError(msg) from e
+
+        return results
+
+    def as_dataframe(self) -> DataFrame:
+        return DataFrame(self.export_document())

lfx_docling/extension.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.langflow.org/extension/v1.json",
+  "id": "lfx-docling",
+  "version": "0.1.0",
+  "name": "Docling",
+  "description": "Docling document processing components as a standalone Langflow Extension Bundle.",
+  "lfx": {
+    "compat": ["1"]
+  },
+  "bundles": [
+    {
+      "name": "docling",
+      "path": "components/docling"
+    }
+  ]
+}

lfx_docling-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: lfx-docling
+Version: 0.1.0
+Summary: Docling document processing components as a standalone Langflow Extension Bundle.
+Project-URL: Homepage, https://github.com/langflow-ai/langflow
+Project-URL: Documentation, https://docs.langflow.org/bundles-docling
+Project-URL: Repository, https://github.com/langflow-ai/langflow
+Author-email: Langflow <contact@langflow.org>
+License: MIT
+Keywords: bundle,docling,documents,extension,langflow,lfx
+Requires-Python: <3.15,>=3.10
+Requires-Dist: docling-core<3.0.0,>=2.36.1
+Requires-Dist: httpx<1.0.0,>=0.28.1
+Requires-Dist: lfx>=0.5.0
+Provides-Extra: all
+Requires-Dist: docling-core[chunking]<3.0.0,>=2.36.1; extra == 'all'
+Requires-Dist: docling<3.0.0,>=2.36.1; (sys_platform != 'darwin' or platform_machine != 'x86_64') and extra == 'all'
+Requires-Dist: langchain-docling>=1.1.0; extra == 'all'
+Requires-Dist: ocrmac>=1.0.0; (sys_platform == 'darwin') and extra == 'all'
+Requires-Dist: rapidocr-onnxruntime>=1.4.4; extra == 'all'
+Requires-Dist: tesserocr>=2.8.0; extra == 'all'
+Requires-Dist: tiktoken>=0.7.0; extra == 'all'
+Requires-Dist: torch>=2.6.0; extra == 'all'
+Requires-Dist: torchvision>=0.21.0; extra == 'all'
+Provides-Extra: chunking
+Requires-Dist: docling-core[chunking]<3.0.0,>=2.36.1; extra == 'chunking'
+Requires-Dist: tiktoken>=0.7.0; extra == 'chunking'
+Provides-Extra: image-description
+Requires-Dist: docling<3.0.0,>=2.36.1; (sys_platform != 'darwin' or platform_machine != 'x86_64') and extra == 'image-description'
+Requires-Dist: langchain-docling>=1.1.0; extra == 'image-description'
+Requires-Dist: ocrmac>=1.0.0; (sys_platform == 'darwin') and extra == 'image-description'
+Requires-Dist: rapidocr-onnxruntime>=1.4.4; extra == 'image-description'
+Requires-Dist: tesserocr>=2.8.0; extra == 'image-description'
+Requires-Dist: torch>=2.6.0; extra == 'image-description'
+Requires-Dist: torchvision>=0.21.0; extra == 'image-description'
+Provides-Extra: local
+Requires-Dist: docling<3.0.0,>=2.36.1; (sys_platform != 'darwin' or platform_machine != 'x86_64') and extra == 'local'
+Requires-Dist: ocrmac>=1.0.0; (sys_platform == 'darwin') and extra == 'local'
+Requires-Dist: rapidocr-onnxruntime>=1.4.4; extra == 'local'
+Requires-Dist: tesserocr>=2.8.0; extra == 'local'
+Requires-Dist: torch>=2.6.0; extra == 'local'
+Requires-Dist: torchvision>=0.21.0; extra == 'local'
+Description-Content-Type: text/markdown
+
+# Docling Bundle
+
+Docling components for Langflow packaged as a standalone Extension Bundle.
+
+## Components
+
+- Docling
+- Docling Serve
+- Export DoclingDocument
+- Chunk DoclingDocument
+
+## Install
+
+The bundle is installed with Langflow in the 1.10 workspace. The base package includes `docling-core` for the `DoclingDocument` schema. For standalone local conversion:
+
+```bash
+uv pip install "lfx-docling[local]"
+```
+
+Chunking and picture-description support use separate optional extras. Chunking
+does not install the full local converter/OCR stack:
+
+```bash
+uv pip install "lfx-docling[chunking]"
+uv pip install "lfx-docling[image-description]"
+```
+
+## Develop
+
+```bash
+uv run lfx extension validate src/bundles/docling/src/lfx_docling
+uv run pytest src/bundles/docling/tests
+```

lfx_docling-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+lfx_docling/__init__.py,sha256=cCRwW1jLZX9BJ5oV9TXYYcYRuhlVDPVDqyPjZBlaBxk,566
+lfx_docling/extension.json,sha256=omS8BGiwJYDI-2zkjTeT1TLTH35ORLBas1ugmA_bdgI,362
+lfx_docling/components/docling/__init__.py,sha256=6xxVeK1DutDKS7vdiuF9XFGbd5yJ9M_ep2e_YYqa32I,386
+lfx_docling/components/docling/chunk_docling_document.py,sha256=9e8yUfXO4YHxjgBfb0Vm7cQ2XSFW4KPkgifrLu489Tc,9220
+lfx_docling/components/docling/docling_inline.py,sha256=ZdOLflUAEm_bbqnucA86jLzDci2ExCmvH9f9rK7ogQw,14833
+lfx_docling/components/docling/docling_remote.py,sha256=pE4ULahalE96hGkcedvEWRehWZmKJmZJUdbgkfMrUEk,13050
+lfx_docling/components/docling/export_docling_document.py,sha256=9gGsRKBQMNRQx8cSkWyhBSlQlC7vHt_z04t7fbWSIoM,5836
+lfx_docling-0.1.0.dist-info/METADATA,sha256=SlOPqGiirb0PkVqdOvnv0oPXspiFJO55tyKIo6Gy8Y4,3167
+lfx_docling-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+lfx_docling-0.1.0.dist-info/entry_points.txt,sha256=ZMFLxk5y0VG5SrHLjZeXSZSA1ceNypO23fDHeHLmDnc,48
+lfx_docling-0.1.0.dist-info/RECORD,,

lfx_docling-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

lfx_docling-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[langflow.extensions]
+lfx-docling = lfx_docling