pdf-inspector 완전 가이드: Firecrawl 오픈소스 Rust 고성능 PDF 파싱 엔진

[dependencies]
pdf-inspector = "0.2"

cargo add pdf-inspector

pip install maturin
git clone https://github.com/firecrawl/pdf-inspector.git
cd pdf-inspector
maturin develop --release

npm install @firecrawl/pdf-inspector

npm install @firecrawl/pdf-inspector-wasm

import pdf_inspector

# 단일 PDF 파일 처리
result = pdf_inspector.process_pdf("document.pdf")

# PDF 유형 분류 확인
print(f"PDF 유형: {result.pdf_type}")
# 출력: "text_based", "scanned", "image_based", 또는 "mixed"

# 마크다운 출력 확인
if result.markdown:
    print(result.markdown)

const { processPdf } = require('@firecrawl/pdf-inspector');
const fs = require('fs');

async function analyzePdf(filePath) {
  const pdfBuffer = fs.readFileSync(filePath);
  const result = await processPdf(pdfBuffer);

  console.log('PDF 유형:', result.pdfType);
  console.log('신뢰도:', result.confidence);
  console.log('--- 마크다운 출력 ---');
  console.log(result.markdown);
}

analyzePdf('report.pdf');

use pdf_inspector::{PdfInspector, ProcessPdfResult};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let inspector = PdfInspector::new();
    let result: ProcessPdfResult = inspector.process_pdf_path("document.pdf")?;

    println!("PDF 유형: {:?}", result.pdf_type);
    println!("신뢰도: {:.2}", result.confidence);

    if let Some(markdown) = result.markdown {
        println!("Markdown:\n{}", markdown);
    }

    Ok(())
}

import pdf_inspector
# 자체 OCR 함수가 있다고 가정
def smart_pdf_pipeline(pdf_path, ocr_function):
    result = pdf_inspector.process_pdf(pdf_path)

    if result.pdf_type == "text_based":
        # 원본 텍스트, 직접 추출 — 빠르고, 무료이며, 정확함
        print("✅ 원본 텍스트 PDF, 직접 추출")
        return result.markdown

    elif result.pdf_type == "scanned":
        # 스캔본, OCR 호출
        print("🔍 스캔본 PDF, OCR 호출")
        return ocr_function(pdf_path)

    elif result.pdf_type == "mixed":
        # 혼합형 — 페이지별 처리
        print("📄 혼합형 PDF, 페이지별 라우팅")
        pages = []
        for page_info in result.page_results:
            if page_info.needs_ocr:
                pages.append(ocr_function_for_page(pdf_path, page_info.page_number))
            else:
                pages.append(page_info.markdown)
        return "\n\n".join(pages)

    else:
        # 순수 이미지형, 텍스트 추출 불가
        print("❌ 이미지형 PDF, 텍스트 추출 불가")
        return None

# Deep Learning Approaches for Natural Language Processing

## 1. Introduction

Natural language processing (NLP) has seen remarkable progress in recent years...

### 1.1 Background

The transformer architecture, introduced by Vaswani et al., has become...

## 2. Methodology

| Model | BLEU Score | Training Time |
|-------|-----------|---------------|
| Transformer | 38.2 | 12 hours |
| BERT | 41.0 | 24 hours |
| GPT-4 | 45.7 | 72 hours |

## 3. Results

The experimental results demonstrate...

> **Note:** All experiments were conducted on...

result = pdf_inspector.process_pdf("newspaper.pdf")

# pdf-inspector가 자동으로 2컬럼/3컬럼 레이아웃 감지
# 위에서 아래로, 왼쪽에서 오른쪽으로 올바른 순서로 출력
print(result.markdown)

# pdf_service.py
import os
import json
from datetime import datetime
import pdf_inspector

class PdfProcessingService:
    def __init__(self, output_dir="./processed"):
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)

    def process_batch(self, pdf_files):
        """PDF 파일 배치 처리"""
        results = []
        for pdf_path in pdf_files:
            result = self.process_single(pdf_path)
            results.append(result)
        return results

    def process_single(self, pdf_path):
        """단일 PDF 파일 처리"""
        filename = os.path.basename(pdf_path)
        pdf_result = pdf_inspector.process_pdf(pdf_path)

        # 메타정보 추출
        metadata = {
            "filename": filename,
            "pdf_type": pdf_result.pdf_type,
            "confidence": pdf_result.confidence,
            "processed_at": datetime.now().isoformat(),
            "pages_count": len(pdf_result.page_results) if hasattr(pdf_result, 'page_results') else 0,
            "needs_ocr": pdf_result.pdf_type in ("scanned", "image_based"),
        }

        # 마크다운 출력 저장
        if pdf_result.markdown:
            md_filename = filename.replace(".pdf", ".md")
            md_path = os.path.join(self.output_dir, md_filename)
            with open(md_path, "w", encoding="utf-8") as f:
                f.write(pdf_result.markdown)
            metadata["markdown_path"] = md_path

        # 메타정보 저장
        meta_path = os.path.join(
            self.output_dir,
            filename.replace(".pdf", ".meta.json")
        )
        with open(meta_path, "w", encoding="utf-8") as f:
            json.dump(metadata, f, ensure_ascii=False, indent=2)

        return metadata

# 사용 예시
service = PdfProcessingService(output_dir="./output")

# 배치 처리
pdf_files = [
    "contracts/contract_2026_001.pdf",
    "invoices/invoice_aug_2026.pdf",
    "reports/q2_financial_report.pdf",
]

results = service.process_batch(pdf_files)
for r in results:
    status = "OCR 필요" if r["needs_ocr"] else "직접 추출 완료"
    print(f"{r['filename']}: {r['pdf_type']} ({status})")

import pdf_inspector
# OpenAI 호환 API 사용 가정
from openai import OpenAI

def analyze_pdf_with_llm(pdf_path, prompt="이 문서의 주요 내용을 요약해 주세요"):
    """LLM으로 PDF 분석"""
    # 1. pdf-inspector로 마크다운 추출
    result = pdf_inspector.process_pdf(pdf_path)

    if not result.markdown:
        return "텍스트 콘텐츠를 추출할 수 없습니다. OCR이 필요할 수 있습니다."

    # 2. 문서가 너무 길면 앞 8000자로 자르기
    markdown_content = result.markdown[:8000]

    # 3. LLM 호출 분석
    client = OpenAI(api_key="YOUR_API_KEY")
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "당신은 문서 분석 도우미입니다."},
            {"role": "user", "content": f"다음 문서 내용을 바탕으로 {prompt}:\n\n{markdown_content}"}
        ]
    )

    return response.choices[0].message.content

# 사용
summary = analyze_pdf_with_llm("annual_report.pdf", "핵심 재무 지표를 추출해 주세요")
print(summary)