อินเทอร์เฟซบรรทัดคำสั่งสำหรับ Python

อินเทอร์เฟซบรรทัดคำสั่งสำหรับ Python

ใช้คำสั่ง nextpdf เพื่อแยกเนื้อหาจากไฟล์ Portable Document Format (PDF) ในเทอร์มินัล ระบุเอนด์พอยต์ NextPDF Connect ให้คำสั่ง ส่งไฟล์ PDF เข้าไป แล้วรับเอาต์พุตแบบมีโครงสร้าง เช่น ข้อความพร้อมการอ้างอิง ตาราง Abstract Syntax Tree (AST) เชิงความหมายฉบับเต็ม หรือสรุปข้อมูลเมตา ผ่านเอาต์พุตมาตรฐาน (stdout) หรือไฟล์

โครงสร้างคำสั่ง

คำสั่ง nextpdf เป็นกลุ่มคำสั่ง Click ตัวเลือกสำหรับการเชื่อมต่อและเซสชัน เช่น --base-url, --api-key, --log-level, --output/-o และ --strict อยู่ในระดับกลุ่ม จึงต้องวางไว้ก่อนคำสั่งย่อย แล้วจึงวางคำสั่งย่อยและตัวเลือกของคำสั่งนั้น เช่น --format หรือ --page ไว้ภายหลัง:

nextpdf [GROUP OPTIONS] COMMAND [SUBCOMMAND] PDF_PATH [COMMAND OPTIONS]

หากวางตัวเลือกของกลุ่มไว้หลังคำสั่งย่อย คำสั่งจะล้มเหลว ตัวอย่างเช่น nextpdf info document.pdf --base-url ... จะรายงาน Error: No such option: --base-url และออกด้วยสถานะ 2 เพราะเมื่อ Click พบ --base-url ระบบกำลังแยกวิเคราะห์คำสั่งย่อย info อยู่แล้ว และ info ไม่ได้กำหนดตัวเลือกนั้นไว้

เพื่อหลีกเลี่ยงปัญหาจากลำดับตัวเลือก ให้ระบุข้อมูลรับรองผ่านตัวแปรสภาพแวดล้อม (ดู กำหนดค่าครั้งเดียวต่อเชลล์) ตัวอย่างด้านล่างแสดงรูปแบบที่ระบุแฟล็กอย่างชัดเจนไว้ก่อน เพื่อให้เห็นลำดับที่ถูกต้อง

ข้อมูลอ้างอิงโดยย่อ

แยกข้อความเป็น JavaScript Object Notation (JSON):

nextpdf --base-url http://localhost:8080 --api-key "$NEXTPDF_API_KEY" extract text document.pdf

แยกตารางเป็นค่าที่คั่นด้วยจุลภาค (CSV):

nextpdf --base-url http://localhost:8080 --api-key "$NEXTPDF_API_KEY" extract tables invoice.pdf --format csv

ตรวจสอบข้อมูลเมตาและโครงสร้างของเอกสาร:

nextpdf --base-url http://localhost:8080 --api-key "$NEXTPDF_API_KEY" info document.pdf

รับ AST เชิงความหมายฉบับเต็ม:

nextpdf --base-url http://localhost:8080 --api-key "$NEXTPDF_API_KEY" ast document.pdf

พิมพ์เวอร์ชันของชุดพัฒนาซอฟต์แวร์ (SDK) ที่ติดตั้งไว้ โดยไม่ต้องติดต่อเซิร์ฟเวอร์:

nextpdf version

คำสั่ง version เป็นคำสั่งเดียวที่ไม่ต้องใช้ทั้ง --base-url และ --api-key คำสั่งอื่นทั้งหมดจะติดต่อเซิร์ฟเวอร์และต้องใช้ทั้งสองค่า

แต่ละตัวอย่างอ่านคีย์ API จากตัวแปรสภาพแวดล้อม NEXTPDF_API_KEY แทนการฝังค่าไว้บนบรรทัดคำสั่ง ให้ถือว่าคีย์เป็นความลับเสมอ คีย์ที่ปรากฏตรงๆ บนบรรทัดคำสั่งจะมองเห็นได้ในประวัติเชลล์ของคุณ และผู้ใช้อื่นบนโฮสต์อาจเห็นได้จากรายการกระบวนการ (ps)

