JSON Yerine TOON mu? LLM Token Optimizasyonunda Yeni Dönem

Yıllardır JSON’u savundum. Evrenselliği, okunabilirliği, ekosistemi… Ama son dönemde LLM entegrasyonlarında bir şeyle sık sık karşılaşmaya başladım: Token maliyetleri artık göz ardı edilemeyecek kadar kritik bir kalem. Büyük dataset’lerle çalışırken, her API call’da binlerce dolarlık fatura gördükçe, “acaba daha verimli bir yol var mı?” sorusu kafamda dönmeye başladı.

TOON (Token-Oriented Object Notation) adlı bir formatla karşılaştığımda, önce şüpheyle yaklaştım. “Yeni bir format daha mı? JSON yetmiyor mu?” diye düşündüm. Ama detaylı analiz yaptıkça sonuçlar beklediğimden çok daha ilginç çıktı. Bir sistem stratejisti ve AI uzmanı olarak, bu konuyu sadece teknik bir detay olarak görmüyorum. Bu, LLM entegrasyonlarında maliyet optimizasyonunun ve veri verimliliğinin geldiği yeni bir eşik.

Bir sistem stratejisti ve AI uzmanı olarak bu konuyu sadece teknik bir detay olarak görmüyorum. Bu, LLM entegrasyonlarında maliyet optimizasyonunun ve veri verimliliğinin geldiği yeni bir eşik. İşte elimdeki veriler ve teknik analiz.

TOON Nedir ve Teknik Altyapısı Nasıl?

TOON (Token-Oriented Object Notation), JSON’un tüm özelliklerini koruyarak LLM’ler için optimize edilmiş bir serileştirme formatı. Temelde iki yaklaşımı birleştiriyor:

• YAML’ın indentation-based yapısı: Nested object’ler için süslü parantezler yerine girinti kullanımı
• CSV’nin tabular verimliliği: Uniform array’ler için key repetition’ı elimine eden tablo formatı

Formatın asıl gücü şurada: Uniform array’lerde (aynı yapıya sahip object’lerin listesi) ciddi token tasarrufu sağlıyor. Örneğin bir kullanıcı listesinde her satırda “id”, “name”, “role” kelimelerini tekrar etmek yerine, bunları bir kez header’da declare edip sonra sadece değerleri yazıyorsunuz.

Kritik özellikler:

• Array length declaration: [N] formatıyla LLM’lere validation hook sağlıyor
• Field headers: {field1,field2,field3} ile key tekrarını önlüyor
• Delimiter awareness: Header’da delimiter declare ediliyor (comma, tab, pipe)
• Key folding: Nested single-key chain’leri dotted path’e çevirebiliyor

Benchmark Sonuçları: Rakamlar Ne Diyor?

MIT kaynaklı TOON ekibinin yaptığı kapsamlı testler, 209 farklı veri çekme sorusu üzerinde 4 farklı model (Claude Haiku 4.5, Gemini 2.5 Flash, GPT-5 Nano, Grok 4 Fast) ile gerçekleştirilmiş. Sonuçlar oldukça çarpıcı:

Retrieval Accuracy (Genel Performans)

TOON           ████████████████████   26.9  │  73.9% acc  │  2,744 tokens
JSON compact   █████████████████░░░   22.9  │  70.7% acc  │  3,081 tokens
YAML           ██████████████░░░░░░   18.6  │  69.0% acc  │  3,719 tokens
JSON           ███████████░░░░░░░░░   15.3  │  69.7% acc  │  4,545 tokens
XML            ██████████░░░░░░░░░░   13.0  │  67.1% acc  │  5,167 tokens

Dikkat çekici nokta: TOON sadece token sayısında değil, accuracy’de de öne çıkıyor. %73.9 doğruluk oranı, JSON’un %69.7’sinden belirgin şekilde yüksek. Bu, formatın LLM’lerin yapıyı daha iyi parse etmesini sağladığını gösteriyor.

Gerçek Dataset’lerde Token Tasarrufu

E-commerce orders (nested structure, %33 tabular):

• TOON: 72,771 token
• JSON (formatted): 108,806 token (-%33.1)
• JSON (compact): 68,975 token (+%5.5 TOON’dan fazla)
• YAML: 84,780 token (-%14.2)

Uniform employee records (%100 tabular):

