Perbandingan output terstruktur di antara penyedia LLM populer - OpenAI, Gemini, Anthropic, Mistral, dan AWS Bedrock

API yang sedikit berbeda memerlukan pendekatan khusus.

Konten Halaman

Berikut adalah perbandingan dukungan sampingan untuk output terstruktur (mendapatkan JSON yang andal) di berbagai penyedia LLM populer, beserta contoh Python minimal

batang berwarna yang berdiri

Kita sudah melihat bagaimana cara meminta output terstruktur dari LLM yang dihosting di Ollama. Di sini kita akan meninjau bagaimana cara meminta hal yang sama dari penyedia lain.

TL;DR matriks

Penyedia Mode JSON “Bawaan” Pemaksaan JSON Schema Knob Tipeikal Catatan
OpenAI Ya Ya (kelas satu) response_format={"type":"json_schema", ...} Berfungsi melalui Responses API atau Chat Completions; juga dapat melakukan pemanggilan fungsi.
Google Gemini Ya Ya (kelas satu) response_schema= + response_mime_type="application/json" Mengembalikan JSON yang divalidasi secara ketat ketika skema diatur.
Anthropic (Claude) Tidak langsung Ya (melalui Tool Use dengan JSON schema) tools=[{input_schema=...}] + tool_choice Memaksa model untuk “memanggil” alat yang Anda definisikan dengan skema; menghasilkan argumen yang sesuai dengan skema.
Mistral Ya Sebagian (hanya JSON; tidak ada skema server-side) response_format={"type":"json_object"} Memastikan JSON, tetapi Anda memvalidasinya terhadap skema Anda secara klien-side.
AWS Bedrock (platform) Bervariasi per model Ya (melalui Tool/Converse schema) toolConfig.tools[].toolSpec.inputSchema API Converse Bedrock memvalidasi input alat terhadap skema JSON.

Output Terstruktur LLM - Informasi Umum

Output terstruktur LLM merujuk pada kemampuan model bahasa besar (LLMs) untuk menghasilkan respons yang secara ketat mematuhi format atau struktur yang ditentukan sebelumnya, bukan menghasilkan teks bebas. Output terstruktur ini dapat berupa format seperti JSON, XML, tabel, atau template, sehingga data dapat dibaca oleh mesin, konsisten, dan mudah diparse oleh perangkat lunak untuk digunakan dalam berbagai aplikasi.

Output terstruktur berbeda dari output LLM tradisional, yang biasanya menghasilkan teks alami yang terbuka. Sebaliknya, output terstruktur memaksa skema atau format tertentu, seperti objek JSON dengan kunci dan jenis nilai yang didefinisikan, atau kelas tertentu dalam output (misalnya, jawaban pilihan ganda, kelas sentimen, atau format baris database). Pendekatan ini meningkatkan keandalan, mengurangi kesalahan dan halusinasi, serta menyederhanakan integrasi ke dalam sistem seperti database, API, atau alur kerja.

Penghasilan output terstruktur dalam LLM sering kali melibatkan teknik seperti:

  • Menentukan instruksi prompt yang rinci untuk memandu model menghasilkan output dalam format yang diinginkan.
  • Menggunakan alat validasi dan parsing seperti Pydantic dalam Python untuk memastikan output sesuai dengan skema.
  • Terkadang memaksa pembatasan dekoding berdasarkan tata bahasa atau mesin keadaan akhir untuk memastikan kepatuhan tingkat token terhadap format.

Manfaat output terstruktur LLM meliputi:

  • Membaca mesin dan kemudahan integrasi.
  • Mengurangi variabilitas dan kesalahan.
  • Meningkatkan prediktabilitas dan verifikasi untuk tugas yang memerlukan format data yang konsisten.

Tantangan meliputi desain skema yang efektif, penanganan data bersarang yang kompleks, dan potensi keterbatasan kemampuan penalaran dibandingkan dengan generasi teks bebas.

Secara keseluruhan, output terstruktur memungkinkan LLM lebih berguna dalam aplikasi yang memerlukan data yang tepat dan terformat, bukan hanya teks yang dapat dibaca manusia.

Contoh Python Output Terstruktur

Semua potongan kode mengekstrak informasi acara sebagai JSON: {judul, tanggal, lokasi}. Ganti kunci/model sesuka Anda.

1) OpenAI — JSON Schema (ketat)

from openai import OpenAI
import json

client = OpenAI()

schema = {
    "name": "Event",
    "schema": {
        "type": "object",
        "properties": {
            "title": {"type": "string"},
            "date":  {"type": "string", "description": "YYYY-MM-DD"},
            "location": {"type": "string"}
        },
        "required": ["title", "date", "location"],
        "additionalProperties": False
    },
    "strict": True
}

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": "Ekstrak acara dari: 'PyData Sydney adalah pada 2025-11-03 di Darling Harbour.'"}
    ],
    response_format={"type": "json_schema", "json_schema": schema},
)

data = json.loads(resp.choices[0].message.content)
print(data)

