BroadRouter

वीज़न LLM से इनवॉइस, रसीद और फ़ॉर्म का डेटा JSON में निकालें

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित

हर पेज को इमेज में बदलें, उसे ऐसे प्रॉम्प्ट के साथ वीज़न मॉडल को भेजें जो हर फ़ील्ड और उसका फ़ॉर्मैट बताए, और सिर्फ़ JSON माँगें। फिर कोड में जाँचें: parse करें, स्कीमा जाँचें, देखें कि लाइन आइटम जुड़कर कुल रक़म बनते हैं, और एरर के साथ एक बार retry करें। बार-बार फ़ेल होने वाले दस्तावेज़ किसी व्यक्ति को भेजें।

A paper invoice headed "فاتورة" (invoice) with tabs labelled Vendor, Date and Total, and the text "Turn documents into useful data."
Illustrative example.

इनवॉइस, रसीद और फ़ॉर्म, सबकी समस्या एक है: डेटा तस्वीर में है, और आपको वह डेटाबेस में चाहिए। टेम्पलेट वाला OCR हर नए वेंडर लेआउट पर टूट जाता है। vision-language मॉडल पेज पढ़ता है और सीधे फ़ील्ड लौटाता है। दिक़्क़त यह है कि वह पूरे भरोसे के साथ ग़लत हो सकता है, इसलिए असली काम उसके आसपास की पाइपलाइन में है। यह पोस्ट किसी भी भाषा के लिए सामान्य पाइपलाइन बताती है। अरबी दस्तावेज़ों के लिए सेटअप वीज़न से अरबी इनवॉइस पढ़ना में है, और क्लासिक OCR कब बेहतर टूल है, यह अरबी OCR बनाम वीज़न LLM में।

पाइपलाइन कैसी दिखती है?

  1. हर पेज तैयार करें: PDF को इमेज में रेंडर करें, घुमाव ठीक करें, साइज़ घटाएँ।
  2. निकालें: हर दस्तावेज़ के लिए एक अनुरोध, फ़ील्ड-दर-फ़ील्ड प्रॉम्प्ट के साथ, सिर्फ़ JSON।
  3. जाँचें: parse, स्कीमा जाँच, जोड़ की जाँच।
  4. validation फ़ेल हो तो एरर मैसेज के साथ एक बार retry करें।
  5. रिव्यू: जो अब भी फ़ेल हो, वह इमेज और ड्राफ़्ट के साथ किसी व्यक्ति के पास जाए।
  6. लेबल किए गए सैंपल पर फ़ील्ड की सटीकता नापें, और मॉडल या प्रॉम्प्ट बदलने पर हर बार फिर चलाएँ।

दस्तावेज़ की इमेज कैसे तैयार करें?

PDF को PyMuPDF से इमेज में रेंडर करें, और ज़रूरत से ज़्यादा पिक्सल भेजे बिना सबसे छोटा टेक्स्ट साफ़ रखें:

# pip install pymupdf pillow
import base64, io
import pymupdf  # older code imports it as fitz
from PIL import Image