• CSV: 46,954 token (en verimli)
• TOON: 49,831 token (+%6.1 vs CSV)
• JSON (formatted): 126,860 token (-%60.7)
• JSON (compact): 78,856 token (-%36.8)

Deeply nested configuration (%0 tabular):

• JSON (compact): 564 token (en verimli)
• TOON: 631 token (+%11.9)
• YAML: 673 token
• JSON (formatted): 919 token

Format Karşılaştırması: JSON, YAML, CSV, TOON

Aynı veriyi farklı formatlarda görelim:

JSON (Standart – 2-space indent)

{
  "users": [
    {
      "id": 1,
      "name": "Alice",
      "role": "admin",
      "lastLogin": "2025-01-15T10:30:00Z"
    },
    {
      "id": 2,
      "name": "Bob",
      "role": "user",
      "lastLogin": "2025-01-14T15:22:00Z"
    },
    {
      "id": 3,
      "name": "Charlie",
      "role": "user",
      "lastLogin": "2025-01-13T09:45:00Z"
    }
  ]
}

JSON (Compact – minified)

{"users":[{"id":1,"name":"Alice","role":"admin","lastLogin":"2025-01-15T10:30:00Z"},{"id":2,"name":"Bob","role":"user","lastLogin":"2025-01-14T15:22:00Z"},{"id":3,"name":"Charlie","role":"user","lastLogin":"2025-01-13T09:45:00Z"}]}

YAML

users:
  - id: 1
    name: Alice
    role: admin
    lastLogin: 2025-01-15T10:30:00Z
  - id: 2
    name: Bob
    role: user
    lastLogin: 2025-01-14T15:22:00Z
  - id: 3
    name: Charlie
    role: user
    lastLogin: 2025-01-13T09:45:00Z

CSV

id,name,role,lastLogin
1,Alice,admin,2025-01-15T10:30:00Z
2,Bob,user,2025-01-14T15:22:00Z
3,Charlie,user,2025-01-13T09:45:00Z

TOON (Comma-separated)

users[3]{id,name,role,lastLogin}:
  1,Alice,admin,2025-01-15T10:30:00Z
  2,Bob,user,2025-01-14T15:22:00Z
  3,Charlie,user,2025-01-13T09:45:00Z

TOON (Tab-separated – daha optimize)

users[3	]{id	name	role	lastLogin}:
  1	Alice	admin	2025-01-15T10:30:00Z
  2	Bob	user	2025-01-14T15:22:00Z
  3	Charlie	user	2025-01-13T09:45:00Z

Token analizi (GPT-5 tokenizer):

• JSON (formatted): ~340 tokens
• JSON (compact): ~210 tokens
• YAML: ~280 tokens
• CSV: ~95 tokens
• TOON (comma): ~105 tokens
• TOON (tab): ~92 tokens

Kullanım Senaryoları: Ne Zaman Hangisi?

1. TOON’un Üstün Olduğu Durumlar

• Uniform/semi-uniform array’ler (%40+ tabular eligibility): Kullanıcı listeleri, ürün katalogları, analytics data
• LLM prompt engineering: Structured output generation, few-shot examples
• Token-critical uygulamalar: Büyük context window’lar, frequent API calls
• RAG sistemleri: Document indexing, embedding optimization

2. JSON’un Tercih Edilmesi Gereken Durumlar

• Deeply nested structures (tabular eligibility ~%0): Complex config files, API responses
• Mevcut JSON-dependent infrastructure: REST APIs, WebSocket communication
• Non-tabular, heterogeneous data: Mixed-type arrays, irregular structures
• Evrensel compatibility: Her platform JSON’u parse edebilir

3. CSV’nin Hâlâ En İyi Olduğu Yer

• Pure flat tabular data: Analytics exports, spreadsheet data
• Maksimum token efficiency: TOON’dan %5-8 daha verimli
• Basit data transfer: Database export/import

4. YAML Ne Durumda?

• Configuration files: Docker, Kubernetes, CI/CD configs
• Human readability priority: Documentation, settings
• LLM için: TOON genelde daha verimli

Pratik Implementasyon ve Kod Örnekleri

TypeScript/JavaScript

import { encode, decode } from '@toon-format/toon'

// Basic encoding
const data = {
  users: [
    { id: 1, name: 'Alice', role: 'admin' },
    { id: 2, name: 'Bob', role: 'user' }
  ]
}