คำสั่งและตัวเลือก

ตัวเลือกของกลุ่ม

วางตัวเลือกเหล่านี้ไว้ก่อนคำสั่งย่อย ตัวเลือกการเชื่อมต่อแต่ละตัวยังอ่านค่าจากตัวแปรสภาพแวดล้อมได้ด้วย คุณจึงละแฟล็กได้เมื่อมีการตั้งค่าตัวแปรไว้แล้ว

ตัวเลือก	ตัวแปรสภาพแวดล้อม	ค่าเริ่มต้น	วัตถุประสงค์
--base-url	NEXTPDF_BASE_URL	(จำเป็นต้องระบุ)	NextPDF Connect — ตัวระบุตำแหน่งทรัพยากร (URL) ของเซิร์ฟเวอร์
--api-key	NEXTPDF_API_KEY	(จำเป็นต้องระบุ)	คีย์ API สำหรับการตรวจสอบสิทธิ์แบบ bearer
--log-level	—	warning	ระดับความละเอียดของบันทึก: debug, info, warning หรือ error บันทึกจะส่งไปยังข้อผิดพลาดมาตรฐาน (stderr)
--output, -o	—	stdout	เขียนเอาต์พุตของคำสั่งไปยังไฟล์แทน stdout
--strict	—	ปิด	สงวนไว้สำหรับการใช้งานในอนาคต ปัจจุบันแฟล็กนี้แยกวิเคราะห์ได้ แต่ยังไม่เปลี่ยนพฤติกรรมการทำงาน
--help, -h	—	—	แสดงความช่วยเหลือและออก

ต้องระบุค่า --base-url และ --api-key สำหรับทุกคำสั่ง ยกเว้น version หากขาดค่าใดค่าหนึ่ง ไม่ว่าจะเป็นแฟล็กหรือตัวแปรสภาพแวดล้อม คำสั่งจะพิมพ์ข้อผิดพลาดและออกด้วยสถานะ 1

nextpdf extract text

แยกบล็อกข้อความพร้อมการอ้างอิง แต่ละบล็อกมีจุดยึดการอ้างอิงพร้อมตัวระบุโหนด ดัชนีหน้า กรอบขอบเขต และคะแนนความเชื่อมั่น

nextpdf [GROUP OPTIONS] extract text PDF_PATH [--format FORMAT] [--page N] [--headings-only]

ตัวเลือก	ค่า	ค่าเริ่มต้น	วัตถุประสงค์
--format	json, markdown, plain	json	รูปแบบเอาต์พุต
--page	จำนวนเต็ม	ทุกหน้า	แยกเฉพาะดัชนีหน้าแบบเริ่มจาก 0 นี้
--headings-only	แฟล็ก	ปิด	แยกเฉพาะโหนดหัวข้อ

PDF_PATH คือพาธของไฟล์ หรือ - สำหรับอ่านไบต์ PDF จากอินพุตมาตรฐาน (stdin)

nextpdf extract tables

แยกตารางทั้งหมดพร้อมจุดยึดการอ้างอิงและโครงสร้างระดับเซลล์

nextpdf [GROUP OPTIONS] extract tables PDF_PATH [--format FORMAT] [--page-start N] [--page-end N]

ตัวเลือก	ค่า	ค่าเริ่มต้น	วัตถุประสงค์
--format	json, csv	json	รูปแบบเอาต์พุต
--page-start	จำนวนเต็ม	หน้าแรก	ดัชนีหน้าเริ่มต้น (เริ่มจาก 0)
--page-end	จำนวนเต็ม	หน้าสุดท้าย	ดัชนีหน้าสิ้นสุด (เริ่มจาก 0)

PDF_PATH คือพาธของไฟล์ หรือ - สำหรับอ่านจาก stdin

nextpdf ast

คืนค่า AST เชิงความหมายฉบับเต็มเป็น JSON: ต้นไม้ของโหนดแบบลำดับชั้นที่ประกอบด้วยหัวข้อ ย่อหน้า ตาราง รายการ และรูปภาพ พร้อมกรอบขอบเขตและเนื้อหาข้อความ

