Structured Outputs Claude Bedrock Rilis: JSON Dijamin Valid

Apa Itu Structured Outputs Claude di Amazon Bedrock?

Secara sederhana, structured outputs adalah fitur yang memaksa Claude memproduksi jawaban yang 100% sesuai dengan skema JSON (JSON schema) yang kamu tentukan. Fitur ini berlaku buat semua model Anthropic Claude yang tersedia di Amazon Bedrock, mulai dari Claude Haiku 5.5 sampai Claude Sonnet 5.

Sebelum adanya update ini, kalau kamu butuh JSON rapi, kamu biasanya mengandalkan prompt engineering tingkat dewa. Kamu bakal menulis prompt panjang lebar, ngasih contoh few-shot, lalu memasang library validator kayak Pydantic atau Zod di sisi backend. Kalau formatnya meleset, aplikasimu bakal melempar error JSON.parse() dan terpaksa memanggil API lagi lewat mekanisme retry. Cara lama ini nggak cuma bikin aplikasi lemot, tapi juga bikin tagihan cloud membengkak karena kamu bayar token untuk output yang gagal dibaca.

Lewat structured outputs di Amazon Bedrock, kamu nggak perlu lagi trik-trik ribet kayak gitu. Setiap field yang kamu wajibkan dipastikan selalu muncul, tipe datanya sesuai (string tetap string, boolean tetap boolean), dan model nggak bakal menyelipkan teks obrolan di luar kurung kurawal JSON.

Dua Cara Kerja: JSON Schema Output Format vs Strict Tool Use

AWS menyediakan dua mekanisme pelengkap buat memakai structured outputs di Amazon Bedrock. Keduanya dirancang buat kebutuhan arsitektur yang berbeda:

Fitur JSON Schema output format sangat pas kalau kamu butuh data langsung dari dokumen mentah atau teks pengguna. Misalnya, kamu memasukkan email keluhan pelanggan dan ingin Claude langsung membalas dalam objek JSON tanpa teks basa-basi.

Sementara itu, Strict tool use dirancang buat agentic workflow di mana Claude bertindak sebagai perencana yang memanggil berbagai tools internal. Saat memakai strict mode, parameter fungsi yang dikirim Claude ke sistemmu dijamin valid. Nggak bakal ada kasus di mana fungsi database mengharapkan integer tapi Claude malah mengirimkan teks.

Cara Kerja di Balik Layar: Constrained Decoding dan Caching

Banyak developer mengira AWS cuma memasang filter regex setelah Claude selesai menulis. Nyatanya, cara kerja fitur ini jauh lebih canggih karena memanfaatkan constrained decoding (dekode terbatas).

Begitu Claude men-generate teks token per token, mesin Amazon Bedrock secara aktif membatasi pilihan token berikutnya hanya pada token yang secara matematis valid menurut JSON schema kamu. Model secara fisik nggak diizinkan memproduksi karakter yang melanggar aturan skema. Inilah yang bikin sifat outputnya berubah dari probabilistik (tebak-tebakan probabilitas) menjadi deterministik (pasti patuh aturan).

Alur pemrosesan di balik layar berjalan lewat empat tahap:

1. Schema validation: Bedrock mengecek apakah skema kamu memenuhi standar subset JSON Schema Draft 2020-12 yang didukung.
2. Grammar compilation: Bedrock mengompilasi skema tersebut menjadi artefak grammar internal. Tahap kompilasi pertama ini butuh sedikit waktu ekstra pada request awal.
3. Caching: Artefak grammar yang sudah jadi bakal disimpan dalam cache selama 24 jam penuh di tingkat akun AWS kamu. Request berikutnya yang memakai skema yang sama bakal langsung ngebut tanpa overhead kompilasi.
4. Constrained generation: Model menghasilkan token yang otomatis menyusun JSON valid sesuai grammar tadi.

Tutorial Boto3: Ekstraksi Data Email Pakai InvokeModel API

Untuk mulai nyobain fitur ini di endpoint bedrock-runtime, kamu bisa memakai SDK Python resmi AWS yaitu Boto3. Skema JSON dimasukkan langsung ke dalam parameter output_config.format sebagai objek JSON bawaan Python (bukan string mentah).

Berikut contoh script lengkap buat mengekstrak data prospek (lead) dari email pelanggan memakai model Claude Sonnet 5.5:

import boto3
import json

REGION = "us-east-1"
bedrock_runtime = boto3.client(service_name="bedrock-runtime", region_name=REGION)

# Definisikan JSON schema yang wajib dipatuhi Claude
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string", "description": "Customer name"},
        "email": {"type": "string", "description": "Customer email address"},
        "plan_interest": {"type": "string", "description": "Product plan of interest"},
        "demo_requested": {"type": "boolean", "description": "Whether a demo was requested"}
    },
    "required": ["name", "email", "plan_interest", "demo_requested"],
    "additionalProperties": False
}