const toon = encode(data)
console.log(toon)
// users[2]{id,name,role}:
//   1,Alice,admin
//   2,Bob,user

// Tab delimiter (often better tokenization)
const toonTab = encode(data, { delimiter: '\t' })

// Key folding for nested structures
const nestedData = {
  data: {
    metadata: {
      items: ['a', 'b', 'c']
    }
  }
}

const toonFolded = encode(nestedData, { keyFolding: 'safe' })
// data.metadata.items[3]: a,b,c

// Decoding with path expansion
const decoded = decode(toonFolded, { expandPaths: 'safe' })
// Restores original nested structure

// Strict validation
try {
  const validated = decode(toonString, { strict: true })
} catch (error) {
  console.error('Invalid TOON format:', error)
}

CLI Usage

# Convert JSON to TOON
npx @toon-format/cli data.json -o output.toon

# With stats (shows token savings)
npx @toon-format/cli data.json --stats -o output.toon

# Tab delimiter
npx @toon-format/cli data.json --delimiter "\t" -o output.toon

# Pipe delimiter
npx @toon-format/cli data.json --delimiter "|" -o output.toon

# Key folding
npx @toon-format/cli data.json --key-folding safe -o output.toon

# Pipe workflow
cat large-dataset.json | npx @toon-format/cli --delimiter "\t" --stats > output.toon

# Decode TOON to JSON
npx @toon-format/cli data.toon -o output.json

# Lenient decoding (skip validation)
npx @toon-format/cli data.toon --no-strict -o output.json

LLM Prompt Engineering

// System prompt example
const systemPrompt = `
Data is in TOON format (2-space indent, arrays show length and fields).

\`\`\`toon
users[3]{id,name,role,lastLogin}:
  1,Alice,admin,2025-01-15T10:30:00Z
  2,Bob,user,2025-01-14T15:22:00Z
  3,Charlie,user,2025-01-13T09:45:00Z
\`\`\`

Task: Return only users with role "user" as TOON. 
Use the same header. Set [N] to match the row count. 
Output only the code block.
`

// Expected output from LLM:
// ```toon
// users[2]{id,name,role,lastLogin}:
//   2,Bob,user,2025-01-14T15:22:00Z
//   3,Charlie,user,2025-01-13T09:45:00Z
// ```

Teknik Analiz: Neden TOON LLM’lerde Daha İyi Çalışıyor?

1. Explicit Structure Validation

TOON’un [N] ve {field1,field2} syntax’ı LLM’lere validation hook’ları sağlıyor:

• Array length declaration: LLM kaç satır beklemesi gerektiğini biliyor
• Field headers: Her satırda hangi field’ların olması gerektiği explicit
• Delimiter awareness: Header’da delimiter declare ediliyor, parsing ambiguity azalıyor

Bu, özellikle structured output generation’da hallucination riskini azaltıyor. LLM, “users[5]” gördüğünde tam 5 satır üretmesi gerektiğini biliyor.

2. Reduced Token Redundancy

JSON’da her object için key tekrarı var:

// JSON - Her satırda key repetition
[
  {"id": 1, "name": "Alice"},
  {"id": 2, "name": "Bob"},
  {"id": 3, "name": "Charlie"}
]
// Keys 3 kez tekrar ediyor: "id" ve "name"

TOON’da key’ler bir kez declare ediliyor:

# TOON - Keys sadece header'da
[3]{id,name}:
  1,Alice
  2,Bob
  3,Charlie
# Keys sadece 1 kez

3. Delimiter Scoping

TOON’da delimiter header’da declare ediliyor, bu LLM’e net bir sinyal:

# Comma delimiter (implicit)
users[3]{id,name}: ...

# Tab delimiter (explicit)
users[3	]{id	name}: ...

# Pipe delimiter (explicit)
users[3|]{id|name}: ...

LLM, delimiter’ı header’dan öğrenince parsing daha güvenilir oluyor.

4. Cognitive Load Reduction

Tabular format, LLM’in attention mechanism’i için daha verimli:

• Aynı pozisyonda aynı tip data (column-oriented thinking)
• Pattern recognition daha kolay
• Token sequence daha predictable

Sonuç: Hybrid Strateji ve Gerçek Dünya Uygulamaları

Sonuç şu: TOON, JSON’un yerini almıyor, onu tamamlıyor. Her format kendi use case’inde en iyisi. Projelerimde şu hybrid stratejiyi uyguluyorum:

