Download Model

Saat pertama kali dijalankan, Marker akan otomatis mendownload model yang diperlukan dari Hugging Face. Model-model ini termasuk:

• Model deteksi layout
• Model OCR (Surya)
• Model pengenalan tabel
• Model konversi rumus matematika

Total ukuran model sekitar 2-3 GB. Pastikan koneksi internet stabil saat pertama kali menjalankan.

Basic Usage

Konversi File Tunggal via CLI

Marker menyediakan command-line interface yang mudah digunakan:

Contoh Output

Misalnya Anda memiliki PDF laporan keuangan dengan tabel. Marker akan menghasilkan output seperti:

# Laporan Keuangan Q1 2026

Ringkasan Pendapatan

| Kategori | Q1 2025 | Q1 2026 | Pertumbuhan |
|----------|---------|---------|-------------|
| Produk A | Rp 500M | Rp 750M | 50% |
| Produk B | Rp 300M | Rp 420M | 40% |
| Total | Rp 800M | Rp 1.17T | 46% |

Pendapatan perusahaan meningkat sebesar 46% year-over-year...

Perhatikan bagaimana tabel dikonversi dengan rapi ke format Markdown, lengkap dengan alignment.

Konfigurasi Lanjutan

Mengatur Parameter Konversi

Marker menyediakan berbagai parameter untuk mengontrol proses konversi:

Advanced Usage

Integrasi dengan Pipeline RAG

Salah satu use case utama Marker adalah menyiapkan dokumen untuk pipeline RAG. Berikut contoh integrasi dengan LangChain:

import os
import json
import time
from marker.converters.pdf import PdfConverter
from marker.models import createmodeldict

from marker.output import textfromrendered


def batchconvertwithmonitoring(
    inputfolder: str,

    outputfolder: str,
    logfile: str = "conversionlog.json"
):
    """Batch convert dengan logging dan error handling."""
    os.makedirs(outputfolder, existok=True)

    converter = PdfConverter(
        artifactdict=createmodeldict(),

    )

    pdffiles = [f for f in os.listdir(inputfolder) if f.endswith(".pdf")]

    total = len(pdffiles)
    results = []

    print(f"Memproses {total} dokumen...")

    for i, filename in enumerate(pdffiles, 1):

        filepath = os.path.join(inputfolder, filename)
        starttime = time.time()


        try:
            rendered = converter(filepath)
            text, metadata, images = textfromrendered(rendered)


            # Simpan output Markdown
            outputname = filename.replace(".pdf", ".md")
            outputpath = os.path.join(outputfolder, outputname)


            with open(outputpath, "w", encoding="utf-8") as f:
                f.write(text)

            # Simpan gambar jika ada
            if images:
                imgfolder = os.path.join(

                    outputfolder,
                    filename.replace(".pdf", "images")

                )
                os.makedirs(imgfolder, existok=True)

                for imgname, imgdata in images.items():

                    imgpath = os.path.join(imgfolder, imgname)
                    with open(imgpath, "wb") as f:

                        f.write(imgdata)

            elapsed = time.time() - starttime

            result = {
                "file": filename,
                "status": "success",
                "output": outputpath,
                "pages": metadata.get("pages", 0),
                "timeseconds": round(elapsed, 2),

                "imagesextracted": len(images) if images else 0
            }

            print(f"[{i}/{total}] OK: {filename} ({elapsed:.1f}s)")

        except Exception as e:
            elapsed = time.time() - starttime

            result = {
                "file": filename,
                "status": "error",
                "error": str(e),
                "timeseconds": round(elapsed, 2)
            }
            print(f"[{i}/{total}] ERROR: {filename} - {e}")

        results.append(result)

    # Simpan log
    with open(logfile, "w") as f:

        json.dump(results, f, indent=2)

    success = sum(1 for r in results if r["status"] == "success")
    print(f"\nSelesai: {success}/{total} berhasil dikonversi")
    print(f"Log disimpan ke: {logfile}")

    return results

Jalankan
results = batchconvertwithmonitoring(

    inputfolder="./pdfdocuments",

    outputfolder="./markdownoutput"

)

import os
import tempfile
from fastapi import FastAPI, UploadFile, File, HTTPException
from fastapi.responses import JSONResponse
from marker.converters.pdf import PdfConverter
from marker.models import createmodeldict

from marker.output import textfromrendered


app = FastAPI(title="Marker PDF Converter API")

converter = None

@app.onevent("startup")
async def loadmodels():

    global converter
    converter = PdfConverter(
        artifactdict=createmodeldict(),
    )

@app.post("/convert")
async def convertpdf(file: UploadFile = File(...)):

    """Konversi PDF ke Markdown."""
    if not file.filename.endswith((".pdf", ".epub", ".mobi")):
        raise HTTPException(
            statuscode=400,
            detail="Format file tidak didukung. Gunakan PDF, EPUB, atau MOBI."
        )

    with tempfile.NamedTemporaryFile(
        suffix=os.path.splitext(file.filename)[1],
        delete=False
    ) as tmp:
        content = await file.read()
        tmp.write(content)
        tmppath = tmp.name


    try:
        rendered = converter(tmppath)
        text, metadata, images = textfromrendered(rendered)

        return JSONResponse({
            "filename": file.filename,
            "markdown": text,
            "metadata": metadata,
            "imagescount": len(images) if images else 0

        })
    except Exception as e:
        raise HTTPException(statuscode=500, detail=str(e))
    finally:
        os.unlink(tmppath)