Fitur Output Terstruktur OpenAI memaksa skema ini di sisi server.

2) Google Gemini — skema respons + MIME JSON

import google.generativeai as genai
from google.genai import types

# Konfigurasi dengan API key Anda
# genai.configure(api_key="your-api-key")

schema = types.Schema(
    type=types.Type.OBJECT,
    properties={
        "title": types.Schema(type=types.Type.STRING),
        "date": types.Schema(type=types.Type.STRING),
        "location": types.Schema(type=types.Type.STRING),
    },
    required=["title", "date", "location"],
    additional_properties=False,
)

resp = genai.generate_content(
    model="gemini-2.0-flash",
    contents="Ekstrak acara dari: 'PyData Sydney adalah pada 2025-11-03 di Darling Harbour.'",
    generation_config=genai.GenerationConfig(
        response_mime_type="application/json",
        response_schema=schema,
    ),
)

print(resp.text)  # sudah valid JSON sesuai skema

Gemini akan mengembalikan JSON ketat yang sesuai dengan response_schema.

3) Anthropic (Claude) — Penggunaan Alat dengan JSON schema

from anthropic import Anthropic
import json

client = Anthropic()

tool = {
    "name": "extract_event",
    "description": "Kembalikan detail acara.",
    "input_schema": {
        "type": "object",
        "properties": {
            "title": {"type": "string"},
            "date": {"type": "string"},
            "location": {"type": "string"}
        },
        "required": ["title", "date", "location"],
        "additionalProperties": False
    }
}

msg = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=256,
    tools=[tool],
    tool_choice={"type": "tool", "name": "extract_event"},  # paksa skema
    messages=[{"role": "user", "content":
        "Ekstrak acara dari: 'PyData Sydney adalah pada 2025-11-03 di Darling Harbour.'"}],
)

# Claude akan "memanggil" alat; ambil argumen (yang sesuai dengan skema Anda)
tool_use = next(b for b in msg.content if b.type == "tool_use")
print(json.dumps(tool_use.input, indent=2))

Claude tidak memiliki saklar “mode JSON” umum; sebaliknya, Penggunaan Alat dengan input_schema memberi Anda argumen yang divalidasi dan sesuai dengan skema (dan Anda dapat memaksa penggunaannya).

4) Mistral — mode JSON (validasi sisi klien)

from mistralai import Mistral
import json

client = Mistral()

resp = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role":"user","content":
        "Kembalikan JSON dengan kunci judul, tanggal (YYYY-MM-DD), lokasi untuk: "
        "'PyData Sydney adalah pada 2025-11-03 di Darling Harbour.'"}],
    response_format={"type": "json_object"}  # memastikan JSON valid
)

data = json.loads(resp.choices[0].message.content)
print(data)
# Tips: validasi `data` terhadap skema Pydantic/JSON Anda secara lokal.

json_object Mistral memaksa bentuk JSON (tidak skema yang tepat) — validasi sisi klien.

5) AWS Bedrock — API Converse Tool schema (model-agnostic)

import boto3, json

bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
model_id = "anthropic.claude-3-5-sonnet-20240620-v1:0"

tools = [{
    "toolSpec": {
        "name": "extract_event",
        "inputSchema": {
            "json": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "date": {"type": "string"},
                    "location": {"type": "string"}
                },
                "required": ["title","date","location"],
                "additionalProperties": False
            }
        }
    }
}]

resp = bedrock.converse(
    modelId=model_id,
    toolConfig={"tools": tools},
    toolChoice={"tool": {"name": "extract_event"}},  # paksa skema
    messages=[{"role":"user","content":[{"text":
        "Ekstrak acara dari: 'PyData Sydney adalah pada 2025-11-03 di Darling Harbour.'"}]}],
)

# Ambil konten toolUse
tool_use = next(
    c["toolUse"] for c in resp["output"]["message"]["content"] if "toolUse" in c
)
print(json.dumps(tool_use["input"], indent=2))

Bedrock memvalidasi input alat terhadap skema JSON Anda dan banyak model yang dihosting (misalnya, Claude) mendukungnya melalui Converse.

Panduan Praktis dan Validasi

  • Jika Anda ingin jaminan sisi server terkuat: Output terstruktur OpenAI atau skema respons Gemini.
  • Jika Anda sudah menggunakan Claude/Bedrock: definisikan Alat dengan skema JSON dan paksa penggunaannya; baca argumen alat sebagai objek bertipe Anda.
  • Jika Anda menggunakan Mistral: aktifkan json_object dan validasi secara lokal (misalnya, dengan Pydantic).

Polanya validasi (berfungsi untuk semua penyedia)

from pydantic import BaseModel, ValidationError

class Event(BaseModel):
    title: str
    date: str
    location: str

try:
    event = Event.model_validate(data)  # `data` dari penyedia apa pun
except ValidationError as e:
    # handle / retry / minta model untuk memperbaiki dengan e.errors()
    print(e)

Tautan yang Berguna