JSON Kullandığım Yerler:

• REST API endpoints: Evrensel standart, her client parse edebilir
• WebSocket communication: Real-time data exchange
• Configuration files: package.json, tsconfig.json, etc.
• Database storage: PostgreSQL JSONB, MongoDB documents
• Deeply nested data: Complex config objects

TOON Kullandığım Yerler:

• LLM prompt engineering: Few-shot examples, structured data in prompts
• Structured output generation: LLM’den tabular data istediğimde
• RAG document indexing: Vector DB’ye göndermeden önce token optimization
• Token-critical AI workflows: Büyük context window’larda maliyet önemli
• Analytics data to LLM: Time-series, metrics, logs

CSV Kullandığım Yerler:

• Pure analytics data: Flat tabular exports
• Database exports: Simple data transfer
• Spreadsheet integrations: Excel, Google Sheets

Gerçek Dünya Örneği: RAG Pipeline

// 1. API'den JSON al
const apiResponse = await fetch('/api/users')
const jsonData = await apiResponse.json()

// 2. LLM'e göndermeden önce TOON'a çevir
const toonData = encode(jsonData, { delimiter: '\t' })

// 3. LLM prompt'unda TOON kullan
const prompt = `
Analyze this user data:

\`\`\`toon
${toonData}
\`\`\`

Generate a summary report.
`

// 4. LLM response'u al ve parse et
const llmResponse = await callLLM(prompt)

// 5. Gerekirse TOON output'u JSON'a çevir
if (llmResponse.includes('```toon')) {
  const toonOutput = extractCodeBlock(llmResponse)
  const jsonOutput = decode(toonOutput)
  await saveToDatabase(jsonOutput)
}

Maliyet Analizi: Gerçek Senaryolar

Senaryo 1: 10,000 user records, günde 1,000 LLM call

• JSON (formatted): ~3.5M tokens/day × $0.003/1K = $10.50/day
• JSON (compact): ~2.1M tokens/day × $0.003/1K = $6.30/day
• TOON (tab): ~1.4M tokens/day × $0.003/1K = $4.20/day
• Tasarruf: $6.30/day ($2,300/year) vs JSON formatted

Senaryo 2: Analytics dashboard, real-time data to LLM

• 100K rows, 10 columns, hourly updates (24×30 = 720 calls/month)
• JSON: ~180M tokens/month × $0.003/1K = $540/month
• TOON: ~72M tokens/month × $0.003/1K = $216/month
• Tasarruf: $324/month ($3,888/year)

Son Tavsiyeler

1. Token count’ınızı measure edin: Her iki formatı da kendi dataset’inizde test edin. npx @toon-format/cli --stats ile gerçek tasarrufu görün.

2. Latency’yi de ölçün: Bazı deployment’larda (özellikle local/quantized models) compact JSON daha hızlı olabilir. TTFT, tokens/sec, total time’ı benchmark edin.

3. Tabular eligibility’yi kontrol edin: Dataset’inizin ne kadarı uniform array? %40’ın altındaysa TOON’un avantajı azalır.

4. Delimiter stratejisi: Tab delimiter genelde en iyi tokenization sağlıyor, ama dataset’inizde tab character varsa pipe kullanın.

5. Infrastructure complexity: Yeni bir format eklemek mi, yoksa JSON ile token maliyeti ödemek mi daha ucuz? TCO (Total Cost of Ownership) hesaplayın.

Sonuç olarak: TOON, LLM-intensive workflow’larda ciddi maliyet tasarrufu sağlayabilen, iyi tasarlanmış bir format. Ama her tool gibi, doğru kullanım senaryosunda değer yaratıyor. JSON’u reddetmek değil, onu doğru yerde kullanmak ve TOON’u da doğru yerde kullanmak önemli.

Kendi projelerinizde test edin, benchmark edin ve veri odaklı karar verin. Çünkü en iyi format, senin kullanım senaryonunda en iyi çalışan formattır.

Kaynaklar

• TOON Format Specification v2.0: https://github.com/toon-format/toon
• TOON Benchmarks (209 retrieval questions, 4 models): GitHub Repository
• Token efficiency tests: GPT-5 o200k_base tokenizer via gpt-tokenizer
• Format Tokenization Playground: TOON Tools