nextpdf [GROUP OPTIONS] ast PDF_PATH [--page-start N] [--page-end N] [--token-budget N]

ตัวเลือก	ค่า	ค่าเริ่มต้น	วัตถุประสงค์
--page-start	จำนวนเต็ม	หน้าแรก	ดัชนีหน้าเริ่มต้น (เริ่มจาก 0)
--page-end	จำนวนเต็ม	หน้าสุดท้าย	ดัชนีหน้าสิ้นสุด (เริ่มจาก 0)
--token-budget	จำนวนเต็ม	ไม่จำกัด	ขีดจำกัดโทเค็นโดยประมาณสำหรับ AST ที่คืนค่า

PDF_PATH คือพาธของไฟล์ หรือ - สำหรับอ่านจาก stdin คำสั่ง ast สร้างต้นไม้เอกสารหนึ่งต้น ไม่ได้เปรียบเทียบ PDF สองไฟล์ สำหรับการเปรียบเทียบเชิงโครงสร้าง ดู สูตร: เปรียบเทียบความต่างของ PDF สองรุ่น ประกอบ

nextpdf info

พิมพ์สรุป JSON แบบกะทัดรัดของเอกสารหนึ่งฉบับ: เวอร์ชันสคีมา แฮชต้นทาง จำนวนหน้า จำนวนโทเค็นโดยประมาณ ประเภทโหนดราก และจำนวนโหนดลูกของราก

nextpdf [GROUP OPTIONS] info PDF_PATH

PDF_PATH คือพาธของไฟล์ หรือ - สำหรับอ่านจาก stdin

nextpdf version

พิมพ์เวอร์ชัน SDK ที่ติดตั้งไว้ เช่น nextpdf 1.1.0 แล้วออก คำสั่งนี้ไม่ติดต่อเซิร์ฟเวอร์ใดๆ และไม่ต้องใช้ข้อมูลรับรอง

nextpdf version

กำหนดค่าครั้งเดียวต่อเชลล์

ตั้งค่าตัวเลือกการเชื่อมต่อเป็นตัวแปรสภาพแวดล้อมครั้งเดียว แล้วละแฟล็กที่ต้องระบุซ้ำได้ รูปแบบนี้ยังหลีกเลี่ยงปัญหาจากลำดับตัวเลือกได้ทั้งหมด เพราะข้อมูลรับรองจะไม่ปรากฏบนบรรทัดคำสั่ง

export NEXTPDF_BASE_URL=http://localhost:8080
export NEXTPDF_API_KEY=your-key
nextpdf extract text document.pdf

บน Windows PowerShell:

$env:NEXTPDF_BASE_URL = "http://localhost:8080"
$env:NEXTPDF_API_KEY = "your-key"
nextpdf extract text document.pdf

ควรโหลดคีย์จากที่เก็บความลับหรือไฟล์ .env ที่เก็บไว้นอกระบบควบคุมเวอร์ชัน อย่าวางคีย์สำหรับใช้งานจริงไว้ในเซสชันเทอร์มินัลที่ใช้ร่วมกัน หรือในสคริปต์ที่คุณคอมมิต

รูปแบบเอาต์พุต

เลือกรูปแบบเอาต์พุตของแต่ละคำสั่งด้วย --format คำสั่ง text และ table รองรับหลายรูปแบบ ส่วน ast และ info ส่งออกเป็น JSON เสมอ

คำสั่ง	รูปแบบ	ค่าเริ่มต้น
extract text	json, markdown, plain	json
extract tables	json, csv	json
ast	json	json
info	json	json

เลือก JSON เมื่อโปรแกรมปลายทางต้องการดัชนีหน้า คะแนนความเชื่อมั่น หรือตัวระบุโหนด เลือก CSV เมื่อสเปรดชีตหรือไปป์ไลน์แบบตารางต้องใช้ข้อมูลตาราง เลือกข้อความแบบ plain หรือ markdown เมื่อผู้อ่านผลลัพธ์เป็นบุคคลหรือเครื่องมือที่อ่านได้เฉพาะข้อความ

การแยกวิเคราะห์เอาต์พุต JSON

