BroadRouter

LLM کا غلط JSON کیسے ٹھیک کریں: وجوہات، مرمت، دوبارہ کوشش

BroadNet Inference ٹیم · 7 منٹ کی پڑھائی · شائع شدہ · اپ ڈیٹ

پہلے finish_reason دیکھیں: max_tokens پر کٹا جواب محفوظ طریقے سے ٹھیک نہیں ہو سکتا، اس لیے حد بڑھا کر دوبارہ بھیجیں۔ ورنہ کوڈ فینس اور آس پاس کی نثر ہٹائیں، پہلی JSON ویلیو ڈی کوڈ کریں، پھر صرف ٹریلنگ کوما جیسی واضح غلطیاں ٹھیک کریں۔ اسکیما سے تصدیق کریں، اور ناکام ہو تو عین ایرر ایک دو بار واپس بھیجیں۔ جہاں سپورٹ ہو، اسٹرکچرڈ آؤٹ پٹ ان میں سے زیادہ تر روکتا ہے۔

آپ کا کوڈ ماڈل کے جواب پر json.loads() چلاتا ہے اور JSONDecodeError: Expecting value: line 1 column 1 ملتا ہے۔ یا وہ پارس ہو جاتا ہے، لیکن جہاں آپ کو نمبر چاہیے تھا وہاں ایک فیلڈ اسٹرنگ ہے۔ یہ پوسٹ وجوہات کو اس حساب سے ترتیب دیتی ہے کہ ہر ایک کے ساتھ آپ محفوظ طریقے سے کیا کر سکتے ہیں، ایک ٹیسٹ شدہ Python فنکشن دیتی ہے جو صرف واضح صورتوں کی مرمت کرتا ہے، اور ایک دوبارہ کوشش کا لوپ دکھاتی ہے جو جانتا ہے کہ کب دوبارہ کوشش سے کچھ نہیں ہوگا۔

JSON mode اور json_schema میں سے انتخاب JSON mode بمقابلہ json_schema میں ہے۔ یہ پوسٹ اس جواب کے بارے میں ہے جو آپ کو اصل میں ملا۔

LLM غلط JSON کیوں لوٹاتے ہیں؟

ماڈل ایک ایک ٹوکن کر کے متن لکھتا ہے۔ جب تک سرور ڈی کوڈنگ کو پابند نہ کرے، اسے ایک دوستانہ جملہ جوڑنے یا جگہ ختم ہونے سے کوئی نہیں روکتا۔ عام خرابیاں:

آپ کو کیا نظر آتا ہے وجہ کیا کوڈ میں مرمت محفوظ ہے؟
```json … ``` آبجیکٹ کے گرد چیٹ فارمیٹنگ کی عادت ہاں: فینس ہٹائیں
پہلے “Here is the JSON:”، بعد میں “Let me know…” وہی عادت ہاں: صرف پہلی ویلیو پڑھیں
آبجیکٹ سے پہلے <think>...</think> کچھ سرورز پر content فیلڈ میں ریزننگ کا متن ہاں: بلاک ہٹائیں
اسٹرنگ کے بیچ میں ختم، بریکٹ کھلے max_tokens تک پہنچا نہیں: زیادہ جگہ کے ساتھ دوبارہ بھیجیں
خالی content ریزننگ نے پورا بجٹ لے لیا نہیں: زیادہ جگہ کے ساتھ دوبارہ بھیجیں
{"a": 1,} ٹریلنگ کوما؛ JavaScript اجازت دیتا ہے، RFC 8259 نہیں ہاں: ایک ہی مطلب
{'a': True, 'b': None} Python سنٹیکس ہاں: ast.literal_eval اسے محفوظ طریقے سے پڑھتا ہے
NaN، Infinity JSON نہیں؛ Python بطور ڈیفالٹ قبول کرتا ہے نہیں: رد کریں
درست JSON، غلط ٹائپس یا غائب فیلڈز اسکیما نافذ نہیں نہیں: ایرر کے ساتھ دوبارہ مانگیں

تقسیم کی لکیر ابہام ہے۔ اگر ماڈل کا مطلب بالکل ایک ہی ہو سکتا تھا تو اسے کوڈ میں ٹھیک کریں اور لاگ کریں کہ آپ نے ٹھیک کیا۔ اگر اندازہ لگانا پڑے تو جواب رد کر دیں۔

کٹے ہوئے JSON کی مرمت کیوں نہ کریں؟

