Category: ezformatter

آپ کا API کال JSONDecodeError: Expecting property name enclosed in double quotes کے ساتھ ناکام ہو گیا۔ گھڑی چل رہی ہے۔ ڈیٹا LLM سے آیا تھا، اور اس 2,000-ٹوکن ردعمل میں کہیں، ایک واحد ٹریلنگ کامے نے آپ کی پوری پائپ لائن کو تباہ کر دیا۔

مئی 2026 تک، خراب JSON فائلز کو ٹھیک کرنے کا تیز ترین طریقہ خودکار لائبریریوں جیسے json_repair (Python) یا jsonrepair (npm) کا استعمال ہے۔ یہ آلات خاص طور پر LLM سے پیدا شدہ نحوی غلطیوں کو فوری طور پر ٹھیک کرنے کے لیے بنائے گئے ہیں۔ دستی مرمت کے لیے، معمول کے مجرم ٹریلنگ کامے، سنگل کوٹس، یا غیر کوٹڈ کلیدز ہیں — یہ RFC 8259 معیار کی خلاف ورزی کے تین سب سے عام طریقے ہیں۔

تیز ترین حل: LLM آؤٹ پٹس کے لیے json_repair

Python کے json.loads() جیسے معیاری پارسر ڈیزائن کے لحاظ سے سخت ہیں۔ ایک غلط مقام پر موجود کریکٹر JSONDecodeError کو متحرک کر دیتا ہے اور سب کچھ رک جاتا ہے۔ یہ 2026 میں روزانہ کا مسئلہ ہے کیونکہ LLMs اکثر JSON کو گفتگو کے متن میں لپیٹ دیتے ہیں، ردعمل کو جملے کے بیچ میں کاٹ دیتے ہیں، یا ایسے تبصرے شامل کر دیتے ہیں جو اسپیک کو توڑ دیتے ہیں۔

json_repair لائبریری ترجیحی حل ہے۔ GitHub کے مطابق، اس پروجیکٹ کے 2026 تک 4,700 سے زیادہ اسٹارز ہیں۔ یہ اسٹرنگ کے ارادے کو "اندازہ لگا کر” کام کرتا ہے — غائب بریکٹس بند کرنا، کوٹس شامل کرنا، اور JSON بلاک کے ارد گرد اضافی متن کو ہٹانا۔

Python: پہلے اور بعد میں

انسٹال کریں: pip install json-repair

خراب ان پٹ:

import json_repair

bad_json = '{"user": "Alice", "status": tru'
decoded_object = json_repair.loads(bad_json)

پردے کے پیچھے کیا ہوا: json_repair نے دیکھا کہ tru غالباً true تھا، غاختہ بند کرنے والا بریس شامل کیا، اور ایک درست Python ڈکشنری واپس کی۔ صفر دستی مداخلت۔

Salvage موڈ: جب ڈیٹا واقعی بہت برا ہو

مشکل کیسز کے لیے، json_repair (v0.59.5+) میں Salvage موڈ شامل ہے۔ جیسا کہ پروجیکٹ دستاویزات میں نوٹ کیا گیا ہے، یہ موڈ خاص طور پر کٹے ہوئے AI ردعمل یا خراب لاگز کے لیے بنایا گیا ہے۔ یہ اریز کو آبجیکٹس میں تبدیل کر سکتا ہے یا ایسے آئٹمز کو چھوڑ سکتا ہے جو بچانے کے لیے بہت زیادہ خراب ہیں، اس بات کو یقینی بناتے ہوئے کہ آؤٹ پٹ آپ کے اسکیمے کے مطابق ہو۔

import json_repair

# Salvage mode for severely truncated data
result = json_repair.loads(
    '{"items": [{"id": 1, "name": "Widget"}, {"id": 2, "na',
    salvage_mode=True
)
# Result: {'items': [{'id': 1, 'name': 'Widget'}, {'id': 2}]}
# Dropped the incomplete 'na' but saved everything else

npm متبادل

Node.js پروجیکٹس کے لیے، jsonrepair CLI اسی کام کو انجام دیتا ہے:

# Fix a file in place
npx jsonrepair broken.json > fixed.json

# Fix a string in a script
const { jsonrepair } = require('jsonrepair');
const fixed = jsonrepair('{"name": "test",}');

دستی ڈیبگنگ: معلوم کریں کہ کیا چیز نے اسپیک کو توڑا

جب خودکاری کام نہیں کرتی، تو آپ کو بالکل یہ معلوم کرنے کی ضرورت ہے کہ فائل کہاں RFC 8259 کی خلاف ورزی کرتی ہے۔ JSON، YAML یا JavaScript سے کہیں کم معاف کرنے والا ہے۔ جیسا کہ JSONParser تشخیصی ٹیم وضاحت کرتی ہے: "پارسر پہلے ایسے کریکٹر پر ناکام ہو جاتا ہے جسے وہ سمجھ نہیں سکتا، اور یہ اکثر کئی لائنوں پہلے پیش آنے والے کسی مسئلے کا نیچے کی طرف علامت ہوتا ہے۔”

تین JSON قاتل

قاتل 1: ٹریلنگ کامے

DEV Community کے مطابق، ٹریلنگ کامے پارسنگ ناکامیوں کا نمبر ایک سبب ہیں۔ وہ JavaScript میں ٹھیک ہیں لیکن JSON اری یا آبجیکٹ میں آخری آئٹم کے بعد غیر قانونی ہیں۔

// BROKEN - trailing comma after "active"
{
  "name": "Alice",
  "status": "active",
}

// FIXED - no comma before closing brace
{
  "name": "Alice",
  "status": "active"
}

قاتل 2: سنگل کوٹس

JSON، کلیدز اور اسٹرنگ ویلیوز دونوں کے لیے ڈبل کوٹس (") کا تقاضا کرتا ہے۔ بہت سے Python اور JavaScript ڈویلپرز غلطی سے سنگل کوٹس (') استعمال کر لیتے ہیں۔ جیسا کہ TidyCode نوٹ کرتا ہے، یہ ایک لازمی اصلاح ہے۔

// BROKEN - single quotes
{'name': 'Alice'}

// FIXED - double quotes
{"name": "Alice"}

قاتل 3: غیر کوٹڈ کلیدز

JavaScript میں آپ { name: "Alice" } لکھ سکتے ہیں۔ JSON میں، ہر کلید کو ڈبل کوٹس کی ضرورت ہے۔

// BROKEN - unquoted key
{name: "Alice"}

// FIXED - quoted key
{"name": "Alice"}

"Unexpected Token” غلطی

جب کوئی ویلیڈیٹر "Unexpected Token” پر نشان زد کرتا ہے، تو اس کا مطلب ہے کہ پارسر NaN، Infinity، یا undefined سے ٹکرا گیا ہے — یہ JavaScript مستقل ہیں جنہیں JSON سپورٹ نہیں کرتا۔ JSON صرف null، true، false، اور نمبرز کی اجازت دیتا ہے۔

// BROKEN - NaN is not valid JSON
{"score": NaN, "result": Infinity}

// FIXED - replace with null or valid values
{"score": null, "result": null}

سخت پارسنگ بمقابلہ مرمت پارسنگ: کب کون سی استعمال کریں

صحیح طریقہ اس بات پر منحصر ہے کہ آپ کا ڈیٹا کہاں سے آتا ہے۔ انسانی طور پر ایڈٹ شدہ کنفیگرشن فائلز سخت پارسنگ کی مستحق ہیں تاکہ مصنف کو غلطیاں ٹھیک کرنے پر مجبور کیا جا سکے۔ LLMs یا API لاگز سے آنے والے مشین-جنریٹڈ ڈیٹا کو مرمت پر مبنی پارسنگ کی ضرورت ہے۔

خصوصیت	سخت (json.loads)	مرمت (json_repair)
ٹریلنگ کامے	JSONDecodeError اٹھاتا ہے	خودکار طور پر ہٹائے جاتے ہیں
سنگل کوٹس	ناکام ہو جاتا ہے	ڈبل کوٹس میں تبدیل ہوتے ہیں
کٹا ہوا ڈیٹا	ناکام ہو جاتا ہے	کھلے بریکٹس/کوٹس بند کرتا ہے
تبصرے	ناکام ہو جاتا ہے	خودکار طور پر ہٹائے جاتے ہیں
بہترین استعمال کیس	انسانی طور پر ایڈٹ شدہ کنفیگرشن فائلز	LLM آؤٹ پٹس، API لاگز

Pydantic کے ساتھ اسکیم-گائیڈڈ مرمت

آپ Pydantic v2 یا JSON Schema کا استعمال کرتے ہوئے مرمت کے عمل کی رہنمائی کر سکتے ہیں۔ json_repair کو ایک اسکیمہ دے کر، یہ آلہ نحو سے زیادہ کرتا ہے — یہ اقسام کو درست کر سکتا ہے (اسٹرنگ "1" کو نمبر 1 میں بدلنا) اور غالباً ضروری فیلڈز کو ڈیفالٹس سے بھر سکتا ہے۔

from pydantic import BaseModel
import json_repair

class User(BaseModel):
    id: int
    name: str
    active: bool = True

# Broken JSON with wrong types
raw = '{"id": "42", "name": "Alice"}'
repaired = json_repair.loads(raw)

# Validate against schema
user = User(**repaired)
# user.id is now int(42), user.active defaults to True

جیسا کہ Stefano Baccianella نے اپنے 2025 کے پروجیکٹ حوالے میں نوٹ کیا، یہ طریقہ ان "زیادہ تر درست لیکن تکنیکی طور پر غیر درست” JSON کے لیے بہترین بنایا گیا ہے جو زبان کے ماڈلز عام طور پر پیدا کرتے ہیں۔

ملٹی-گیگابائٹ فائلز کو کریش کیے بغیر سنبھالنا

ایک 10KB اسنیپٹ کی مرمت آسان ہے۔ ایک 2GB فائل کو ٹھیک کرنے کے لیے ایک ایسی حکمت عملی کی ضرورت ہے جو آپ کی ساری RAM نہ کھا جائے۔ پوری فائل کو میموری میں لوڈ کرنے سے Out-of-Memory (OOM) غلطیاں پیدا ہوتی ہیں۔

حکمت عملی 1: ijson کے ساتھ اسٹریمنگ

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

import ijson

# Stream through a large JSON file
with open('huge_broken.json', 'r') as f:
    for item in ijson.items(f, 'records.item'):
        # Process each item individually
        process(item)

حکمت عملی 2: زیادہ سے زیادہ کارکردگی کے لیے CLI پائپ

بڑی فائلز کے لیے سب سے میموری-کارآمد طریقہ jsonrepair CLI کا استعمال کرنا اور آؤٹ پٹ کو براہ راست ایک نئی فائل میں پائپ کرنا ہے:

# Streams repair, never loads full file into memory
jsonrepair large_broken.json > fixed.json

یہ فائل کو Python یا براؤزر میں لوڈ کرنے سے کہیں زیادہ میموری-کارآمد ہے۔

نتیجہ

json_repair جیسی AI-آگاہ لائبریریوں کی بدولت خراب JSON کو ٹھیک کرنا اب کوئی دستی کام نہیں رہا۔ آپ کو اب بھی RFC 8259 کی بنیادیات کو سمجھنے کی ضرورت ہے — کوئی ٹریلنگ کامے نہیں، کوئی سنگل کوٹس نہیں، کوئی غیر کوٹڈ کلیدز نہیں — لیکن 2026 میں پیمانے پر ڈیٹا کے لیے خودکاری ہی واحد عملی طریقہ ہے۔

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

اکثر پوچھے جانے والے سوالات

کیا JSON باضابطہ طور پر تبصرے یا سنگل کوٹس کی سپورٹ کرتا ہے؟

نہیں۔ RFC 8259 معیار سختی سے تبصرے کی منع کرتا ہے۔ سنگل کوٹس بھی غیر درست ہیں — کلیدز اور اسٹرنگز کے لیے صرف ڈبل کوٹس کی اجازت ہے۔ تاہم، json_repair جیسے آلات تبصرے ہٹا اور کوٹس کو خودکار طور پر تبدیل کر سکتے ہیں تاکہ فائلز کو معیاری لائبریریوں کے ذریعے پارس کیا جا سکے۔

میں بہت بڑی خراب JSON فائلز کو کریش کیے بغیر کیسے سنبھالوں؟

ڈیٹا کو حصوں میں پروسیس کرنے کے لیے ijson جیسے اسٹریمنگ پارسر کا استعمال کریں۔ پوری خراب اسٹرنگ کو ایک ہی متغیر میں لوڈ کرنے سے گریز کریں۔ تیز ترین نتائج کے لیے CLI مرمت آلات استعمال کریں جو آؤٹ پٹ کو براہ راست ڈسک پر نئی فائل میں پائپ کرتے ہیں بغیر سب کچھ میموری میں رکھے۔

خراب JSON اور غیر درست JSON میں کیا فرق ہے؟

خراب (malformed) JSON نحوی قواعد کی خلاف ورزی کرتا ہے — غائب بریکٹس، غیر کوٹڈ کلیدز، ٹریلنگ کامے — جس کی وجہ سے اسے پارس کرنا ناممکن ہو جاتا ہے۔ غیر درست (invalid) JSON تمام نحوی قواعد پر عمل کرتا ہے لیکن کسی مخصوص JSON Schema سے مماثل نہیں ہوتا (مثلاً، کوئی فیلڈ اسکیمے میں نمبر کی توقع کرے لیکن اسٹرنگ ہو)۔ خراب JSON کو ٹھیک کرنا ساختی مرمت ہے؛ غیر درست JSON کو ٹھیک کرنا ڈیٹا کی سالمیت کے بارے میں ہے۔

کیا میں json_repair کو Pydantic توثیق کے ساتھ استعمال کر سکتا ہوں؟

ہاں۔ پہلے نحوی غلطیاں ٹھیک کرنے کے لیے json_repair.loads() چلائیں، پھر قسم کی توثیق اور اسکیمہ نافذ کرنے کے لیے مرمت شدہ ڈکشنری کو اپنے Pydantic ماڈل کو پاس کریں۔ یہ دو مرحلہ طریقہ ساختی اور معنوی دونوں مسائل کو سنبھالتا ہے۔

JavaScript طرز کے تبصروں والے JSON کا کیا ہوگا؟

معیاری JSON تبصرے کی سپورٹ نہیں کرتا، لیکن json_repair // اور /* */ تبصرے خودکار طور پر ہٹا سکتا ہے۔ اگر آپ کو اپنی کنفیگرشن فائلز میں تبصرے کی ضرورت ہے، تو JSONC (تبصروں والا JSON) فارمیٹ اور json5 (Python) جیسے مطابق پارسر استعمال کرنے پر غور کریں۔

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

فارمیٹر کے ساتھ اے آئی پرامپٹ کیسے لکھیں یہ سیکھنے کے لیے، RTCCO فریم ورک (Role، Task، Context، Constraints، Output) کو XML یا JSON جیسے ساختی ڈیلیمیٹرز کے ساتھ نافذ کریں۔ یہ پرامپٹس کو ماڈیولر سافٹ ویئر اثاثوں کے طور پر سمجھتا ہے، جو مئی 2026 تک ماڈل کے ہیلیوسینیشن کو 60 فیصد تک کم اور انسانی پروسیسنگ کا وقت 75 فیصد تک کم کر سکتا ہے۔

آپ کے پیراگراف پرامپٹس کیوں بار بار ناکام ہوتے ہیں

2026 تک، پیشہ ورانہ اے آئی کام "چیٹ” سے ہٹ کر پرامپٹ بطور کوڈ (PaC) کی طرف بڑھ گیا ہے۔ پیراگراف پرامپٹس — وہ طویل، بغیر ڈھانچے والے ٹیکسٹ بلاکس — کا مسئلہ یہ ہے کہ ماڈل آپ کی اصل ہدایات کو ان کے ساتھ ملے ہوئے پس منظر کے ڈیٹا یا آؤٹ پٹ کی ضروریات سے الگ کرنے میں مشکل محسوس کرتا ہے۔

PromptOT کے ڈیٹا سے پتہ چلتا ہے کہ ساختی انجینئرنگ کی طرف منتقلی غلطیوں کو 60 فیصد تک کم کر سکتی ہے اور انسانی پروسیسنگ کو 75 فیصد تک تیز کر سکتی ہے۔ Alex Ostrovskyy ہارڈ کوڈڈ پرامپٹس کو "سورس کوڈ میں میجک نمبرز کا جدید ہموار” قرار دیتے ہیں — نازک نظام جہاں کچھ بھی توڑے بغیر اپ ڈیٹ کرنا تقریباً ناممکن ہے۔

پہلے اور بعد میں: فارمیٹنگ کا فرق

پہلے (بغیر ڈھانچے):

You are a helpful coding assistant. Please write a Python function that validates
email addresses. Make sure it handles edge cases like plus signs and subdomains.
The output should be in JSON format with a valid boolean and the cleaned email.
Also make sure you add proper error handling and don't forget logging.

بعد میں (RTCCO + XML ڈیلیمیٹرز):

<system_instructions>
  <role>Senior Python engineer specializing in input validation</role>
  <primary_objective>Write a production-grade email validator</primary_objective>
</system_instructions>

<context>
  Must handle: plus addressing ([email protected]), subdomains,
  internationalized domains. Target: Python 3.11+.
</context>

<task_requirements>
  <rules>
    - Use only stdlib (no regex shortcuts)
    - Return structured JSON
    - Include type hints
  </rules>
  <steps>
    1. Parse the input string
    2. Validate format per RFC 5322
    3. Return JSON with "valid" boolean and "cleaned_email"
  </steps>
</task_requirements>

<output_format>
  {"valid": bool, "cleaned_email": str, "error": str | null}
</output_format>

ایک ہی ہدف، لیکن نتائج میں بہت فرق۔ فارمیٹ شدہ ورژن ماڈل کے لیے ابہام کی کوئی جگہ نہیں چھوڑتا۔

RTCCO فریم ورک: آپ کے پرامپٹ کا ڈھانچہ

انڈسٹری RTCCO کو معیاری پرامپٹ آرکیٹیکچر کے طور پر تسلیم کر چکی ہے۔ ہر پرامپٹ پانچ حصوں میں تقسیم ہوتا ہے:

عنصر	مقصد	مثال
R ole	اے آئی کون ہے؟	"سینئر بیک اینڈ انجینئر”
T ask	کون سا مخصوص عمل؟	"ریٹ لمیٹر مڈل ویئر لکھیں”
C ontext	کون سا پس منظر ڈیٹا؟	RAG ریٹریول، کوڈ بیس اسنیپٹس
C onstraints	قواعد کیا ہیں؟	"کوئی بیرونی ڈپینڈنسی نہیں”
O utput	یہ کیسا لگنا چاہیے؟	"ٹائپ ہنٹس کے ساتھ درست Python 3.11”

وہ XML اسکلیٹن ٹیمپلیٹ جسے آپ ابھی کاپی کر سکتے ہیں

یہ پروڈکشن کے لیے تیار ٹیمپلیٹ ہے۔ اسے کاپی کریں، ڈھالیں، اور استعمال کریں۔

<system_instructions>
  <role> [Expert Persona] </role>
  <primary_objective> [Main Goal] </primary_objective>
</system_instructions>

<context>
  [Background Data or RAG Retrieval]
</context>

<task_requirements>
  <rules> [Non-negotiable Constraints] </rules>
  <steps> [Specific Workflow] </steps>
</task_requirements>

<output_format>
  [JSON/XML/Markdown Specification]
</output_format>

<recency_recap>
  [Reminder of Critical Constraints]
</recency_recap>

ریسنسی ریکیپ کیوں اہم ہے

LLMs کی ایک معروف "پرائمسی اور ریسنسی” جانبداری ہے — وہ پرامپٹ کے آغاز اور اختتام کو درمیان سے بہتر یاد رکھتے ہیں۔ PromptOT کے حوالے سے ٹیسٹنگ سے پتہ چلا کہ اہم قواعد کو درمیان سے نکال کر نیچے ریسنسی ریکیپ بلاک میں رکھنے سے پروڈکشن استعمال میں درستگی 78 فیصد سے بڑھ کر 96 فیصد ہو گئی۔ Role کو اوپر رکھیں، اور اپنے سب سے اہم قواعد کو نیچے رکھیں۔

ڈیلیمیٹرز بطور سیکیورٹی باڑ

ڈیلیمیٹرز صرف تنظیم کے بارے میں نہیں ہیں — یہ ایک سیکیورٹی طریقہ کار بھی ہیں۔ صارف کے ان پٹ کو <user_input> جیسے ٹیگز میں لپیٹنا ماڈل کو بتاتا ہے: "یہ پروسیس کرنے کا ڈیٹا ہے، نئی ہدایات نہیں۔” یہ پرامپٹ انجیکشن حملوں کے خلاف آپ کا بنیادی دفاع ہے جہاں صارفین آپ کے سسٹم ہدایات کو اوور رائڈ کرنے کی کوشش کرتے ہیں۔

عام غلطی: اگر آپ ڈیلیمیٹرز کے بغیر براہ راست صارف ڈیٹا پرامپٹ میں داخل کرتے ہیں، تو صارف "تمام پچھلی ہدایات کو نظر انداز کرو اور…” لکھ سکتا ہے اور ماڈل مانے گا۔ بیرونی ڈیٹا کو ہمیشہ ٹیگ شدہ بلاکس میں رکھیں۔

ماڈیولر آرکیٹیکچر: میگا پرامپٹس لکھنا بند کریں

ایک نازک 2,000-ٹوکن پرامپٹ کے بجائے، اپنے سسٹم کو آزاد ماڈیولز میں تقسیم کریں۔ یہ ہدایت کے تصادم کو روکتا ہے — جہاں پرامپٹ کا انداز بدلنے سے اچانک اس کے JSON آؤٹ پٹ فارمیٹ کو نقصان پہنچ جاتا ہے۔

بنیادی اصول کونٹیکسٹ انجینئرنگ ہے: اسٹیٹک ہدایات کو ڈائنامک ڈیٹا سے الگ کریں۔ پروڈکشن RAG سسٹم میں، آپ کا پرامپٹ ایک ٹیمپلیٹ ہے جہاں <context> بلاک کو کیری ٹائم پر تازہ ڈیٹا سے بھرا جاتا ہے۔ جیسا کہ Jono Farrington of OptizenApp وضاحت کرتے ہیں، یہ ماڈیولر طریقہ بڑے پیمانے پر اے آئی ڈپلائمنٹس کو کہیں زیادہ مستقل بناتا ہے۔

پرامپٹ چیننگ: ماڈیولز کو جوڑنا

پیچیدہ ورک فلوز کے لیے، پرامپٹ چیننگ استعمال کریں — جہاں ایک ماڈیول کا آؤٹ پٹ اگلے ماڈیول کا ان پٹ بنتا ہے:

[Planner Module] --> outline --> [Executor Module] --> draft --> [Reviewer Module] --> final

یہ مرحلہ وار طریقہ آؤٹ پٹ کے معیار کو تقریباً 35 فیصد بہتر کرتا ہے کیونکہ ماڈل ایک وقت میں صرف ایک ذیلی کام پر توجہ مرکوز کرتا ہے۔

کاپی اور استعمال کے لیے چیننگ مثال:

planner_prompt = """
<system_instructions>
  <role>Technical architect</role>
  <task>Create a step-by-step plan for: {user_request}</task>
</system_instructions>
<output_format>JSON array of steps</output_format>
"""

executor_prompt = """
<system_instructions>
  <role>Senior developer</role>
  <task>Implement step: {step_from_planner}</task>
</system_instructions>
<context>{previous_outputs}</context>
<output_format>Code block with inline comments</output_format>
"""

مشکل مسائل کے لیے چین آف تھاٹ کا اضافہ

جب آپ کا کام پیچیدہ منطق پر مشتمل ہو، تو ایک <thought_process> بلاک شامل کریں۔ یہ ماڈل کو جواب دینے سے پہلے مرحلہ وار استدلال کرنے پر مجبور کرتا ہے، جو ریاضی، کوڈنگ، اور کثیر المراحل استدلال میں غلطیوں کو نمایاں طور پر کم کرتا ہے۔

<task_requirements>
  <rules>Reason inside <thought> tags before answering</rules>
</task_requirements>

<output_format>
  <thought> [Your step-by-step reasoning here] </thought>
  <answer> [Final JSON output here] </answer>
</output_format>

Zencoder کے مطابق، ٹری آف تھاٹس (ToT) جیسی تکنیکیں اسے مزید آگے بڑھاتی ہیں ماڈل سے مطالبہ کرکے کہ وہ ایک ساتھ متعدد حل کے راستوں کا جائزہ لے اور بہترین کو منتخب کرے۔ یہ خاص طور پر ان فن تعمیراتی فیصلوں کے لیے قیمتی ہے جہاں کوئی واحد درست جواب نہیں ہوتا۔

ٹوکن لاگت کی وارننگ

ساختی استدلال زیادہ ٹوکن استعمال کرتا ہے۔ ایک عام <thought_process> بلاک ہر درخواست پر 200-500 ٹوکنز کا اضافہ کرتا ہے۔ بڑے پیمانے پر، اس کا مطلب زیادہ API لاگت ہے۔ معاوضہ درستگی ہے: آپ ہر درخواست پر زیادہ ادا کرتے ہیں لیکن آپ کو کم دوبارہ کوششوں اور کم انسانی اصلاح کی ضرورت ہوتی ہے۔

پروڈکشن تیاری: ورژننگ، ٹیسٹنگ، اور CI/CD

آخری مرحلہ پرامپٹس کو سافٹ ویئر کی طرح سمجھنا ہے۔ سیمنٹک ورژننگ (v1.0.0) استعمال کریں تاکہ آپ کی ٹیم تبدیلیوں کی نشاندہی کر سکے اور جب کوئی نیا پرامپٹ ورژن خراب ہو تو فوراً واپس لے سکے۔

PromptOT کی رپورٹ کے مطابق، 50 سے زیادہ پرامپٹس کا انتظام کرنے والی کمپنیاں انتظامی مرکوزیت اور انجینئرز کے دستی ٹوییک میں گزارے جانے والے وقت کو کم کرکے سالانہ 400,000 ڈالر تک بچا سکتی ہیں۔

پرامپٹ CI/CD پائپ لائن سیٹ اپ کرنا

# .github/workflows/prompt-tests.yml
name: Prompt Quality Gate
on: [push]
jobs:
  test-prompts:
    runs-on: ubuntu-latest
    steps:
      - name: Run Golden Dataset Tests
        run: |
          # Test against 50-200 curated cases
          python scripts/eval_prompts.py \
            --dataset golden_dataset.json \
            --judge-model gpt-4 \
            --min-score 0.85

      - name: Regression Check
        run: |
          # Compare new version vs. production
          python scripts/compare_versions.py \
            --staging v2.1.0 \
            --production v2.0.3 \
            --threshold 0.05

ایک پرامپٹ صرف اس وقت Staging سے Production میں ترقی پاتا ہے جب وہ ان کوالٹی گیٹس سے گزر جاتا ہے جسے "LLM-as-a-judge” اسکور کرتا ہے۔

نتیجہ

فارمیٹرز کے ساتھ ساختی پرامپٹ انجینئرنگ اب اختیاری نہیں ہے — یہ ان سب کے لیے بنیادی معیار ہے جو قابل اعتماد اے آئی ٹولز بناتے ہیں۔ RTCCO فریم ورک، XML ڈیلیمیٹرز، اور ماڈیولر آرکیٹیکچر وہ اسٹیک ہیں جو غیر متوقع LLM آؤٹ پٹس کو مستقل، پروڈکشن گریڈ نتائج میں تبدیل کرتے ہیں۔

اپنے سب سے زیادہ استعمال ہونے والے پرامپٹس سے شروع کریں اور انہیں اوپر دیے گئے XML ٹیمپلیٹ کا استعمال کرتے ہوئے RTCCO فریم ورک میں دوبارہ ترتیب دیں۔ انہیں ورژن کنٹرول میں منتقل کریں، بنیادی تشخیص سیٹ اپ کریں، اور آپ کے پاس ایک ایسا پرامپٹ انفراسٹرکچر ہوگا جو پیمانے پر ہے۔

اکثر پوچھے جانے والے سوالات

میں اپنے موجودہ پیراگراف پرامپٹس کو RTCCO بلاک فارمیٹ میں کیسے تبدیل کروں؟

پہلے بنیادی Task کی نشاندہی کریں اور اسے Context سے الگ کریں۔ ہدایات کو <rules> ٹیگز میں لپیٹیں اور <examples> ٹیگز میں 3-5 مثالیں فراہم کریں۔ آپ مدد کے لیے ایک LLM بھی استعمال کر سکتے ہیں — اسے "اس غیر ساختی ٹیکسٹ کو XML ڈیلیمیٹرز کا استعمال کرتے ہوئے RTCCO فریم ورک میں دوبارہ پارس کرو” کہہ کر پرامپٹ کریں اور یہ بھاری کام کرے گا۔

کیا میں XML، JSON، یا Markdown ڈیلیمیٹرز استعمال کروں؟

XML کلائڈ اور GPT-5 جیسے ماڈلز میں ہدایات کو طویل فارم مواد سے الگ کرنے کے لیے موجودہ گولڈن اسٹینڈرڈ ہے کیونکہ اس کی سخت درجہ بندی ہے۔ JSON تب بہتر ہے جب آپ کو API انٹیگریشنز کے لیے پروگرامیٹک ان پٹ/آؤٹ پٹ درکار ہو۔ Markdown سادہ، انسان کے لیے پڑھنے کے قابل پرامپٹس کے لیے کام کرتا ہے لیکن پیچیدہ، کثیر پرتوں والے پروڈکشن پرامپٹس کے لیے ضروری سخت حد بندی کی تعریف کی کمی ہے۔

میں پرامپٹس کے لیے خودکار CI/CD ٹیسٹنگ کیسے نافذ کروں؟

ایک ٹیسٹنگ سوٹ سیٹ اپ کریں جس میں "گولڈن ڈیٹا سیٹ” (50-200 منتخب کردہ ٹیسٹ کیسز) اور "LLM-as-a-judge” شامل ہو جو آؤٹ پٹس کو ربرک کے خلاف اسکور کرے۔ ان ٹیسٹس کو اپنے GitHub Actions یا Jenkins پائپ لائن میں شامل کریں تاکہ کوئی بھی پرامپٹ تبدیلی ڈپلائمنٹ سے پہلے درستگی اور انداز کے لیے تصدیق شدہ ہو۔

ساختی پرامپٹس میں تبدیل کرتے وقت سب سے عام غلطی کیا ہے؟

<context> بلاک کو زیادہ بوجھ دینا۔ ڈویلپرز اکثر پورے کوڈ بیس یا دستاویزات کو کونٹیکسٹ میں ڈال دیتے ہیں، جو ماڈل کی توجہ کمزور کر دیتا ہے۔ کونٹیکسٹ کو صرف اس چیز پر مرکوز رکھیں جو کام سے براہ راست متعلق ہے۔ اگر آپ کو بڑی دستاویزات کا حوالہ دینے کی ضرورت ہے، تو RAG ریٹریول استعمال کریں تاکہ صرف متعلقہ حصے حاصل کیے جا سکیں۔