# Panggil Claude via InvokeModel API
response = bedrock_runtime.invoke_model(
    modelId="global.anthropic.claude-sonnet-5-5",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 512,
        "messages": [
            {
                "role": "user",
                "content": (
                    "Paulo Santos ([email protected]) is interested in our Enterprise plan "
                    "and wants to schedule a demo for next Tuesday at 2pm."
                )
            }
        ],
        "output_config": {
            "format": {
                "type": "json_schema",
                "schema": schema
            }
        }
    })
)

body = json.loads(response["body"].read())

# Cek stop_reason sebelum memproses hasil
if body["stop_reason"] == "end_turn":
    result_text = next(b["text"] for b in body["content"] if b["type"] == "text")
    print(json.dumps(json.loads(result_text), indent=2))
elif body["stop_reason"] == "max_tokens":
    print("Response truncated: increase max_tokens and retry.")

Hasil output dari script di atas bakal langsung berupa objek JSON bersih tanpa embel-embel markdown backtick:

{
  "name": "Paulo Santos",
  "email": "[email protected]",
  "plan_interest": "Enterprise",
  "demo_requested": true
}

Kamu bisa langsung melempar hasil parsing tersebut ke database produksi atau sistem CRM tanpa perlu khawatir formatnya rusak di tengah jalan.

Strict Tool Use di Bedrock Mantle Buat Agentic Workflow

Kalau kamu sedang merancang AI agent yang bisa menjalankan tindakan otomatis di server, kamu bisa memanfaatkan endpoint Amazon Bedrock Mantle. Endpoint ini memang dioptimalkan buat alur kerja agen yang butuh server-side tools, background inference, dan percakapan stateful.

Di Bedrock Mantle, kamu bisa menambahkan opsi "strict": True pada deklarasi tool. Dengan opsi ini, Claude dilarang keras mengarang argumen di luar skema input tool yang sudah kamu pasang.

import json
from anthropic import AnthropicBedrockMantle

client = AnthropicBedrockMantle(aws_region="us-east-1")

message = client.messages.create(
    model="anthropic.claude-sonnet-5",
    max_tokens=512,
    messages=[{"role": "user", "content": "What's the weather like in San Francisco?"}],
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather for a specified location",
            "strict": True,
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g., San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location", "unit"],
                "additionalProperties": False
            }
        }
    ]
)

for block in message.content:
    if block.type == "tool_use":
        print(f"Tool: {block.name}")
        print(f"Input: {json.dumps(block.input, indent=2)}")

Karena opsi strict aktif, parameter unit pasti bernilai salah satu dari enum (celsius atau fahrenheit). Model nggak bakal bisa memasukkan input lain kayak "kelvin" atau menambahkan properti dadakan. Kalau kamu tertarik mendalami arsitektur agen yang aman dan teruji di AWS, kamu juga bisa membaca artikel kami tentang evaluasi AI agent Amazon Bedrock AgentCore.

Contoh Klasifikasi Tiket Support Skala Besar Pakai Haiku 5.5

Untuk tugas-tugas berulang yang butuh kecepatan tinggi dan biaya murah—kayak klasifikasi tiket komplain pelanggan, peringkasan ringkas, atau query database—kamu bisa memakai model Claude Haiku 5.5. Model ini lincah banget kalau dipadukan dengan structured outputs.

Berikut contoh script untuk mengklasifikasi tiket komplain secara otomatis:

import boto3
import json

REGION = "us-east-1"
bedrock_runtime = boto3.client(service_name="bedrock-runtime", region_name=REGION)

schema = {
    "type": "object",
    "properties": {
        "category": {
            "type": "string",
            "enum": ["billing", "technical", "account", "sales", "other"],
            "description": "Primary ticket category"
        },
        "priority": {
            "type": "string",
            "enum": ["low", "medium", "high", "urgent"],
            "description": "Urgency based on business impact"
        },
        "sentiment": {
            "type": "string",
            "enum": ["positive", "neutral", "negative"],
            "description": "Customer sentiment"
        },
        "escalate": {"type": "boolean", "description": "Whether a human should review immediately"},
        "reason": {"type": "string", "description": "One-sentence justification for the classification"}
    },
    "required": ["category", "priority", "sentiment", "escalate", "reason"],
    "additionalProperties": False
}

ticket = (
    "Our production API calls have been failing with 500 errors since this morning. "
    "We're losing orders every minute. This is the second outage this month!"
)

response = bedrock_runtime.invoke_model(
    modelId="global.anthropic.claude-haiku-5-5",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "max_tokens": 512,
        "system": "You are a support ticket classifier. Classify the ticket accurately.",
        "messages": [
            {"role": "user", "content": f"Classify this support ticket:\n\n{ticket}"}
        ],
        "output_config": {"format": {"type": "json_schema", "schema": schema}}
    })
)

body = json.loads(response["body"].read())

if body["stop_reason"] == "end_turn":
    result_text = next(b["text"] for b in body["content"] if b["type"] == "text")
    result = json.loads(result_text)
    print(json.dumps(result, indent=2))
    if result["escalate"]:
        print(f"Escalating to on-call: {result['category']} / {result['priority']}")
elif body["stop_reason"] == "max_tokens":
    print("Response truncated: increase max_tokens and retry.")