คำสั่ง text ส่งออกอาร์เรย์ JSON ของบล็อกพร้อมการอ้างอิง แต่ละบล็อกมี text ออบเจกต์ citation (node_id, page_index, bbox, confidence) และ node_type ที่เป็นทางเลือก ส่งเอาต์พุตไปยังไฟล์ด้วย --output หรือเปลี่ยนทิศทาง stdout แล้วจึงแยกวิเคราะห์

ตัวอย่างเชลล์นี้ใช้ jq เพื่อเก็บเฉพาะหัวข้อบนหน้า 0:

nextpdf --output blocks.json extract text report.pdf --format json
jq '[.[] | select(.citation.page_index == 0 and .node_type == "heading") | .text]' blocks.json

ข้อมูลเดียวกันสามารถแยกวิเคราะห์ใน Python ได้อย่างเป็นระเบียบ อินเทอร์เฟซบรรทัดคำสั่ง (CLI) เขียนอาร์เรย์ JSON ออกมา ดังนั้นให้โหลดด้วยไลบรารีมาตรฐานและอ่านฟิลด์ที่กำหนดชนิดไว้:

"""Parse cited text blocks emitted by `nextpdf extract text --format json`."""

import json
from pathlib import Path


def load_headings(blocks_path: Path) -> list[str]:
    """Return the text of every heading block on page 0.

    Args:
        blocks_path: Path to the JSON file written by `nextpdf extract text`.

    Returns:
        The text of each heading-type block whose citation is on page 0.
    """
    raw = blocks_path.read_text(encoding="utf-8")
    blocks: list[dict[str, object]] = json.loads(raw)
    headings: list[str] = []
    for block in blocks:
        citation = block["citation"]
        if block.get("node_type") == "heading" and citation["page_index"] == 0:
            headings.append(str(block["text"]))
    return headings


if __name__ == "__main__":
    for heading in load_headings(Path("blocks.json")):
        print(heading)

เมื่อต้องการโมเดลที่ตรวจสอบความถูกต้องได้และมีการกำหนดชนิด แทนการใช้พจนานุกรมดิบ ให้เรียก SDK โดยตรงแทนการแยกวิเคราะห์เอาต์พุตของ CLI ดู ภาพรวม Python สำหรับไคลเอนต์ NextPDF และชนิดคืนค่า CitedTextBlock ของไคลเอนต์

การแยกวิเคราะห์เอาต์พุต CSV

เมื่อใช้ --format csv คำสั่ง table จะเขียนบล็อก CSV หนึ่งบล็อกต่อหนึ่งตาราง แถวคอมเมนต์ # Table N (pM) จะอยู่ก่อนแต่ละตาราง และระบุหมายเลขตารางแบบเริ่มจาก 1 กับดัชนีหน้าแบบเริ่มจาก 0 บรรทัดว่างจะคั่นระหว่างตารางที่ต่อเนื่องกัน CLI จะใส่เครื่องหมายคำพูดและ escape ค่าของเซลล์ด้วยโมดูล csv ของ Python ดังนั้นค่าที่มีจุลภาค เครื่องหมายคำพูด หรือบรรทัดใหม่จะรับส่งไปมาได้อย่างปลอดภัย

nextpdf --output tables.csv extract tables statement.pdf --format csv

เนื่องจากไฟล์มีบล็อก CSV หลายบล็อก ให้แยกไฟล์ตามแถวคอมเมนต์ก่อน แล้วจึงแยกวิเคราะห์แต่ละบล็อกเป็นตารางเดี่ยว:

"""Split multi-table CSV output from `nextpdf extract tables --format csv`."""

import csv
import io
from pathlib import Path


def read_tables(csv_path: Path) -> list[list[list[str]]]:
    """Parse the multi-block CSV file into a list of tables.

    Each table is a list of rows; each row is a list of cell strings.
    The leading `# Table N (pM)` comment row is dropped from every table.

    Args:
        csv_path: Path to the file written by `nextpdf extract tables`.

    Returns:
        One parsed table per `# Table` block in the file.
    """
    text = csv_path.read_text(encoding="utf-8")
    tables: list[list[list[str]]] = []
    current: list[str] = []
    for line in text.splitlines(keepends=True):
        if line.startswith("# Table ") and current:
            tables.append(_parse_block(current))
            current = []
        current.append(line)
    if current:
        tables.append(_parse_block(current))
    return tables