def pdf_pages_as_data_urls(path, long_edge=1800):
    urls = []
    for page in pymupdf.open(path):
        pix = page.get_pixmap(dpi=200)
        img = Image.open(io.BytesIO(pix.tobytes("png"))).convert("RGB")
        img.thumbnail((long_edge, long_edge))
        buf = io.BytesIO()
        img.save(buf, format="JPEG", quality=90)
        urls.append("data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode())
    return urls

BroadNet Inference पर इमेज मैसेज में सही MIME टाइप वाले data: URL के रूप में जाती हैं, और उपयोग के अनुसार भुगतान पर उनका बिल इनपुट टोकन के रूप में बनता है; बड़ी इमेज ज़्यादा टोकन लेती है। usage ब्लॉक से एक बार प्रति पेज टोकन नापें और उसी से अपने बैच का साइज़ तय करें; भेजने से पहले टोकन गिनना तरीक़ा बताता है, और प्रति इमेज वीज़न LLM लागत टोकन को प्रति पेज लागत में बदलता है। कुछ भी भेजने से पहले प्रति पेज टोकन का अंदाज़ा लगाने के लिए एक सैंपल स्कैन इमेज टोकन कैलकुलेटर में डालें।

extraction प्रॉम्प्ट कैसे लिखें?

key, टाइप, फ़ॉर्मैट और ग़ायब वैल्यू के बारे में बिल्कुल सटीक रहें। अगर आपको validation के लिए, या स्कीमा लागू करने वाले प्रोवाइडरों के लिए, JSON Schema भी चाहिए, तो मुफ़्त JSON schema generator एक सैंपल इनवॉइस से उसे बना देता है:

PROMPT = """Extract this invoice. Reply with one JSON object only, no prose.
Keys:
- vendor_name: string, as printed
- vendor_tax_id: string or null
- invoice_number: string
- invoice_date: string, YYYY-MM-DD
- currency: ISO 4217 code, e.g. USD, EUR, SAR
- line_items: list of {description: string, quantity: number, unit_price: number, line_total: number}
- subtotal: number
- tax: number or null
- total: number
Rules: numbers without currency symbols or thousands separators. If a field is not on the page, use null. Never guess."""

“Never guess” और साफ़ लिखा null सबसे ज़्यादा मायने रखते हैं। इनके बिना मॉडल ख़ाली जगहों को भरोसेमंद लगने वाली वैल्यू से भर देते हैं, जो ख़ाली छोड़ने से बुरा है, क्योंकि ऐसी वैल्यू सीधी-सादी जाँच पार कर जाती है।

structured output कैसे पाएँ और उसे validate कैसे करें?

structured output के दो स्तर हैं। JSON mode वैध JSON की गारंटी देता है। स्कीमा से बँधा आउटपुट उसके ढाँचे की भी गारंटी देता है। OpenAI की गाइड साफ़ कहती है: दोनों वैध JSON बनाते हैं, लेकिन स्कीमा का पालन सिर्फ़ Structured Outputs पक्का करता है। दोनों का सपोर्ट प्रोवाइडर और मॉडल के हिसाब से बदलता है, इसलिए API कुछ भी वादा करे, कोड में validate करें:

import json, os
from decimal import Decimal
from pydantic import BaseModel, ValidationError, model_validator
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

class Line(BaseModel):
    description: str
    quantity: Decimal
    unit_price: Decimal
    line_total: Decimal

class Invoice(BaseModel):
    vendor_name: str
    vendor_tax_id: str | None = None
    invoice_number: str
    invoice_date: str
    currency: str
    line_items: list[Line]
    subtotal: Decimal
    tax: Decimal | None = None
    total: Decimal

    @model_validator(mode="after")
    def sums(self):
        tol = Decimal("0.02")
        if abs(sum(l.line_total for l in self.line_items) - self.subtotal) > tol:
            raise ValueError("line_totals do not sum to subtotal")
        if abs(self.subtotal + (self.tax or 0) - self.total) > tol:
            raise ValueError("subtotal + tax != total")
        return self

def extract(image_urls, model="broadnet/qwen3.8-27b"):
    content = [{"type": "text", "text": PROMPT}] + [
        {"type": "image_url", "image_url": {"url": u}} for u in image_urls]
    messages = [{"role": "user", "content": content}]
    for attempt in range(2):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=4000, temperature=0)
        raw = (r.choices[0].message.content or "").strip().removeprefix("```json").removesuffix("```")
        try:
            return Invoice.model_validate(json.loads(raw)), r.usage
        except (json.JSONDecodeError, ValidationError, ValueError) as e:
            messages += [{"role": "assistant", "content": raw},
                         {"role": "user", "content": f"That failed validation: {e}. Re-read the image and reply with corrected JSON only."}]
    return None, r.usage  # send to human review

पैसों के लिए float नहीं, Decimal इस्तेमाल करें। max_tokens खुला रखें: Qwen3.8 27B जवाब देने से पहले रीज़निंग करता है, और रीज़निंग सीमा में गिनी जाती है; छोटी सीमा ख़ाली स्ट्रिंग लौटाती है। देखें रीज़निंग मॉडल ख़ाली जवाब क्यों देते हैं।

कौन-सी जाँचें सबसे ज़्यादा ग़लतियाँ पकड़ती हैं?

जाँच क्या पकड़ती है लागत
JSON parse होता है JSON के आसपास का गद्य, कटा हुआ आउटपुट मुफ़्त
स्कीमा validate होता है ग़ायब key, ग़लत टाइप मुफ़्त
लाइनें जुड़कर subtotal बनती हैं ग़लत पढ़े अंक, छूटी लाइनें मुफ़्त
subtotal + टैक्स = total ग़लत पढ़ा total या टैक्स मुफ़्त
तारीख़ parse होती है और भविष्य की नहीं है दिन/महीने की अदला-बदली, OCR का शोर मुफ़्त
वेंडर का टैक्स ID आपकी सप्लायर लिस्ट से मिलता है ग़लत वेंडर, धोखाधड़ी एक lookup
हर वेंडर के लिए दोहराया गया इनवॉइस नंबर दोहरा भुगतान एक query

जोड़ की जाँच सबसे फ़ायदेमंद है: एक भी ग़लत पढ़ा अंक लगभग हमेशा जोड़ बिगाड़ देता है। रसीदों में अक्सर लाइन-स्तर का ब्योरा नहीं होता, इसलिए जो मौजूद है उसे जाँचें और उनके लिए कम जाँचें स्वीकार करें।

लाइव जाने से पहले सटीकता कैसे नापें?