Untuk workflow berskala masif, structured outputs ini juga mendukung fitur batch inference asynchronous serta cross-Region inference di endpoint bedrock-runtime. Kamu juga bisa mengalirkan respons secara real-time lewat teknik streaming typed events.

Bagi kamu yang butuh prompt awal untuk menguji ekstraksi data sederhana sebelum mengintegrasikannya ke Boto3, kamu bisa memakai template berikut:

Kamu adalah asisten ekstraksi data. Ekstrak informasi kontak dari teks berikut ke dalam format JSON yang valid:- Nama lengkap- Alamat email- Paket langganan yang diminati- Status permintaan demo (true/false) Teks: Budi Santoso ([email protected]) tertarik mencoba paket Enterprise dan meminta sesi demo produk untuk hari Kamis jam 10 pagi.

Aturan Wajib dan Batasan JSON Schema yang Perlu Kamu Tahu

Meskipun structured outputs ini sangat membantu, ada aturan main ketat dari AWS yang wajib kamu ikuti agar request API-mu nggak ditolak mentah-mentah.

Fitur JSON Schema yang didukung penuh meliputi tipe dasar (object, array, string, integer, number, boolean, null), nilai tetap via enum dan const, penggabungan via anyOf dan allOf dengan batasan tertentu, referensi internal ($ref, $def, definitions), format string standar (date-time, date, time, duration, email, hostname, uri, ipv4, ipv6, uuid), serta minItems pada array (khusus nilai 0 dan 1).

Selain itu, ada beberapa batasan penting yang tidak ditegakkan saat generasi token meskipun diterima oleh API:

• Skema rekursif tidak didukung.
• Referensi $ref eksternal tidak diizinkan.
• Batasan angka (minimum, maximum, multipleOf) tidak dipaksa oleh model saat generasi token.
• Batasan panjang teks (minLength, maxLength) tidak ditegakkan langsung oleh model.

Jika aplikasi kamu butuh batasan angka atau panjang teks yang kaku, validasi kedua hal tersebut tetap harus kamu jalankan di layer backend aplikasi setelah respons diterima.

Pastikan juga kodemu selalu mengecek parameter stop_reason. Model bisa saja menghasilkan output yang tidak tuntas jika terpotong batas max_tokens atau jika Claude menolak merespons karena aturan keselamatan sistem (refusal).

Dampak Nyata Buat Developer dan Tim Produk di Indonesia

Buat ekosistem software engineering di Indonesia—mulai dari startup fintech, SaaS B2B, logistik, sampai perbankan—rilisnya structured outputs di Amazon Bedrock ini ngasih dampak yang sangat nyata:

1. Arsitektur Lebih Bersih: Kamu bisa menghapus ratusan baris kode parsing regex kotor dan modul retry otomatis yang selama ini bikin codebase terasa rapuh.
2. Hemat Biaya Infrastruktur: Karena Claude tidak lagi men-generate kalimat basa-basi di awal dan akhir JSON, jumlah token output yang dihabiskan jadi jauh lebih sedikit. Di level traffic jutaan request, penghematan biaya komputasi ini bakal sangat terasa.
3. Kepatuhan Privasi Data: Banyak perusahaan Indonesia yang memilih Amazon Bedrock karena alasan kepatuhan data residensi dan keamanan enterprise. Dengan hadirnya fitur ini langsung di dalam VPC AWS mereka, integrasi AI ke data sensitif perbankan atau rekam medis elektronik bisa berjalan mulus tanpa risiko kebocoran data pihak ketiga.

Kebutuhan pipeline inferensi enterprise di cloud AWS memang berkembang cepat, mirip dengan kemudahan scaling model open source yang kami ulas di artikel TorchNeuron AWS Trainium Hugging Face.

Cara Nyobain Model Claude Lebih Simpel Lewat Classai Router

Mengonfigurasi izin IAM AWS, endpoint Bedrock, dan SDK Boto3 memang tepat untuk infrastruktur cloud skala besar. Tapi kalau kamu cuma mau bikin prototipe cepat, menguji performa Claude Sonnet 5, atau butuh integrasi API instan tanpa kartu kredit luar negeri, kamu bisa melirik Classai Router.

Classai Router menyediakan satu API key universal yang kompatibel langsung dengan SDK OpenAI maupun Anthropic Messages API. Cukup arahkan base URL ke router.classai.id/v1, dan kamu bisa langsung memanggil model Claude Sonnet 5 (claude-sonnet-5) dengan tarif Rp3.210 per 1 juta token input dan Rp15.750 per 1 juta token output. Pilihan model flagship lain kayak Claude Opus 5 (claude-opus-5) juga tersedia mulai Rp4.500 per 1 juta token input.

Kamu bisa mengisi saldo mulai dari Rp10.000 saja lewat QRIS, transfer virtual account bank lokal, atau e-wallet tanpa ribet urusan tagihan kurs valuta asing. Praktis banget buat kamu yang ingin segera menguji ketangguhan berbagai model frontier sebelum membawanya ke tahap produksi.