@app.get("/health")
async def health():
    return {"status": "ok", "modelloaded": converter is not None}

Jalankan server:

pip install fastapi uvicorn python-multipart
uvicorn markerapi:app --host 0.0.0.0 --port 8000

curl -X POST http://localhost:8000/convert \
  -F "file=@document.pdf" \
  | python -m json.tool

import time

def compareextraction(pdfpath: str):

    """Bandingkan hasil ekstraksi berbagai tools."""

    # Marker
    from marker.converters.pdf import PdfConverter
    from marker.models import createmodeldict

    from marker.output import textfromrendered


    start = time.time()
    converter = PdfConverter(artifactdict=createmodeldict())
    rendered = converter(pdfpath)

    markertext, ,  = textfromrendered(rendered)
    markertime = time.time() - start


    # PyPDF2
    from PyPDF2 import PdfReader

    start = time.time()
    reader = PdfReader(pdfpath)
    pypdftext = ""

    for page in reader.pages:
        pypdftext += page.extracttext() or ""

    pypdftime = time.time() - start

    # pdfminer
    from pdfminer.highlevel import extracttext

    start = time.time()
    pdfminertext = extracttext(pdfpath)

    pdfminertime = time.time() - start

    print("=== Perbandingan Hasil ===")
    print(f"Marker    : {len(markertext)} chars, {markertime:.2f}s")
    print(f"PyPDF2    : {len(pypdftext)} chars, {pypdftime:.2f}s")
    print(f"pdfminer  : {len(pdfminertext)} chars, {pdfminertime:.2f}s")
    print()
    print("--- Marker Output (first 500 chars) ---")
    print(markertext[:500])

    print()
    print("--- PyPDF2 Output (first 500 chars) ---")
    print(pypdftext[:500])

compareextraction("complexreport.pdf")

Best Practices

1. Optimasi Memori untuk Dokumen Besar

Saat memproses dokumen besar (ratusan halaman), perhatikan penggunaan memori:

import gc
import torch

def processlargedocument(pdfpath: str, batchsize: int = 20):
    """Proses dokumen besar per batch halaman."""
    from marker.converters.pdf import PdfConverter
    from marker.models import createmodeldict
    from marker.output import textfromrendered
    import fitz  # PyMuPDF

    doc = fitz.open(pdfpath)

    totalpages = len(doc)
    doc.close()

    alltext = []

    converter = PdfConverter(artifactdict=createmodeldict())

    for start in range(0, totalpages, batchsize):
        end = min(start + batchsize, totalpages)
        rendered = converter(pdfpath, pagerange=[start, end])
        text, ,  = textfromrendered(rendered)
        alltext.append(text)


        gc.collect()
        if torch.cuda.isavailable():
            torch.cuda.emptycache()


    return "\n\n".join(alltext)

2. Caching Hasil Konversi

Hindari konversi ulang dokumen yang sama:

import hashlib
import json
import os

CACHEDIR = "./markercache"

def getfilehash(filepath: str) -> str:
    """Hitung hash SHA256 dari file."""
    sha256 = hashlib.sha256()
    with open(filepath, "rb") as f:
        for chunk in iter(lambda: f.read(8192), b""):
            sha256.update(chunk)
    return sha256.hexdigest()

def convertwithcache(pdfpath: str) -> str:

    """Konversi dengan caching berbasis hash file."""
    os.makedirs(CACHEDIR, existok=True)

    filehash = getfilehash(pdfpath)

    cachepath = os.path.join(CACHEDIR, f"{filehash}.json")

    if os.path.exists(cachepath):

        with open(cachepath, "r") as f:
            cached = json.load(f)
        print(f"Cache hit: {pdfpath}")

        return cached["text"]

    from marker.converters.pdf import PdfConverter
    from marker.models import createmodeldict

    from marker.output import textfromrendered


    converter = PdfConverter(artifactdict=createmodeldict())
    rendered = converter(pdfpath)

    text, metadata,  = textfromrendered(rendered)

    with open(cachepath, "w") as f:

        json.dump({"text": text, "metadata": metadata}, f)

    print(f"Converted and cached: {pdfpath}")
    return text

3. Validasi Output

Selalu validasi kualitas output sebelum menggunakannya:

def validateconversion(text: str, minlength: int = 100) -> dict:
    """Validasi kualitas hasil konversi."""
    issues = []

    if len(text) < minlength:

        issues.append(f"Teks terlalu pendek ({len(text)} chars)")

    lines = text.split("\n")
    emptyratio = sum(1 for l in lines if not l.strip()) / max(len(lines), 1)
    if emptyratio > 0.7:

        issues.append(f"Terlalu banyak baris kosong ({emptyratio:.0%})")

    garbled = sum(1 for c in text if ord(c) > 65535) / max(len(text), 1)
    if garbled > 0.05:
        issues.append(f"Kemungkinan karakter rusak ({garbled:.1%})")

    tablecount = text.count("|---|")

    headingcount = text.count("\n#")

    return {
        "valid": len(issues) == 0,
        "issues": issues,
        "stats": {
            "length": len(text),
            "lines": len(lines),
            "tables": tablecount,

            "headings": headingcount,
            "emptylineratio": round(emptyratio, 2)

        }
    }