کیونکہ مرمت شدہ ورژن درست دکھتا ہے مگر ہوتا نہیں۔ ہم نے json_repair 0.64.9، ایک مقبول MIT لائسنس والی لائبریری، ایک ایسے جواب پر چلائی جو لفظ کے بیچ میں کٹا تھا:

'{"name": "Omar", "city": "Jed'  ->  {'name': 'Omar', 'city': 'Jed'}

اس نے شہر “Jed” کے ساتھ درست JSON لوٹایا۔ اس کا README یہ کھل کر کہتا ہے: یہ “automatically completes missing values in JSON fields with reasonable defaults” (ترجمہ: JSON فیلڈز میں غائب ویلیوز کو خودکار طور پر مناسب ڈیفالٹ سے مکمل کرتا ہے)۔ لاگز پڑھنے کے لیے یہ مفید ہے۔ جس ڈیٹا کو آپ محفوظ کرتے ہیں یا جس پر عمل کرتے ہیں، اس کے لیے یہ نظر آنے والی خرابی کو چھپی خرابی بنا دیتا ہے۔

پارس کرنے سے پہلے finish_reason دیکھیں۔ "length" کا مطلب ہے کہ جواب max_tokens تک پہنچ گیا۔ وہی درخواست اسی حد کے ساتھ دوبارہ بھیجنے پر ویسے ہی ناکام ہوگی، اس لیے حد دگنی کریں یا ہر کال میں کم مانگیں۔ ریزننگ ماڈلز سے یہ اور عام ہو جاتا ہے: BroadNet کا API ریفرنس کہتا ہے کہ DeepSeek V4.1 Flash، GLM 5.3 اور Qwen3.8 27B جواب دینے سے پہلے ریزننگ کرتے ہیں، اور ریزننگ max_tokens میں گنی جاتی ہے۔ چھوٹی حد پر جواب خالی آ سکتا ہے۔ 1,000 یا زیادہ ٹوکن چھوڑیں، یا reasoning_effort کو low کریں؛ اعداد ریزننگ بجٹ والی پوسٹ میں ہیں۔

مرمت کا فنکشن جو صرف محفوظ صورتیں ٹھیک کرتا ہے

یہ صرف اسٹینڈرڈ لائبریری استعمال کرتا ہے۔ یہ پارس شدہ ویلیو اور کی گئی مرمتوں کی فہرست لوٹاتا ہے، تاکہ آپ انہیں گن سکیں۔

import ast, json, re

class Truncated(Exception): pass
class NotJSON(Exception): pass

FENCE = re.compile(r"```(?:json|JSON)?\s*\n(.*?)```", re.S)
THINK = re.compile(r"<think>.*?</think>", re.S)

def _reject_constant(name):                 # NaN, Infinity: Python accepts them, JSON does not
    raise NotJSON(f"non-standard constant {name}")

_decoder = json.JSONDecoder(parse_constant=_reject_constant)

def _first_value(s):
    """Decode the first JSON object or array in s, ignoring prose before and after it."""
    for i, ch in enumerate(s):
        if ch in "{[":
            try:
                return _decoder.raw_decode(s, i)[0]
            except json.JSONDecodeError:
                continue                    # a stray brace in prose; try the next one
    raise NotJSON("no JSON object or array found")

def _scan(s):
    """Drop commas before } or ] outside strings; report brackets left open."""
    out, stack, in_str, esc = [], [], False, False
    for i, ch in enumerate(s):
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == '"':
                in_str = False
        elif ch == '"':
            in_str = True
        elif ch in "{[":
            stack.append(ch)
        elif ch in "}]" and stack:
            stack.pop()
        elif ch == ",":
            rest = s[i + 1:].lstrip()
            if rest[:1] in ("}", "]"):
                continue                    # trailing comma: skip it
        out.append(ch)
    return "".join(out), len(stack) + (1 if in_str else 0)

def _python_literal(s):
    """Output in Python syntax: single quotes, True/False/None, trailing commas."""
    start = min((i for i in (s.find("{"), s.find("[")) if i >= 0), default=-1)
    end = max(s.rfind("}"), s.rfind("]"))
    if start < 0 or end <= start:
        raise NotJSON("no braces")
    value = ast.literal_eval(s[start:end + 1])       # literals only; never runs code
    if not isinstance(value, (dict, list)):
        raise NotJSON("not an object or array")
    json.dumps(value, allow_nan=False)               # must round-trip as strict JSON
    return value

def parse_llm_json(content, finish_reason=None):
    """Return (value, repairs). Raises Truncated or NotJSON."""
    if finish_reason == "length":
        raise Truncated("hit max_tokens; raise the limit or shorten the output")
    if not content or not content.strip():
        raise NotJSON("empty content (reasoning may have used the whole budget)")
    repairs = []
    s = content.strip().lstrip("\ufeff")
    if THINK.search(s):
        s = THINK.sub("", s).strip(); repairs.append("removed <think> block")
    m = FENCE.search(s)
    if m:
        s = m.group(1).strip(); repairs.append("removed code fence")
    try:
        value = _decoder.decode(s)
        return value, repairs
    except json.JSONDecodeError:
        pass
    try:
        value = _first_value(s); repairs.append("ignored text around JSON")
        return value, repairs
    except NotJSON:
        pass
    fixed, open_count = _scan(s)
    if open_count:
        raise NotJSON(f"incomplete JSON, {open_count} bracket(s) or string left open: treat as truncated")
    if fixed != s:
        try:
            value = _first_value(fixed); repairs.append("removed trailing commas")
            return value, repairs
        except NotJSON:
            pass
    try:
        value = _python_literal(s); repairs.append("parsed Python-style literal")
        return value, repairs
    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError, NotJSON) as e:
        raise NotJSON(f"unrepairable: {e}") from None

ہر مرحلہ کیسے کام کرتا ہے:

  1. کٹے اور خالی جواب پارسنگ سے پہلے ہی ایرر اٹھاتے ہیں، اس لیے وہ کبھی ڈیٹا نہیں بنتے۔
  2. فینس اور ریزننگ بلاک دو ریگولر ایکسپریشنز سے ہٹائے جاتے ہیں۔
  3. raw_decode اصل اوزار ہے۔ Python کی دستاویزات کہتی ہیں کہ یہ دستاویز کو “from a string that may have extraneous data at the end” (ترجمہ: ایسی اسٹرنگ سے جس کے آخر میں فالتو ڈیٹا ہو سکتا ہے) ڈی کوڈ کرتا ہے، اور بتاتا ہے کہ کہاں رکا۔ پہلے { یا [ سے شروع کر کے یہ آبجیکٹ سے پہلے کی نثر چھوڑ دیتا ہے اور بعد کی نظرانداز کرتا ہے۔ اگر نثر میں کوئی بریس ڈی کوڈ نہ ہو تو یہ اگلا آزماتا ہے۔
  4. بریکٹ اسکین اسٹرنگز اور ایسکیپس پر نظر رکھتے ہوئے متن سے گزرتا ہے۔ کھلے رہ جانے والے بریکٹ کا مطلب ہے کہ جواب کٹا تھا، چاہے finish_reason نے ایسا نہ کہا ہو؛ اس پر ایرر اٹھتا ہے۔ اسٹرنگز کے باہر } یا ] سے فوراً پہلے والے کوما ہٹا دیے جاتے ہیں۔
  5. ast.literal_eval سنگل کوٹس، True اور None والا Python انداز کا آؤٹ پٹ پڑھتا ہے۔ یہ صرف لٹرلز کا حساب کرتا ہے اور کبھی کوڈ نہیں چلاتا۔ پھر نتیجے کا سخت JSON کے طور پر سیریلائز ہونا ضروری ہے۔
  6. NaN اور Infinity parse_constant کے ذریعے ایرر اٹھاتے ہیں۔ Python کا json انہیں بطور ڈیفالٹ قبول کرتا ہے؛ RFC 8259 کہتا ہے کہ یہ “are not permitted” (ترجمہ: اجازت نہیں ہے)، اور JavaScript کا JSON.parse انہیں رد کرتا ہے۔

ہم نے اسے 17 ٹیسٹ اسٹرنگز پر چلایا: صاف JSON، فینس والا JSON، فینس میں عربی کلیدیں اور ویلیوز، پہلے اور بعد میں نثر، آبجیکٹ سے پہلے نثر میں {name} پلیس ہولڈر، ایک <think> بلاک، آبجیکٹس اور ایریز میں ٹریلنگ کوما، اسٹرنگز کے اندر کوما اور بریکٹ، ایسکیپ شدہ کوٹس، بیک سلیش پر ختم ہونے والا Windows پاتھ، Python لٹرلز، NaN، خالی جواب، finish_reason: "length" کے ساتھ اور اس کے بغیر کٹا جواب، اور لگاتار دو آبجیکٹس۔ سب نے اوپر کی ٹیبل کے مطابق برتاؤ کیا۔ ایک ٹیسٹ نے اصل بگ پکڑا: ایک ابتدائی ورژن بند ہونے والے کوٹ کی جانچ سے پہلے اپنا ایسکیپ فلیگ پلٹ دیتا تھا، اس لیے "he said \"hi,]\"" کا کوما کھو جاتا تھا۔ اپنے مرمت کے کوڈ کو ایسکیپ شدہ کوٹس پر ضرور ٹیسٹ کریں۔

دو حدیں جان لیں۔ لگاتار دو آبجیکٹس ملیں تو یہ پہلا لوٹاتا ہے؛ اگر آپ کو کئی آئٹمز چاہییں تو ایک JSON ایرے مانگیں۔ اور سنگل کوٹس والا Python آؤٹ پٹ، جس کی کسی اسٹرنگ میں ڈبل کوٹ ہو، بریکٹ اسکین میں غلط پڑھا جا کر رد ہو سکتا ہے۔ رد کرنا ناکامی کی محفوظ صورت ہے۔

مرمت ناکام ہونے کے بعد دوبارہ کوشش کیسے کریں؟

مرمت فارمیٹ سنبھالتی ہے۔ تصدیق مواد سنبھالتی ہے: درست فیلڈز، درست ٹائپس، معقول ویلیوز۔ یہ لوپ jsonschema پیکیج سے تصدیق کرتا ہے اور وجہ کے حساب سے دوبارہ کوشش کا طریقہ چنتا ہے:

import json, os
from jsonschema import Draft202012Validator
from openai import OpenAI
from llm_json import parse_llm_json, Truncated, NotJSON

client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
SCHEMA = {"type": "object", "additionalProperties": False,
          "required": ["name", "city", "amount"],
          "properties": {"name": {"type": "string", "minLength": 1},
                         "city": {"type": ["string", "null"]},
                         "amount": {"type": "number", "minimum": 0}}}
validator = Draft202012Validator(SCHEMA)

def extract(text, model="broadnet/qwen3.8-27b", max_tokens=1500, attempts=3, log=print):
    messages = [{"role": "system", "content": "Extract name, city and amount. Reply with one JSON object only, no code fence. "
                                              "Schema: " + json.dumps(SCHEMA)},
                {"role": "user", "content": text}]
    for attempt in range(1, attempts + 1):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens,
                                           reasoning_effort="low", temperature=0)
        c = r.choices[0]
        try:
            value, repairs = parse_llm_json(c.message.content, c.finish_reason)
            errors = [f"{'/'.join(map(str, e.path)) or '(root)'}: {e.message}" for e in validator.iter_errors(value)]
            if not errors:
                log({"attempt": attempt, "repairs": repairs, "ok": True})
                return value
            problem = "The JSON does not match the schema: " + "; ".join(errors)
        except Truncated:
            log({"attempt": attempt, "ok": False, "why": "truncated"})
            max_tokens *= 2                 # same prompt, more room; a re-ask would be cut off too
            continue
        except NotJSON as e:
            problem = f"That reply was not valid JSON ({e})."
        log({"attempt": attempt, "ok": False, "why": problem})
        messages += [{"role": "assistant", "content": c.message.content or ""},
                     {"role": "user", "content": problem + " Return the corrected JSON object only."}]
    raise RuntimeError(f"no valid JSON after {attempts} attempts")

اس لوپ کے اصول:

  • کٹا ہوا: وہی پیغامات دگنی حد کے ساتھ دوبارہ بھیجیں۔ ”please fix“ والا پیغام جوڑنے سے پرامپٹ لمبا ہوگا اور آؤٹ پٹ چھوٹا نہیں ہوگا۔
  • JSON نہیں، یا غلط ساخت: عین ایرر واپس بھیجیں۔ “amount: ‘1200’ is not of type ‘number’” ماڈل کو ٹھیک کرنے کے لیے کچھ ٹھوس دیتا ہے۔ خالی دوبارہ کوشش اکثر وہی غلطی دہراتی ہے۔
  • کوششیں تین تک محدود رکھیں۔ ہر دوبارہ کوشش پوری گفتگو کو ان پٹ ٹوکن کے طور پر دوبارہ بھیجتی ہے۔ تین کے بعد ان پٹ لاگ کریں اور اسے کہیں اور بھیجیں۔
  • مرمتوں کی فہرست لاگ کریں۔ پرامپٹ بدلنے کے بعد “removed code fence” کی بڑھتی گنتی بتاتی ہے کہ پرامپٹ بگڑ گیا، چاہے کچھ ناکام نہ ہوا ہو۔

ہم نے یہ لوپ ایک مقامی موک سرور پر چلایا جو پہلے سے طے شدہ جواب لوٹاتا تھا۔ ٹریلنگ کوما اور اسٹرنگ کی صورت میں "amount": "1200" والا فینس شدہ جواب مرمت ہوا، تصدیق میں ناکام ہوا، اور ایرر واپس بھیجنے پر دوسری کال میں ٹھیک ہو گیا۔ finish_reason: "length" کے ساتھ کٹا جواب max_tokens کو 1,500 سے 3,000 کر کے دوبارہ بھیجا گیا اور کامیاب رہا۔ موک نے ہر بار درخواست ریکارڈ کی، جس سے تصدیق ہوئی کہ لوپ نے کتنے پیغامات اور کون سی حد بھیجی۔ اصل ماڈل مختلف طریقے سے ناکام ہو سکتا ہے، اس لیے اعداد پر بھروسا کرنے سے پہلے اسے اپنے 100 ان پٹس پر چلائیں۔

کیا اسٹرکچرڈ آؤٹ پٹ سے یہ سب غیر ضروری ہو جاتا ہے؟

یہ زیادہ تر ختم کر دیتا ہے۔ جو سرور ڈی کوڈنگ کو آپ کے اسکیما کا پابند کرتا ہے، وہ فینس، ٹریلنگ کوما یا غائب فیلڈ نہیں نکال سکتا۔ vLLM، اوپن ماڈلز کا ایک عام سرور، یہ xgrammar یا guidance بیک اینڈ سے کرتا ہے۔ پھر بھی دو خرابیاں باقی رہتی ہیں: max_tokens پر کٹاؤ، اور انکار۔ OpenAI بتاتا ہے کہ JSON mode کا آؤٹ پٹ درست ہوتا ہے “except for in some edge cases” (ترجمہ: کچھ خاص صورتوں کے سوا) اور آپ کی ایپلیکیشن کو ایسا آؤٹ پٹ جو مکمل آبجیکٹ نہیں، “must detect and handle” (ترجمہ: پہچاننا اور سنبھالنا ہوگا)۔ اس لیے json_schema کے ساتھ بھی finish_reason کی جانچ اور تصدیق کار رکھیں۔

ہر طریقہ کیا روکتا ہے:

طریقہ فینس اور نثر سنٹیکس ایررز غلط ساخت کٹاؤ
صرف پرامپٹ (”JSON میں جواب دیں“) کم کم کم نہیں
JSON mode (json_object) ہاں ہاں نہیں نہیں
اسٹرکچرڈ آؤٹ پٹ (json_schema، نافذ) ہاں ہاں ہاں نہیں

JSON mode کے ساتھ OpenAI یہ بھی کہتا ہے کہ آپ کو کسی پیغام میں “must always instruct the model to produce JSON” (ترجمہ: ماڈل کو ہمیشہ JSON بنانے کی ہدایت دینی ہوگی)؛ ورنہ وہ ٹوکن کی حد تک وائٹ اسپیس نکال سکتا ہے۔ OpenAI سے مطابقت رکھنے والے دوسرے سرورز مختلف ہیں، اس لیے جو ماڈل آپ شپ کرتے ہیں اس پر موڈ ٹیسٹ کریں۔ ٹیسٹ اسٹرکچرڈ آؤٹ پٹ والی پوسٹ میں ہے۔

کسی جواب کو ہاتھ سے جانچنے کے لیے اسے LLM JSON آؤٹ پٹ ویلیڈیٹر میں پیسٹ کریں، یا JSON schema جنریٹر سے ایک نمونہ آبجیکٹ سے سخت اسکیما بنائیں۔

BroadNet Inference کہاں فٹ ہوتا ہے

BroadRouter، BroadNet کی سائٹ ہے۔ BroadNet کا API ریفرنس اسٹرکچرڈ آؤٹ پٹ صرف GLM 5.3 اور Qwen3.8 27B کے لیے درج کرتا ہے، اور درخواست کے پیرامیٹر کا نام نہیں بتاتا، اس لیے اس پر انحصار سے پہلے ماڈل پر json_schema ٹیسٹ کریں۔ DeepSeek V4.1 Flash اور Gemma 4 VL 26B پر اوپر کے مرمت کے فنکشن اور تصدیق کار کے ساتھ صرف پرامپٹ والا JSON استعمال کریں۔ چار میں سے تین ماڈلز جواب سے پہلے ریزننگ کرتے ہیں، اس لیے max_tokens میں اس کا بجٹ رکھیں۔ بڑی مقدار میں ایکسٹریکشن کے لیے بیچ رنر والی پوسٹ دکھاتی ہے کہ ہر آئٹم کا finish_reason کیسے لاگ کریں۔ ہر درخواست کے بعد پرامپٹس اور جوابات محفوظ نہیں رکھے جاتے۔

عام سوالات

میرا LLM مارک ڈاؤن کوڈ بلاک کے اندر JSON کیوں لوٹاتا ہے؟

چیٹ ماڈلز عموماً کوڈ کو انسانوں کے لیے فارمیٹ کرتے ہیں، اور چیٹ انٹرفیس کوڈ فینس سے ہی کوڈ دکھاتے ہیں۔ ”صرف JSON، کوڈ فینس نہیں“ مانگیں، لیکن کوڈ میں فینس پھر بھی ہٹائیں: ہدایت سے ایسا کم ہوتا ہے، ختم نہیں ہوتا۔

LLM آؤٹ پٹ پر JSONDecodeError کیسے ٹھیک کریں؟

پہلے finish_reason دیکھیں۔ اگر وہ "length" ہے تو جواب کٹ گیا: max_tokens بڑھائیں اور دوبارہ بھیجیں۔ ورنہ کوڈ فینس ہٹائیں اور raw_decode سے پہلی JSON ویلیو ڈی کوڈ کریں، جو اس کے بعد کے متن کو نظرانداز کرتا ہے۔ ٹریلنگ کوما ٹھیک کریں، پھر تصدیق کریں۔ پھر بھی ناکام ہو تو ایرر کے ساتھ دوبارہ مانگیں۔

کیا JSON مرمت کی لائبریری استعمال کرنی چاہیے؟

لاگز اور ڈیبگنگ کے لیے، ہاں۔ جس ڈیٹا پر آپ عمل کرتے ہیں، اس کے لیے محتاط رہیں۔ json_repair جیسی لائبریریاں غائب ویلیوز ڈیفالٹ سے پوری کرتی ہیں، اس لیے کٹا ہوا شہر "Jed" ایک درست "Jed" بن کر لوٹتا ہے۔ کٹے ہوئے آؤٹ پٹ کو رد کریں اور دوبارہ بھیجیں۔

میرا LLM JSON آؤٹ پٹ درمیان میں کیوں کٹ جاتا ہے؟

جواب max_tokens تک پہنچ گیا۔ DeepSeek V4.1 Flash، GLM 5.3 اور Qwen3.8 27B جیسے ریزننگ ماڈلز پر ریزننگ اسی حد میں گنی جاتی ہے، اس لیے لمبی تھنکنگ کے بعد بہت کم جگہ بچ سکتی ہے۔ حد بڑھائیں، reasoning_effort low کریں، یا ہر کال میں کم آؤٹ پٹ مانگیں۔

کیا JSON mode درست JSON کی ضمانت دیتا ہے؟

تقریباً۔ OpenAI کہتا ہے کہ JSON mode کا آؤٹ پٹ درست JSON ہوتا ہے "except for in some edge cases" (ترجمہ: کچھ خاص صورتوں کے سوا)، جیسے ٹوکن کی حد تک پہنچنا، اور یہ آپ کا اسکیما نافذ نہیں کرتا۔ json_schema والا اسٹرکچرڈ آؤٹ پٹ اسکیما کی پابندی جوڑتا ہے، جہاں فراہم کنندہ اسے نافذ کرتا ہے۔ دونوں میں تصدیق کریں۔

BroadNet کے کون سے ماڈلز اسٹرکچرڈ آؤٹ پٹ سپورٹ کرتے ہیں؟

BroadNet کا API ریفرنس GLM 5.3 اور Qwen3.8 27B کے لیے اسٹرکچرڈ آؤٹ پٹ درج کرتا ہے، 15 نومبر 2026 کو دیکھا گیا۔ DeepSeek V4.1 Flash یا Gemma 4 VL 26B کے لیے یہ درج نہیں، اس لیے ان پر مرمت اور تصدیق کے ساتھ صرف پرامپٹ والا JSON استعمال کریں۔

Markdown میں پڑھیںChatGPT سے پوچھیںClaude سے پوچھیںPerplexity سے پوچھیں