feat: added firecrawl anydoc parser

app/core/constants.py

@@ -5,7 +5,7 @@ SUPPORTED_EXTENSIONS = {
     ".xlsx", ".xls", ".csv", ".json", ".xml",
     ".html", ".htm", ".txt", ".md", ".rst",
     ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp", ".tiff",
-    ".mp3", ".wav", ".ogg", ".flac",
+    ".mp3", ".wav",
     ".zip", ".epub",
 }
 
@@ -15,9 +15,26 @@ IMAGE_EXTENSIONS = {
 
 IMAGE_MIME_PREFIXES = {"image/"}
 
+# Formats processed by Firecrawl AnyDoc (local Rust engine).
+# Verified against anydoc.format_from_extension() for firecrawl-anydoc 0.1.8.
+ANYDOC_EXTENSIONS = frozenset({
+    ".pdf", ".docx", ".doc", ".docm",
+    ".pptx", ".ppt", ".pptm", ".pps", ".ppsx", ".ppsm", ".pot",
+    ".xlsx", ".xls", ".xlsm", ".xlsb",
+    ".odt", ".ods", ".odp", ".rtf", ".epub", ".csv",
+})
+
+# Formats AnyDoc cannot parse; these fall back to Microsoft MarkItDown:
+# html/htm, txt/md/rst, json/xml, zip, and audio (mp3/wav only — the
+# MarkItDown AudioConverter accepts .wav/.mp3/.m4a, not .ogg/.flac).
+MARKITDOWN_EXTENSIONS = frozenset({
+    ".json", ".xml", ".html", ".htm", ".txt", ".md", ".rst", ".zip",
+    ".mp3", ".wav",
+})
+
 TABULAR_EXTENSIONS = {".csv", ".xls", ".xlsx"}
 
-AUDIO_EXTENSIONS = {".mp3", ".wav", ".ogg", ".flac"}
+AUDIO_EXTENSIONS = {".mp3", ".wav"}
 
 DOCUMENT_EXTENSIONS = {".pdf", ".docx", ".doc", ".epub"}
 

app/services/converter_service.py

@@ -7,9 +7,14 @@ import time
 from pathlib import Path
 from urllib.parse import urlparse
 
+import anydoc
 from markitdown import MarkItDown
 
-from app.core.constants import IMAGE_EXTENSIONS, IMAGE_MIME_PREFIXES
+from app.core.constants import (
+    ANYDOC_EXTENSIONS,
+    IMAGE_EXTENSIONS,
+    IMAGE_MIME_PREFIXES,
+)
 from app.core.logger import get_logger
 from app.models.domain import ConversionError, ConversionResult
 from app.services.ocr_service import ocr_image, ocr_pdf
@@ -21,6 +26,14 @@ def _is_image(ext: str, mime: str) -> bool:
     return ext.lower() in IMAGE_EXTENSIONS or any(mime.startswith(p) for p in IMAGE_MIME_PREFIXES)
 
 
+def _fetch_url(url: str) -> bytes:
+    """Download *url* for engines that only accept local bytes (AnyDoc)."""
+    import httpx
+    resp = httpx.get(url, follow_redirects=True, timeout=30.0)
+    resp.raise_for_status()
+    return resp.content
+
+
 def _build_result(
     source: str,
     markdown: str,
@@ -45,6 +58,19 @@ def _build_result(
 
 
 class ConverterService:
+    """Converts documents to Markdown.
+
+    Routing is a static extension map — the extension decides the engine:
+
+    * ``ANYDOC_EXTENSIONS`` (pdf, doc/docx/docm, ppt/pptx/pptm/pps/ppsx/
+      ppsm/pot, xls/xlsx/xlsm/xlsb, odt/ods/odp, rtf, epub, csv)
+      -> Firecrawl AnyDoc. Scanned / image-only PDFs that AnyDoc cannot
+      read fall back to OCR.
+    * ``IMAGE_EXTENSIONS`` -> OCR.
+    * ``MARKITDOWN_EXTENSIONS`` (html/htm, txt/md/rst, json/xml, zip,
+      mp3/wav/ogg/flac) -> Microsoft MarkItDown.
+    """
+
     def __init__(self, enable_plugins: bool = False) -> None:
         kwargs: dict = {"enable_plugins": enable_plugins}
         self._engine = MarkItDown(**kwargs)
@@ -66,13 +92,7 @@ class ConverterService:
         mime_type = mime_type or "application/octet-stream"
 
         try:
-            if _is_image(path.suffix, mime_type):
-                markdown = ocr_image(str(path))
-            else:
-                markdown = self._engine.convert(str(path)).text_content
-                if not markdown.strip() and path.suffix.lower() == ".pdf":
-                    _logger.info("No text from PDF, falling back to OCR")
-                    markdown = ocr_pdf(str(path))
+            markdown = self._dispatch(path.suffix, mime_type, str(path))
             elapsed = (time.perf_counter() - start) * 1000
             return _build_result(str(path), markdown, file_size, mime_type, elapsed)
         except Exception as exc:
@@ -101,7 +121,11 @@ class ConverterService:
             if url_ext in IMAGE_EXTENSIONS:
                 markdown = ocr_image(url)
                 mime_type = mimetypes.guess_type(url)[0] or "image/jpeg"
+            elif url_ext in ANYDOC_EXTENSIONS:
+                markdown = self._convert_with_anydoc(_fetch_url(url), url_ext, url)
+                mime_type = mimetypes.guess_type(url)[0] or "application/octet-stream"
             else:
+                # HTML pages and other MarkItDown formats served over HTTP.
                 result = self._engine.convert(url)
                 markdown = result.text_content
                 mime_type = "text/html"
@@ -123,14 +147,7 @@ class ConverterService:
         ext = Path(filename).suffix.lower()
 
         try:
-            if _is_image(ext, mime_type):
-                markdown = ocr_image(data)
-            else:
-                result = self._engine.convert_stream(io.BytesIO(data), file_extension=ext)
-                markdown = result.text_content
-                if not markdown.strip() and ext == ".pdf":
-                    _logger.info("No text from PDF stream, falling back to OCR")
-                    markdown = ocr_pdf(data)
+            markdown = self._dispatch(ext, mime_type, data)
             elapsed = (time.perf_counter() - start) * 1000
             return _build_result(filename, markdown, len(data), mime_type, elapsed)
         except Exception as exc:
@@ -141,3 +158,66 @@ class ConverterService:
                 message=str(exc),
                 duration_ms=elapsed,
             )
+
+    # ------------------------------------------------------------------
+    # Internal routing — the static extension map lives here
+    # ------------------------------------------------------------------
+
+    def _dispatch(self, ext: str, mime_type: str, source) -> str:
+        """Route *source* to OCR, AnyDoc or MarkItDown based on extension.
+
+        ``source`` is a local path (convert_file) or raw bytes
+        (convert_stream). No engine is probed for routing decisions — the
+        extension fully determines the processor.
+        """
+        ext = ext.lower()
+
+        if _is_image(ext, mime_type):
+            return ocr_image(source)
+
+        if ext in ANYDOC_EXTENSIONS:
+            data = source if isinstance(source, bytes) else _read_bytes(source)
+            label = f"<{len(data)} bytes>" if isinstance(source, bytes) else str(source)
+            return self._convert_with_anydoc(data, ext, label)
+
+        if isinstance(source, bytes):
+            result = self._engine.convert_stream(io.BytesIO(source), file_extension=ext)
+        else:
+            result = self._engine.convert(str(source))
+        return result.text_content
+
+    def _convert_with_anydoc(self, data: bytes, ext: str, source_label: str) -> str:
+        """Convert bytes with Firecrawl AnyDoc.
+
+        PDFs get a special path: scanned / image-only PDFs carry no text
+        operators, so AnyDoc raises ``anydoc.UnsupportedError`` — that is
+        the documented signal to fall back to OCR.
+        """
+        if ext == ".pdf":
+            try:
+                markdown = self._anydoc_to_markdown(data, ext)
+            except anydoc.UnsupportedError as exc:
+                _logger.info(
+                    "Scanned PDF rejected by anydoc, falling back to OCR | source=%s | error=%s",
+                    source_label,
+                    exc,
+                )
+                markdown = ""
+            if not markdown.strip():
+                _logger.info("PDF text empty, falling back to OCR | source=%s", source_label)
+                markdown = ocr_pdf(data)
+            return markdown
+        return self._anydoc_to_markdown(data, ext)
+
+    @staticmethod
+    def _anydoc_to_markdown(data: bytes, ext: str) -> str:
+        """Canonical-format name for the extension, then AnyDoc conversion."""
+        fmt = anydoc.format_from_extension(ext)
+        if fmt is None:
+            raise ValueError(f"Unsupported file extension: {ext}")
+        return anydoc.to_markdown_bytes(data, fmt)
+
+
+def _read_bytes(source: str | Path) -> bytes:
+    with open(source, "rb") as fh:
+        return fh.read()

pyproject.toml

@@ -11,7 +11,8 @@ requires-python = ">=3.10"
 license = { text = "MIT" }
 
 dependencies = [
-    "markitdown[all]>=0.1.5",
+    "markitdown[audio-transcription]>=0.1.5",
+    "firecrawl-anydoc>=0.1.8",
     "fastapi>=0.111",
     "uvicorn[standard]>=0.30",
     "pydantic>=2.7",

requirements.txt

@@ -20,7 +20,10 @@ pypdfium2==4.30.0
 # in app/services/ocr_service.py (enables easy rollback).
 rapidocr-onnxruntime==1.4.4
 onnxruntime==1.20.1
-markitdown[all]==0.1.5
+# MarkItDown handles the formats AnyDoc cannot parse: html/htm, txt/md/rst,
+# json/xml, zip (all in the base install) and audio transcription (extra).
+markitdown[audio-transcription]==0.1.5
+firecrawl-anydoc>=0.1.8
 
 # --- OCR: PaddleOCR PP-OCRv6 Small on ONNX Runtime ---
 # PaddleOCR 3.7.0 ships the PP-OCRv6 model family (tiny/small/medium). The

start.sh

@@ -58,10 +58,11 @@ mkdir -p /app/data /app/logs
 log "Data directories: OK"
 
 # Check core deps
-python -c "import markitdown, fastapi, httpx, pandas" 2>/dev/null
+python -c "import markitdown, anydoc, fastapi, httpx, pandas" 2>/dev/null
 if [ $? -ne 0 ]; then
     log "ERROR: Missing core dependencies"
     python -c "import markitdown" 2>&1 | log
+    python -c "import anydoc" 2>&1 | log
     python -c "import fastapi" 2>&1 | log
     python -c "import httpx" 2>&1 | log
     python -c "import pandas" 2>&1 | log