50 से 100 असली दस्तावेज़ हाथ से लेबल करें, पाइपलाइन चलाएँ, और हर फ़ील्ड का स्कोर निकालें, हर दस्तावेज़ का नहीं। टोटल और तारीख़ के लिए विवरण से कड़ा पैमाना रखें। तीन नंबर ट्रैक करें: फ़ील्ड की सटीकता, बिना retry के validation पास करने वाले दस्तावेज़ों का हिस्सा, और रिव्यू में भेजे गए दस्तावेज़ों का हिस्सा। वह रिव्यू क़दम कैसे डिज़ाइन करें, पास हुए दस्तावेज़ों के रैंडम ऑडिट समेत, यह ह्यूमन रिव्यू को अपने document AI वर्कफ़्लो का हिस्सा बनाना में है। जब कोई दूसरा मॉडल आज़माएँ, तो वही सेट चलाएँ; तरीक़ा बदलने से पहले LLM का मूल्यांकन में है।

BroadNet Inference पर कौन-से वीज़न मॉडल फ़िट होते हैं?

मॉडल इमेज कॉन्टेक्स्ट नोट्स
Qwen3.8 27B हाँ 262,144 टूल, structured output और रीज़निंग लिस्टेड; BroadNet ने अरबी में टेस्ट किया
Gemma 4 VL 26B हाँ 32,768 BroadNet की सबसे कम कीमत; मुफ़्त क्रेडिट और घंटे वाली key पर चलता है
DeepSeek V4.1 Flash हाँ 1,048,576 अनलिमिटेड प्लान में इमेज शामिल

प्रति 1M टोकन कीमतें कीमतों के पेज पर हैं; प्रति पेज नापे गए टोकन को मासिक मात्रा से LLM API लागत कैलकुलेटर में गुणा करें।

BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference तीन चैट मॉडल पर मानक OpenAI मैसेज फ़ॉर्मैट से इमेज लेता है, और अनुरोध के बाद प्रॉम्प्ट, इमेज या जवाब नहीं रखता, जो नाम, टैक्स ID और बैंक विवरण से भरे इनवॉइस के लिए मायने रखता है (zero data retention)। उसके डॉक्स Qwen3.8 27B के लिए structured output लिस्ट करते हैं, लेकिन स्कीमा पैरामीटर डॉक्युमेंट नहीं करते, इसलिए अपना स्कीमा लागू करवाने के लिए API की जगह ऊपर वाली validation परत पर भरोसा करें। BroadNet कोई इमेज साइज़ सीमा या अलग document-AI प्रोडक्ट प्रकाशित नहीं करता, और उसके डॉक्स PDF अपलोड नहीं, इमेज इनपुट बताते हैं, इसलिए पहले पेज को इमेज में रेंडर करें। तय बजट पर बड़ी मात्रा वाले रन के लिए अनलिमिटेड DeepSeek V4.1 Flash प्लान में इमेज शामिल हैं।

अक्सर पूछे जाने वाले सवाल

क्या इनवॉइस के लिए वीज़न LLM, OCR की जगह ले सकता है?

कई लेआउट के लिए, हाँ। वीज़न मॉडल इमेज पढ़ता है और एक ही क़दम में टेक्स्ट को फ़ील्ड से जोड़ देता है, हर वेंडर के लिए टेम्पलेट के बिना। फिर भी वह कभी-कभी अंक ग़लत पढ़ता है, इसलिए validation और रिव्यू क्यू रखें।

वीज़न मॉडल से भरोसेमंद JSON कैसे पाएँ?

प्रॉम्प्ट में सटीक key, टाइप और फ़ॉर्मैट लिखें, सिर्फ़ JSON माँगें, और कोड में parse करें। अगर मॉडल स्कीमा से बँधा आउटपुट सपोर्ट करता है, तो उसे इस्तेमाल करें। दोनों हालात में स्कीमा लाइब्रेरी से validate करें और एरर के साथ एक बार retry करें।

कई पेज वाले PDF इनवॉइस से डेटा कैसे निकालें?

हर पेज को इमेज में बदलें, फिर एक इनवॉइस के सभी पेज एक ही अनुरोध में भेजें, अगर वे मॉडल के कॉन्टेक्स्ट में आ जाएँ, ताकि आख़िरी पेज के टोटल को पहले पेज की लाइनों से मिलाया जा सके।

इनवॉइस की इमेज का resolution कितना होना चाहिए?

इतना कि सबसे छोटे अंक साफ़ दिखें, उससे ज़्यादा नहीं। बड़ी इमेज ज़्यादा इनपुट टोकन लेती है। A4 पेज के लिए लंबी तरफ़ लगभग 1,500 से 2,000 पिक्सल एक समझदार शुरुआत है; अपने दस्तावेज़ों पर टेस्ट करें।

extraction की सटीकता कैसे नापें?

50 से 100 असली दस्तावेज़ हाथ से लेबल करें और फ़ील्ड-दर-फ़ील्ड स्कोर करें। टोटल और तारीख़ को वेंडर नाम जैसे खुले टेक्स्ट वाले फ़ील्ड से अलग ट्रैक करें, क्योंकि उनकी ग़लती की क़ीमत अलग होती है।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें