---
title: "JSON mode vs JSON schema: output berstruktur, dengan kod"
description: "JSON mode memberi JSON yang sah; json_schema memberi bentuk anda. Cara memintanya pada model serasi OpenAI, mengesahkan dengan Pydantic, dan membaiki output rosak."
url: https://broadrouter.com/ms/blog/structured-output-json-schema/
lang: ms
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Diterjemahkan daripada bahasa Inggeris dengan bantuan AI. [Baca versi asal dalam bahasa Inggeris](https://broadrouter.com/blog/structured-output-json-schema/) (dikemas kini 2026-11-14).

# JSON mode vs json\_schema: output berstruktur yang boleh diharap

Oleh pasukan BroadNet Inference · 4 minit bacaan · Diterbitkan 2026-11-14

JSON mode (response\_format json\_object) hanya menjanjikan JSON yang sah. Output berstruktur (response\_format json\_schema) juga menjanjikan medan dan jenis anda, jika penyedia menguatkuasakannya. Walau apa pun, semak finish\_reason, huraikan, dan sahkan terhadap skema seperti model Pydantic. Jika pengesahan gagal, hantar semula ralat itu dan minta sekali lagi, dengan had cubaan yang ketat.

## Perkara utama

-   Panduan OpenAI: kedua-dua mod menghasilkan JSON yang sah, tetapi "only Structured Outputs ensure schema adherence" (Terjemahan: hanya Structured Outputs yang memastikan pematuhan skema).
-   Sokongan berbeza antara penyedia serasi OpenAI. Uji json\_schema dahulu, kemudian beralih ke json\_object, kemudian ke prompt sahaja.
-   Sahkan setiap jawapan. Jawapan yang terpotong oleh max\_tokens ialah JSON yang rosak walau apa pun kata skema.
-   Gelung pembaikan berfungsi apabila anda menghantar semula ralat pengesahan yang tepat. Hadkannya kepada dua atau tiga cubaan.
-   Di BroadNet Inference, GLM 5.3 dan Qwen3.8 27B menyenaraikan output berstruktur.

**Dalam halaman ini**

1.  Apakah perbezaan antara JSON mode dan json\_schema?
2.  Bagaimanakah meminta json\_schema?
3.  Mod manakah yang disokong oleh penyedia anda?
4.  Bagaimanakah mengesahkan dan membaiki output yang rosak?
5.  Ciri skema manakah yang menimbulkan masalah?
6.  Bagaimanakah memantau output berstruktur dalam pengeluaran?
7.  Bilakah anda patut menggunakan tool sebaliknya?
8.  Di manakah BroadNet Inference sesuai

Kod anda memerlukan data, dan model menulis teks. [Output berstruktur](https://broadrouter.com/ms/glossary/structured-output/) merapatkan jurang itu, tetapi “model memulangkan JSON” membawa tiga maksud berbeza bergantung pada cara anda meminta. Artikel ini membandingkan pilihan pada model terbuka yang serasi OpenAI, menunjukkan cara meminta setiap satu, dan memberi gelung sahkan-dan-baiki yang boleh terus dimasukkan ke pengeluaran.

## Apakah perbezaan antara JSON mode dan json\_schema?

| Kaedah | Permintaan | Apa yang dijanjikan |
| --- | --- | --- |
| Prompt sahaja | “Balas dalam JSON dengan medan…” | Tiada; biasanya JSON, kadangkala dengan teks tambahan |
| JSON mode | `response_format: {"type": "json_object"}` | JSON yang sah, apa-apa bentuk |
| Output berstruktur | `response_format: {"type": "json_schema", ...}` | JSON yang sepadan dengan skema anda, jika dikuatkuasakan |

Panduan Structured Outputs OpenAI menyatakannya dengan terus: “While both ensure valid JSON is produced, only Structured Outputs ensure schema adherence.” (Terjemahan: Walaupun kedua-duanya memastikan JSON yang sah dihasilkan, hanya Structured Outputs yang memastikan pematuhan skema.) Ia mengesyorkan output berstruktur berbanding JSON mode bila-bila masa yang boleh.

Pada penyedia model terbuka, jaminannya bergantung pada cara pelayan melaksanakannya. Banyak yang menggunakan penyahkodan terkekang, yang menyekat token yang akan melanggar skema. Sesetengahnya menerima medan itu tetapi tidak menguatkuasakannya. Itulah sebabnya kod di bawah tetap mengesahkan.

## Bagaimanakah meminta json\_schema?

```python
import os
from openai import OpenAI
from pydantic import BaseModel, Field

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

class Invoice(BaseModel):
    vendor: str
    currency: str = Field(pattern="^[A-Z]{3}$")
    total: float
    line_items: list[float]

schema = Invoice.model_json_schema()
schema["additionalProperties"] = False

response_format = {"type": "json_schema",
                   "json_schema": {"name": "invoice", "strict": True, "schema": schema}}
```

Pydantic menjana JSON Schema daripada kelas anda, jadi skema dan pengesah tidak akan pernah tersasar. Jika anda tidak menggunakan Pydantic, [penjana skema JSON](https://broadrouter.com/tools/json-schema-generator/) membina skema strict mode daripada objek sampel. Untuk strict mode, OpenAI memerlukan `additionalProperties: false` dan setiap sifat disenaraikan sebagai wajib.

## Mod manakah yang disokong oleh penyedia anda?

Jalankan ujian ini sekali bagi setiap model sebelum membina di atasnya:

1.  Hantar `json_schema` dengan prompt yang mengundang medan tambahan (“tambahkan juga komen ringkas”).
2.  Jika permintaan menghasilkan ralat, penyedia tidak menerima `json_schema`. Cuba `json_object`.
3.  Jika jawapan mengandungi medan tambahan itu, skema tidak dikuatkuasakan. Anggap ia sebagai JSON mode.
4.  Jika `json_object` juga menghasilkan ralat, gunakan prompt sahaja dengan pengesahan.

Di BroadNet Inference, dokumentasi menyenaraikan output berstruktur untuk [GLM 5.3](https://broadrouter.com/ms/models/glm-5.3/) dan [Qwen3.8 27B](https://broadrouter.com/ms/models/qwen3.8-27b/) ([dibandingkan bersebelahan](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/)), tetapi tidak menamakan parameter permintaan. Jalankan ujian di atas pada model yang anda gunakan dalam produk.

## Bagaimanakah mengesahkan dan membaiki output yang rosak?

```python
import json
from pydantic import ValidationError

def extract(text: str, model="broadnet/glm-5.3", attempts=3) -> Invoice:
    messages = [
        {"role": "system", "content": "Extract the invoice. Reply with JSON only."},
        {"role": "user", "content": text},
    ]
    for attempt in range(attempts):
        r = client.chat.completions.create(model=model, messages=messages,
                                           response_format=response_format,
                                           max_tokens=4000)
        choice = r.choices[0]
        if choice.finish_reason == "length":
            raise RuntimeError("Cut off: raise max_tokens")  # retrying won't help
        if getattr(choice.message, "refusal", None):
            raise RuntimeError(f"Refused: {choice.message.refusal}")
        raw = choice.message.content or ""
        try:
            inv = Invoice.model_validate_json(raw)
            if abs(sum(inv.line_items) - inv.total) > 0.01:
                raise ValueError("total must equal the sum of line_items")
            return inv
        except (ValidationError, ValueError) as e:
            messages += [
                {"role": "assistant", "content": raw},
                {"role": "user", "content": f"That JSON is invalid: {e}. Return corrected JSON only."},
            ]
    raise RuntimeError(f"No valid JSON after {attempts} attempts")
```

Apa yang membuat gelung ini berfungsi:

-   **Semak `finish_reason` dahulu.** Jawapan yang mencapai [`max_tokens`](https://broadrouter.com/ms/glossary/max-tokens/) ialah JSON yang terpotong. Mencuba semula dengan had yang sama gagal dengan cara yang sama. Kedua-dua model di atas membuat penaakulan sebelum menjawab, dan [penaakulan dikira dalam had](https://broadrouter.com/ms/guides/reasoning-tokens-empty-response/), jadi beri ruang.
-   **Kendalikan penolakan secara berasingan.** Panduan OpenAI menyatakan penolakan “does not necessarily follow the schema you have supplied” (Terjemahan: tidak semestinya mengikut skema yang anda berikan).
-   **Hantar semula ralat yang tepat.** Cuba semula secara membuta tuli sering memulangkan kesilapan yang sama. “line\_items: field required” memberi model sesuatu untuk dibetulkan.
-   **Semak peraturan perniagaan dalam kod.** Skema tidak boleh menyatakan bahawa jumlah mesti sama dengan item barisnya. Semakan di atas boleh.
-   **Hadkan cubaan.** Setiap cubaan menghantar semula keseluruhan prompt sebagai [token input](https://broadrouter.com/ms/glossary/input-and-output-tokens/).

## Ciri skema manakah yang menimbulkan masalah?

Pastikan skema ringkas dan membosankan:

1.  **Rata lebih baik daripada bersarang.** Dua tahap sudah memadai untuk kebanyakan pengekstrakan.
2.  **Enum dan bukannya rentetan bebas** untuk kategori.
3.  **Tiada objek terbuka.** Medan `dict` bentuk bebas mematahkan tujuannya.
4.  **Nama medan pendek dengan penerangan.** Penerangan dalam skema membimbing model.
5.  **Medan pilihan sebagai nullable.** Dalam strict mode, senaraikan setiap medan sebagai wajib dan benarkan `null`.

Panduan OpenAI menyatakan sesetengah ciri JSON Schema tidak disokong dalam strict mode. Pelayan model terbuka mempunyai had mereka sendiri. Jika skema ditolak, permudahkannya sebelum menukar mod.

## Bagaimanakah memantau output berstruktur dalam pengeluaran?

Gelung yang membaiki secara senyap boleh menyembunyikan masalah yang membazirkan token setiap hari. Log tiga angka bagi setiap tempat panggilan:

| Metrik | Apa yang diberitahunya |
| --- | --- |
| Kadar kejayaan cubaan pertama | Sejauh mana model dan skema sepadan; penurunan sering berlaku selepas perubahan prompt atau model |
| Purata cubaan bagi setiap kejayaan | Kos token untuk pembaikan |
| Kegagalan akhir | Input yang tidak dapat dikendalikan pipeline anda; semaknya secara manual |

Jika kejayaan cubaan pertama jatuh di bawah tahap biasa, permudahkan skema atau cuba model lain sebelum menambah lebih banyak cuba semula. Simpan sampel jawapan mentah yang gagal, supaya anda boleh menguji pembetulan terhadap kes sebenar.

## Bilakah anda patut menggunakan tool sebaliknya?

Gunakan output berstruktur untuk **jawapan akhir**: pengekstrakan, klasifikasi, pelan. Gunakan [panggilan tools](https://broadrouter.com/ms/blog/tool-calling-open-models/) apabila model memerlukan kod anda untuk **melakukan** sesuatu dan meneruskan. Banyak ejen menggunakan kedua-duanya: tools semasa gelung, skema untuk langkah terakhir. Untuk contoh imej ke JSON, lihat [membaca invois bahasa Arab dengan model visi](https://broadrouter.com/ms/guides/read-arabic-invoices-with-vision/).

## Di manakah BroadNet Inference sesuai

BroadNet Inference menyenaraikan output berstruktur untuk GLM 5.3 dan Qwen3.8 27B, di sebalik format chat-completions standard, jadi kod di atas berjalan dengan [SDK Python OpenAI](https://broadrouter.com/ms/guides/openai-python-sdk/) tanpa perubahan. Qwen3.8 27B juga menerima imej, yang sesuai untuk pengekstrakan dokumen. Dokumentasi BroadNet tidak menyatakan output berstruktur untuk DeepSeek V4.1 Flash atau Gemma 4 VL 26B, jadi gunakan laluan prompt sahaja dengan pengesahan di sana. Bandingkan harga setiap token di [halaman harga](https://broadrouter.com/ms/pricing/).

Alat percuma untuk topik ini (Bahasa Inggeris)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Alatan percuma (Bahasa Inggeris)](https://broadrouter.com/tools/)

## Istilah dalam artikel ini

[Output berstruktur (structured output)](https://broadrouter.com/ms/glossary/structured-output/)

Output berstruktur ialah ciri API LLM yang mengehadkan balasan model kepada format yang ditetapkan oleh pembangun, biasanya JSON Schema, supaya kod boleh menghuraikannya dengan boleh dipercayai. Ia lebih ketat daripada JSON mode, yang menjamin JSON yang sah tetapi bukan bentuk tertentu.

[JSON Schema (skema JSON)](https://broadrouter.com/ms/glossary/json-schema/)

JSON Schema ialah perbendaharaan kata, ditulis dalam JSON, untuk menerangkan dan mengesahkan struktur data JSON: jenis, medan wajib, nilai yang dibenarkan dan penyarangan. Versi semasa ialah 2020-12. API LLM menggunakannya untuk mentakrifkan parameter alat dan bentuk tepat yang mesti diikuti oleh output berstruktur.

[Token](https://broadrouter.com/ms/glossary/token/)

Token ialah unit teks yang dibaca dan ditulis oleh model bahasa: satu perkataan, sebahagian perkataan, tanda baca atau jujukan bait yang dihasilkan oleh tokenizer model itu. API LLM mengira, mengehadkan dan biasanya mengebil penggunaan dalam token.

[Mod JSON (JSON mode)](https://broadrouter.com/ms/glossary/json-mode/)

Mod JSON ialah tetapan API LLM, response\_format {"type": "json\_object"} dalam API gaya OpenAI, yang menjadikan jawapan model JSON yang sah dan boleh dihurai. Tidak seperti structured outputs dengan JSON Schema, ia tidak menjamin kunci, jenis atau nilai yang terkandung dalam objek itu.

[Model open-weight (model pemberat terbuka)](https://broadrouter.com/ms/glossary/open-weight-model/)

Model open-weight ialah model pembelajaran mesin yang pemberat terlatihnya diterbitkan untuk dimuat turun dan dijalankan oleh sesiapa sahaja, biasanya di bawah lesen bersyarat. Ia berbeza daripada AI sumber terbuka sepenuhnya, yang turut mengeluarkan kod latihan dan maklumat terperinci tentang data latihan supaya orang lain boleh mengkaji dan menghasilkan semula model itu.

[Tool calling (panggilan alatan)](https://broadrouter.com/ms/glossary/tool-calling/)

Tool calling, juga dipanggil function calling, ialah ciri API LLM di mana model memulangkan permintaan berstruktur untuk menjalankan fungsi yang ditakrifkan oleh pembangun, bersama argumen JSON. Aplikasi menjalankan fungsi itu dan menghantar hasilnya kembali; model sendiri tidak pernah menjalankan kod.

[Token input dan output (input and output tokens)](https://broadrouter.com/ms/glossary/input-and-output-tokens/)

Token input ialah token yang dibaca oleh model bahasa dalam satu permintaan, termasuk prompt sistem, sejarah perbualan, definisi alatan dan imej. Token output ialah token yang dijananya sebagai balasan, termasuk sebarang penaakulan. API LLM biasanya meletakkan harga berasingan, dan output biasanya lebih mahal.

## Soalan lazim

### Apakah perbezaan antara JSON mode dan output berstruktur?

JSON mode, response\_format jenis json\_object, hanya menjanjikan jawapan boleh dihuraikan sebagai JSON. Output berstruktur, jenis json\_schema, juga menjanjikan medan dan jenis yang anda tetapkan, jika penyedia menguatkuasakannya. OpenAI mengesyorkan output berstruktur berbanding JSON mode apabila boleh.

### Adakah model terbuka menyokong response\_format json\_schema?

Bergantung pada penyedia. Sesetengahnya menerima json\_schema, sesetengahnya hanya json\_object, dan sesetengahnya mengabaikan medan itu. Hantar permintaan ujian dengan skema dan prompt yang menggoda model untuk menambah medan tambahan, kemudian semak jawapannya.

### Adakah saya masih perlu mengesahkan output berstruktur?

Ya. Jawapan boleh terpotong oleh max\_tokens, boleh berupa penolakan, dan boleh melanggar peraturan perniagaan yang tidak dapat dinyatakan oleh skema, seperti jumlah yang mesti sepadan.

### Berapa kali saya patut mencuba semula JSON yang tidak sah?

Dua atau tiga cubaan dengan ralat pengesahan disertakan biasanya sudah cukup. Selepas itu, log input dan hantar ke laluan sandaran, model yang lebih kuat atau manusia. Gelung tanpa had membazirkan token.

### Patutkah saya menggunakan output berstruktur atau panggilan tools?

Gunakan output berstruktur apabila anda mahu jawapan akhir dalam bentuk tetap. Gunakan panggilan tools apabila model memerlukan kod anda melakukan sesuatu dan kemudian meneruskan.

## Teruskan membaca

-   [Pengelasan teks bahasa Arab dengan LLM: sentimen, niat, triaj](https://broadrouter.com/ms/blog/arabic-text-classification-llm/)
-   [Tool calling pada model terbuka: skema, panggilan selari, cuba semula](https://broadrouter.com/ms/blog/tool-calling-open-models/)
-   [Beralih ke API serasi OpenAI: senarai semak migrasi](https://broadrouter.com/ms/blog/openai-compatible-api-migration-checklist/)
-   [n8n AI Agent pada LLM murah: persediaan, pilihan model, kos larian](https://broadrouter.com/ms/blog/n8n-ai-agent-cheap-llm/)
-   [Cara membaiki JSON tidak sah daripada LLM: punca, baiki, cuba semula](https://broadrouter.com/ms/blog/fix-invalid-json-from-llm/)
-   [Pengekstrakan entiti bernama bahasa Arab dengan LLM: JSON dan tarikh](https://broadrouter.com/ms/blog/arabic-named-entity-extraction-llm/)
-   [Perkakasan GPU dan pendekatan penyajian BroadNet, menurut BroadNet](https://broadrouter.com/ms/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache respons API LLM untuk jimat kos: cache padanan tepat Python](https://broadrouter.com/ms/blog/cache-llm-responses-cut-cost/)
-   [Panduan: Cara guna OpenAI Python SDK dengan BroadNet Inference](https://broadrouter.com/ms/guides/openai-python-sdk/)
-   [Panduan: Baca invois dan resit Arab dengan model vision](https://broadrouter.com/ms/guides/read-arabic-invoices-with-vision/)
-   [Panduan: Mengapa model penaakulan memulangkan jawapan kosong](https://broadrouter.com/ms/guides/reasoning-tokens-empty-response/)

Cuba dengan beban kerja sebenar anda. Akaun baharu bermula dengan kredit US$5 untuk Gemma dan transkripsi. DeepSeek, GLM dan Qwen3.8 memerlukan tambah nilai.

[Mulakan](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=ms-blog-structured-output-json-schema&utm_content=page-cta) ·

**Sumber**

-   [OpenAI, panduan Structured Outputs (disemak 2026-11-14)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [Rujukan API OpenAI, create chat completion (response\_format)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
-   [Dokumentasi Pydantic, JSON Schema dan pengesahan](https://docs.pydantic.dev/latest/concepts/json_schema/)
-   [Rujukan API BroadNet Inference, model (Bahasa Inggeris)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ms-blog-structured-output-json-schema&utm_content=sources#models)