def _parse_block(lines: list[str]) -> list[list[str]]:
    """Parse one CSV block, discarding its leading comment row."""
    reader = csv.reader(io.StringIO("".join(lines)))
    rows = [row for row in reader if row]
    return rows[1:] if rows and rows[0] and rows[0][0].startswith("# Table ") else rows


if __name__ == "__main__":
    for index, table in enumerate(read_tables(Path("tables.csv")), start=1):
        print(f"table {index}: {len(table)} rows")

รหัสการออกและการตรวจจับข้อผิดพลาด

CLI ใช้รหัสการออกสามรหัส ตรวจสอบ $? ในสคริปต์เชลล์ หรือ $LASTEXITCODE ใน PowerShell เพื่อแยกเส้นทางการทำงานตามความสำเร็จหรือความล้มเหลว อ่านข้อความวินิจฉัยจาก stderr ซึ่งแยกออกจากข้อมูลบน stdout

รหัสการออก	ความหมาย	ตัวอย่าง
0	สำเร็จ	คำสั่งทำงานเสร็จสมบูรณ์ version พิมพ์ผลแล้ว
1	ข้อผิดพลาดขณะทำงาน CLI พิมพ์ Error: <message> ไปยัง stderr	ไม่พบไฟล์อินพุตหรือไฟล์ไม่ใช่ไฟล์ปกติ stdin ว่างเปล่า ขาด --base-url/--api-key หรือค่าดังกล่าวไม่ถูกต้อง ข้อผิดพลาดฝั่งเซิร์ฟเวอร์ใดๆ (ต้องมีสิทธิ์ใช้งาน เกินโควตา PDF ที่ไม่มีแท็ก หมดเวลาในการสร้าง หรือความล้มเหลวอื่นของ API)
2	ข้อผิดพลาดจากการใช้งาน รายงานโดย Click	คำสั่งหรือตัวเลือกที่ไม่รู้จัก (รวมถึงตัวเลือกของกลุ่มที่วางไว้หลังคำสั่งย่อย) อาร์กิวเมนต์ที่จำเป็นซึ่งขาดหายไป เช่น PDF_PATH เป็นต้น

ความล้มเหลวฝั่งเซิร์ฟเวอร์ทุกครั้งจะคืนรหัสการออก 1 พร้อมข้อความบน stderr ที่มนุษย์อ่านได้ SDK จะยกข้อยกเว้นที่มีการกำหนดชนิด ได้แก่ NextPDFLicenseError (Hypertext Transfer Protocol (HTTP) 402), QuotaExceededError (HTTP 429), AstNoStructTreeError (HTTP 422, PDF ที่ไม่มีแท็ก), AstBuildTimeoutError (HTTP 504) หรือ NextPDFAPIError ซึ่งเป็นคลาสฐาน CLI จะดักจับทั้งหมดภายใต้คลาสฐานร่วม NextPDFError พิมพ์ข้อความ แล้วออกด้วยรหัส 1 CLI ไม่ได้เปิดเผยรหัสการออกที่แตกต่างกันตามประเภทความล้มเหลว หากต้องการแยกแยะ เช่น ข้อผิดพลาดเรื่องโควตาจากข้อผิดพลาดเรื่องสิทธิ์การใช้งานในสคริปต์ ให้ตรวจสอบข้อความบน stderr หรือเรียก SDK โดยตรง (ดู ภาพรวม Python สำหรับคลาสข้อยกเว้น)

ใช้รูปแบบการเขียนสคริปต์นี้เพื่อแยกข้อมูลออกจากข้อความวินิจฉัย:

#!/usr/bin/env bash
set -euo pipefail

# Credentials come from the environment, not the command line.
: "${NEXTPDF_BASE_URL:?set NEXTPDF_BASE_URL}"
: "${NEXTPDF_API_KEY:?set NEXTPDF_API_KEY}"

if nextpdf --output contract.ast.json ast contract.pdf; then
  echo "AST written to contract.ast.json"
else
  status=$?
  echo "nextpdf failed with exit code ${status}" >&2
  exit "${status}"
fi

เมื่อใช้ --output CLI จะเขียนข้อมูลไปยังไฟล์ที่ระบุชื่อ และพิมพ์เฉพาะบรรทัดยืนยัน Written to <path> ไปยัง stderr ดังนั้น stdout จะว่างเปล่า หากไม่ใช้ --output ข้อมูลจะถูกส่งไปยัง stdout และคุณสามารถเปลี่ยนทิศทางได้

สูตร

สูตรทั้งหมดด้านล่างใช้เฉพาะคำสั่งและแฟล็กที่ผ่านการตรวจสอบแล้ว ในแต่ละกรณี ข้อมูลรับรองมาจากสภาพแวดล้อม

สูตร: แยกตารางใบแจ้งหนี้เป็น CSV

แปลงโฟลเดอร์ใบแจ้งหนี้ให้เป็นไฟล์ CSV หนึ่งไฟล์ต่อหนึ่งเอกสาร สำหรับใช้กับสเปรดชีตหรือไปป์ไลน์บัญชี:

#!/usr/bin/env bash
set -euo pipefail

: "${NEXTPDF_BASE_URL:?set NEXTPDF_BASE_URL}"
: "${NEXTPDF_API_KEY:?set NEXTPDF_API_KEY}"

mkdir -p out
for pdf in invoices/*.pdf; do
  name="$(basename "${pdf}" .pdf)"
  nextpdf --output "out/${name}.csv" extract tables "${pdf}" --format csv
done

ไฟล์ out/<name>.csv แต่ละไฟล์มีบล็อก CSV หนึ่งบล็อกต่อหนึ่งตารางที่ตรวจพบ พร้อมส่วนหัว # Table N (pM) อยู่ก่อนแต่ละบล็อก แยกวิเคราะห์บล็อกด้วย ตัวอ่าน CSV ที่แสดงไว้ข้างต้น ประกอบ

สูตร: สร้างเค้าโครงเอกสาร

รวม --headings-only กับรูปแบบ markdown เพื่อสร้างเค้าโครงย่อที่คุณอ่านหรือวางลงในบันทึกได้:

nextpdf --output outline.md extract text whitepaper.pdf --headings-only --format markdown

สูตร: เปรียบเทียบความต่างของ PDF สองรุ่น

คำสั่ง ast ของ CLI คืนค่าต้นไม้สำหรับเอกสารหนึ่งฉบับ และไม่มีคำสั่งย่อยสำหรับเปรียบเทียบความต่าง การเปรียบเทียบเชิงโครงสร้างอยู่ใน SDK ในชื่อ client.ast.get_ast_diff(...) และอยู่ในเซิร์ฟเวอร์ Model Context Protocol (MCP) ในชื่อเครื่องมือ nextpdf_diff เรียกใช้การเปรียบเทียบความต่างผ่าน SDK:

"""Compare two PDF revisions structurally with the NextPDF SDK.

The API key is read from the environment, never hard-coded.
"""

import os
from pathlib import Path

from nextpdf import NextPDF


def diff_revisions(original: Path, modified: Path) -> None:
    """Print a structural diff summary between two PDF revisions.

    Args:
        original: Path to the earlier PDF revision.
        modified: Path to the later PDF revision.
    """
    base_url = os.environ["NEXTPDF_BASE_URL"]
    api_key = os.environ["NEXTPDF_API_KEY"]

    client = NextPDF(base_url=base_url, api_key=api_key)
    result = client.ast.get_ast_diff(
        original.read_bytes(),
        modified.read_bytes(),
    )

    summary = result.summary
    print(f"added:   {summary.added_node_count}")
    print(f"removed: {summary.removed_node_count}")
    print(f"changed: {summary.changed_node_count}")
    for entry in result.diff:
        preview = entry.text_preview or ""
        print(f"  {entry.type:<8} {entry.node_type:<12} p{entry.page_index} {preview}")


if __name__ == "__main__":
    diff_revisions(Path("contract-v1.pdf"), Path("contract-v2.pdf"))

หากต้องการเรียกใช้การเปรียบเทียบความต่างเดียวกันจากเอเจนต์ปัญญาประดิษฐ์ (AI) แทนสคริปต์ ให้ลงทะเบียนเซิร์ฟเวอร์ MCP แล้วเรียกเครื่องมือ nextpdf_diff ดูหน้า เซิร์ฟเวอร์ Python MCP ประกอบ

สูตร: สตรีม PDF เข้ามาจากเครื่องมืออื่น

อ่านไบต์ PDF จาก stdin ด้วย - เพื่อเชื่อม nextpdf ต่อท้ายเครื่องมือที่ส่ง PDF ออกทาง stdout ของตนเอง:

curl --silent https://example.com/report.pdf | nextpdf info -

อาร์กิวเมนต์ - บอกให้คำสั่งอ่านเอกสารจาก stdin หากไม่มีไบต์ใดเข้ามา คำสั่งจะรายงานข้อผิดพลาดและออกด้วยรหัส 1

หมายเหตุด้านประสิทธิภาพ

CLI สร้างการตอบกลับแต่ละครั้งในหน่วยความจำและเขียนเพียงครั้งเดียว การเปลี่ยนทิศทางหรือไปป์เอาต์พุตทำได้โดยตรง แต่เอาต์พุตไม่ได้ถูกสร้างแบบทีละส่วน AST หรือชุดตารางขนาดใหญ่จะถูกบัฟเฟอร์จนครบก่อนที่ไบต์แรกจะไปถึง stdout หรือไฟล์ --output จึงควรวางแผนหน่วยความจำและเวลาแฝงสำหรับการตอบกลับทั้งเอกสาร ไม่ใช่สำหรับสตรีม

การเรียกใช้ nextpdf แต่ละครั้งจะสร้างไคลเอนต์และการเชื่อมต่อ HTTP ใหม่ ดังนั้นการวนซ้ำกับไฟล์จำนวนมากจะเปิดและปิดการเชื่อมต่อต่อหนึ่งไฟล์ ต้นทุนการเชื่อมต่อมักเล็กน้อยเมื่อเทียบกับเวลาในการแยกข้อมูลฝั่งเซิร์ฟเวอร์ แต่จะกลายเป็นภาระงานจริงเมื่อทำในระดับใหญ่

• ใช้เอนด์พอยต์เดียวซ้ำ ชี้การเรียกใช้ทุกครั้งไปยังการปรับใช้ NextPDF Connect เดียวกัน เพื่อให้เซิร์ฟเวอร์ใช้แคชที่อุ่นไว้แล้วและกลุ่มการเชื่อมต่อซ้ำได้ หลีกเลี่ยงการกระจายงานเป็นชุดข้ามหลายเอนด์พอยต์ เว้นแต่คุณกำลังกระจายโหลดโดยตั้งใจ
• จำกัดงานต่อการเรียกหนึ่งครั้ง ใช้ --page, --page-start/--page-end หรือ --token-budget เพื่อประมวลผลเฉพาะหน้าที่คุณต้องการ ช่วงหน้าที่เล็กลงจะลดทั้งเวลาของเซิร์ฟเวอร์และขนาดการตอบกลับ --token-budget จำกัดขนาด AST ที่เอเจนต์ของคุณต้องอ่าน
• รวมเป็นชุดในกระบวนการเดียวสำหรับงานขนาดใหญ่ สำหรับงานเป็นชุดปริมาณมาก ควรใช้ Python SDK แทนการเรียก CLI ซ้ำ ไคลเอนต์ NextPDF หรือ AsyncNextPDF ตัวเดียวที่มีอายุยืนยาวจะใช้การเชื่อมต่อ HTTP แบบรวมกลุ่มรายการเดียวซ้ำกับทุกเอกสาร ซึ่งตัดต้นทุนการเริ่มต้นกระบวนการและการตั้งค่าการเชื่อมต่อที่การวนซ้ำของ CLI ต้องจ่ายทุกครั้ง ภาพรวม Python แสดงวงจรชีวิตของไคลเอนต์ และ AsyncNextPDF รองรับการแยกข้อมูลพร้อมกันข้าม PDF หลายไฟล์
• กันบันทึกออกจากเส้นทางข้อมูล ปล่อย --log-level ไว้ที่ค่าเริ่มต้นสำหรับการทำงานเป็นชุด บันทึกการวินิจฉัยจะส่งไปยัง stderr และไม่ทำให้ข้อมูล stdout เสียหาย แต่การยกระดับเป็น debug จะเพิ่มเสียงรบกวนและภาระงานเล็กน้อย