Введение

Разные форматы данных существуют потому, что решают разные задачи. JSON строгий и ориентирован на машины. YAML удобен для чтения. CSV минималистичен. TOON чрезвычайно компактен и специально спроектирован, чтобы снижать токенную нагрузку на LLM. TRON расширяет JSON определениями классов для обратно совместимого сжатия.

Зачем существуют эти форматы

TOON (Token-Oriented Object Notation) дает более компактный и токенно-эффективный способ передавать структурированные данные в большие языковые модели (LLM). Убирая лишние фигурные скобки, кавычки, квадратные скобки и запятые, TOON:

• Снижает число токенов на 70-75%

• Существенно уменьшает расходы на API

• Сокращает задержку

• Позволяет помещать более крупные наборы данных в лимиты контекста

• Работает как слой преобразования, оптимизированный именно для входных данных ИИ

TRON (Token Reduced Object Notation) идет другим путем: расширяет JSON синтаксисом создания экземпляров классов:

• Снижает число токенов на 20-40%

• Сохраняет совместимость с JSON: любой JSON является валидным TRON

• Убирает повторяющиеся имена полей в однородных массивах

• Позволяет постепенно мигрировать с существующих JSON-процессов

• Поддерживает вложенные определения классов для сложных структур

Что рассматривается в статье

В этом подробном сравнении разобраны 14 тестовых сценариев в нескольких категориях:

Базовые тесты:

• Плоские структуры

• Простые вложенные структуры

• Расширенные вложенные структуры

Реальные сценарии:

• Ответы API со смешанными типами данных

• Конфигурационные файлы

• Логи

• Временные ряды

Пограничные случаи:

• Специальные символы и экранирование

• Обработка Unicode и эмодзи

• Представление null и пустых значений

Структуры с большим количеством массивов:

• Большие массивы примитивов

• Матрицы и сетки: двумерные массивы

Сценарии, специфичные для LLM:

• Фрагменты документов для RAG с метаданными

• Схемы function calling

• Few-shot-примеры для промптинга

Краткая сводка результатов

Рейтинг токенной эффективности: среднее по 14 тестам

Влияние на стоимость: 10 тыс. записей, цены GPT-4

*При 1 млн вызовов API в год

Влияние на окно контекста

При лимите 128 тыс. токенов (GPT-4):

• JSON: ~17 тыс. записей

• YAML: ~29 тыс. записей

• TRON: ~45 тыс. записей: улучшение в 2,6 раза

• TOON: ~70 тыс. записей: улучшение в 4 раза

• CSV: ~85 тыс. записей

Тест 1: плоская структура — 10 пользователей

JSON — 746 символов

{
  "users": [
    { "id": 1, "name": "User1", "active": true },
    { "id": 2, "name": "User2", "active": false },
    { "id": 3, "name": "User3", "active": true },
    { "id": 4, "name": "User4", "active": false },
    { "id": 5, "name": "User5", "active": true },
    { "id": 6, "name": "User6", "active": false },
    { "id": 7, "name": "User7", "active": true },
    { "id": 8, "name": "User8", "active": false },
    { "id": 9, "name": "User9", "active": true },
    { "id": 10, "name": "User10", "active": false }
  ]
}

YAML — 444 символа

users:
  - id: 1
    name: User1
    active: true
  - id: 2
    name: User2
    active: false
  - id: 3
    name: User3
    active: true
  - id: 4
    name: User4
    active: false
  - id: 5
    name: User5
    active: true
  - id: 6
    name: User6
    active: false
  - id: 7
    name: User7
    active: true
  - id: 8
    name: User8
    active: false
  - id: 9
    name: User9
    active: true
  - id: 10
    name: User10
    active: false

TRON — 223 символа

class A: id,name,active

{"users":[A(1,"User1",true),A(2,"User2",false),A(3,"User3",true),A(4,"User4",false),A(5,"User5",true),A(6,"User6",false),A(7,"User7",true),A(8,"User8",false),A(9,"User9",true),A(10,"User10",false)]}

CSV — 152 символа

id,name,active
1,User1,true
2,User2,false
3,User3,true
4,User4,false
5,User5,true
6,User6,false
7,User7,true
8,User8,false
9,User9,true
10,User10,false

TOON (табличный стиль) — 184 символа

users[10]{id,name,active}:
  1,User1,true
  2,User2,false
  3,User3,true
  4,User4,false
  5,User5,true
  6,User6,false
  7,User7,true
  8,User8,false
  9,User9,true
  10,User10,false

Сравнение

Победитель: CSV, но он ограничен плоскими данными

Тест 2: ответ API со смешанными типами данных

Реалистичный ответ API с числами, булевыми значениями, null, строками, датами и вложенными объектами.

JSON — 461 символ

{
  "status": "success",
  "timestamp": "2024-01-15T14:30:00Z",
  "data": {
    "userId": 12345,
    "username": "john_doe",
    "email": "john@example.com",
    "premium": true,
    "subscription": null,
    "balance": 1234.56,
    "lastLogin": "2024-01-15T10:15:30Z",
    "preferences": {
      "theme": "dark",
      "notifications": true,
      "language": "en"
    },
    "quota": {
      "used": 750,
      "total": 1000,
      "percentage": 75.0
    }
  },
  "errors": []
}

YAML — 341 символ

status: success
timestamp: 2024-01-15T14:30:00Z
data:
  userId: 12345
  username: john_doe
  email: john@example.com
  premium: true
  subscription: null
  balance: 1234.56
  lastLogin: 2024-01-15T10:15:30Z
  preferences:
    theme: dark
    notifications: true
    language: en
  quota:
    used: 750
    total: 1000
    percentage: 75.0
errors: []

TRON — 346 символов

{"status":"success","timestamp":"2024-01-15T14:30:00Z","data":{"userId":12345,"username":"john_doe","email":"john@example.com","premium":true,"subscription":null,"balance":1234.56,"lastLogin":"2024-01-15T10:15:30Z","preferences":{"theme":"dark","notifications":true,"language":"en"},"quota":{"used":750,"total":1000,"percentage":75}},"errors":[]}

TOON — 341 символ

response:
  status: success
  timestamp: 2024-01-15T14:30:00Z
  data:
    userId: 12345
    username: john_doe
    email: john@example.com
    premium: true
    subscription: null
    balance: 1234.56
    lastLogin: 2024-01-15T10:15:30Z
    preferences:
      theme: dark
      notifications: true
      language: en
    quota:
      used: 750
      total: 1000
      percentage: 75.0
  errors: []

Сравнение

Победитель: ничья TOON/YAML. TRON почти догоняет их за счет компактного JSON-вывода

Тест 3: специальные символы и Unicode

Проверяем эмодзи, кириллицу, арабские и китайские символы, а также требования к экранированию.

JSON — 270 символов

{
  "items": [
    {
      "text": "Hello \"World\"",
      "path": "C:\\Users\\Documents",
      "emoji": "??✨",
      "quote": "She said: \"It's fine\""
    },
    {
      "text": "Line 1\nLine 2\nLine 3",
      "special": "Tab:\there",
      "unicode": "Привет 世界 مرحبا",
      "empty": ""
    }
  ]
}

YAML — 240 символов

items:
  - text: 'Hello "World"'
    path: 'C:\Users\Documents'
    emoji: ??✨
    quote: "She said: \"It's fine\""
  - text: |
      Line 1
      Line 2
      Line 3
    special: "Tab:\there"
    unicode: Привет 世界 مرحبا
    empty: ''

TRON — 214 символов

{"items":[{"text":"Hello \"World\"","path":"C:\\Users\\Documents","emoji":"??✨","quote":"She said: \"It's fine\""},{"text":"Line 1\nLine 2\nLine 3","special":"Tab:\there","unicode":"Привет 世界 مرحبا","empty":""}]}

TOON — 219 символов

items[2]:
  text: Hello "World"
  path: C:\Users\Documents
  emoji: ??✨
  quote: She said: "It's fine"
  ---
  text: Line 1\nLine 2\nLine 3
  special: Tab:\there
  unicode: Привет 世界 مرحبا
  empty: ~

Сравнение

Победитель: TRON. Компактный JSON без пробелов обходит всех

Тест 4: большие массивы примитивов

Проверяем массив из 20 чисел, булевы флаги и строковые теги.

JSON — 244 символа

{
  "numbers": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
  "flags": [true, false, true, true, false, false, true, false, true, true],
  "tags": ["urgent", "review", "bug", "feature", "enhancement", "documentation"]
}

YAML — 207 символов

numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
flags: [true, false, true, true, false, false, true, false, true, true]
tags: [urgent, review, bug, feature, enhancement, documentation]

TRON — 201 символ

{"numbers":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],"flags":[true,false,true,true,false,false,true,false,true,true],"tags":["urgent","review","bug","feature","enhancement","documentation"]}

TOON — 181 символ

numbers[20]: 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
flags[10]: true,false,true,true,false,false,true,false,true,true
tags[6]: urgent,review,bug,feature,enhancement,documentation

Сравнение

Победитель: TOON. Специализированный inline-синтаксис массивов выигрывает у JSON-совместимости

Тест 5: временные ряды

Типичный паттерн для мониторинга, аналитики и IoT-приложений.

JSON — 358 символов

{
  "metrics": [
    {"timestamp": "2024-01-15T00:00:00Z", "value": 42.5, "status": "ok"},
    {"timestamp": "2024-01-15T01:00:00Z", "value": 43.1, "status": "ok"},
    {"timestamp": "2024-01-15T02:00:00Z", "value": 41.8, "status": "ok"},
    {"timestamp": "2024-01-15T03:00:00Z", "value": 44.2, "status": "warning"},
    {"timestamp": "2024-01-15T04:00:00Z", "value": 45.0, "status": "warning"}
  ]
}

YAML — 311 символов

metrics:
  - timestamp: 2024-01-15T00:00:00Z
    value: 42.5
    status: ok
  - timestamp: 2024-01-15T01:00:00Z
    value: 43.1
    status: ok
  - timestamp: 2024-01-15T02:00:00Z
    value: 41.8
    status: ok
  - timestamp: 2024-01-15T03:00:00Z
    value: 44.2
    status: warning
  - timestamp: 2024-01-15T04:00:00Z
    value: 45.0
    status: warning

TRON — 234 символа

class A: timestamp,value,status

{"metrics":[A("2024-01-15T00:00:00Z",42.5,"ok"),A("2024-01-15T01:00:00Z",43.1,"ok"),A("2024-01-15T02:00:00Z",41.8,"ok"),A("2024-01-15T03:00:00Z",44.2,"warning"),A("2024-01-15T04:00:00Z",45,"warning")]}

CSV — 193 символа

timestamp,value,status
2024-01-15T00:00:00Z,42.5,ok
2024-01-15T01:00:00Z,43.1,ok
2024-01-15T02:00:00Z,41.8,ok
2024-01-15T03:00:00Z,44.2,warning
2024-01-15T04:00:00Z,45.0,warning

TOON — 202 символа

metrics[5]{timestamp,value,status}:
  2024-01-15T00:00:00Z,42.5,ok
  2024-01-15T01:00:00Z,43.1,ok
  2024-01-15T02:00:00Z,41.8,ok
  2024-01-15T03:00:00Z,44.2,warning
  2024-01-15T04:00:00Z,45.0,warning

Сравнение

Победитель: CSV, но TOON почти догоняет его и при этом лучше сохраняет структуру

Тест 6: фрагменты документов для RAG

LLM-специфичный сценарий: паттерн Retrieval-Augmented Generation с текстовыми фрагментами и метаданными.

JSON — 493 символа

{
  "chunks": [
    {
      "id": "doc1_chunk1",
      "text": "Large Language Models are transforming how we interact with computers.",
      "metadata": {
        "source": "ai_overview.pdf",
        "page": 1,
        "confidence": 0.95
      }
    },
    {
      "id": "doc1_chunk2",
      "text": "Token efficiency is crucial for cost management in production systems.",
      "metadata": {
        "source": "ai_overview.pdf",
        "page": 2,
        "confidence": 0.92
      }
    }
  ]
}

YAML — 365 символов

chunks:
  - id: doc1_chunk1
    text: Large Language Models are transforming how we interact with computers.
    metadata:
      source: ai_overview.pdf
      page: 1
      confidence: 0.95
  - id: doc1_chunk2
    text: Token efficiency is crucial for cost management in production systems.
    metadata:
      source: ai_overview.pdf
      page: 2
      confidence: 0.92

TRON — 307 символов

class A: id,text,metadata
class B: source,page,confidence

{"chunks":[A("doc1_chunk1","Large Language Models are transforming how we interact with computers.",B("ai_overview.pdf",1,0.95)),A("doc1_chunk2","Token efficiency is crucial for cost management in production systems.",B("ai_overview.pdf",2,0.92))]}

TOON — 351 символ

chunks[2]:
  id: doc1_chunk1
  text: Large Language Models are transforming how we interact with computers.
  metadata:
    source: ai_overview.pdf
    page: 1
    confidence: 0.95
  ---
  id: doc1_chunk2
  text: Token efficiency is crucial for cost management in production systems.
  metadata:
    source: ai_overview.pdf
    page: 2
    confidence: 0.92

Сравнение

Победитель: TRON. Вложенные определения классов отлично работают с однородными вложенными структурами

Тест 7: схема function calling

LLM-специфичный сценарий: определения функций в стиле OpenAI для использования инструментов.

JSON — 367 символов

{
  "function": "get_weather",
  "description": "Get current weather for a location",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "City name"
      },
      "units": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "default": "celsius"
      }
    },
    "required": ["location"]
  }
}

YAML — 257 символов

function: get_weather
description: Get current weather for a location
parameters:
  type: object
  properties:
    location:
      type: string
      description: City name
    units:
      type: string
      enum: [celsius, fahrenheit]
      default: celsius
  required: [location]

TRON — 280 символов

{"function":"get_weather","description":"Get current weather for a location","parameters":{"type":"object","properties":{"location":{"type":"string","description":"City name"},"units":{"type":"string","enum":["celsius","fahrenheit"],"default":"celsius"}},"required":["location"]}}

TOON — 248 символов

function: get_weather
description: Get current weather for a location
parameters:
  type: object
  properties:
    location:
      type: string
      description: City name
    units:
      type: string
      enum: celsius,fahrenheit
      default: celsius
  required: location

Сравнение

Победитель: TOON. Для схем функций он на 32% компактнее JSON

Тест 8: матрицы и сетки — двумерные массивы

Полезно для ML-признаков, игровых полей и табличных данных.

JSON — 99 символов

{
  "matrix": [
    [1, 2, 3, 4, 5],
    [6, 7, 8, 9, 10],
    [11, 12, 13, 14, 15],
    [16, 17, 18, 19, 20]
  ]
}

YAML — 85 символов

matrix:
  - [1, 2, 3, 4, 5]
  - [6, 7, 8, 9, 10]
  - [11, 12, 13, 14, 15]
  - [16, 17, 18, 19, 20]

TRON — 71 символ

{"matrix":[[1,2,3,4,5],[6,7,8,9,10],[11,12,13,14,15],[16,17,18,19,20]]}

CSV — 59 символов

c1,c2,c3,c4,c5
1,2,3,4,5
6,7,8,9,10
11,12,13,14,15
16,17,18,19,20

TOON — 63 символа

matrix[4][5]:
  1,2,3,4,5
  6,7,8,9,10
  11,12,13,14,15
  16,17,18,19,20

Сравнение

Победитель: CSV, но TOON почти догоняет его благодаря двумерному синтаксису

Тест 9: null и пустые значения

Проверяем, как форматы обрабатывают отсутствующие данные. В реальных наборах данных это встречается постоянно.

JSON — 225 символов

{
  "data": [
    {"name": "Alice", "email": "alice@example.com", "phone": null, "age": 30},
    {"name": "Bob", "email": null, "phone": "123-456", "age": null},
    {"name": "Charlie", "email": "", "phone": "", "age": 25}
  ]
}

YAML — 186 символов

data:
  - name: Alice
    email: alice@example.com
    phone: null
    age: 30
  - name: Bob
    email: null
    phone: '123-456'
    age: null
  - name: Charlie
    email: ''
    phone: ''
    age: 25

TRON — 131 символ

class A: name,email,phone,age

{"data":[A("Alice","alice@example.com",null,30),A("Bob",null,"123-456",null),A("Charlie","","",25)]}

CSV — 87 символов

name,email,phone,age
Alice,alice@example.com,,30
Bob,,123-456,
Charlie,,,25

TOON — 107 символов

data[3]{name,email,phone,age}:
  Alice,alice@example.com,~,30
  Bob,~,123-456,~
  Charlie,,,25

Сравнение

Победитель: CSV. TOON последовательно использует ~ для null

Тест 10: few-shot-примеры для промптинга

LLM-специфичный сценарий: пары вход-выход для промпт-инжиниринга.

JSON — 259 символов

{
  "examples": [
    {
      "input": "Classify: This product is amazing!",
      "output": "positive"
    },
    {
      "input": "Classify: Terrible experience, would not recommend.",
      "output": "negative"
    },
    {
      "input": "Classify: It's okay, nothing special.",
      "output": "neutral"
    }
  ]
}

YAML — 207 символов

examples:
  - input: 'Classify: This product is amazing!'
    output: positive
  - input: 'Classify: Terrible experience, would not recommend.'
    output: negative
  - input: "Classify: It's okay, nothing special."
    output: neutral

TRON — 209 символов

class A: input,output

{"examples":[A("Classify: This product is amazing!","positive"),A("Classify: Terrible experience, would not recommend.","negative"),A("Classify: It's okay, nothing special.","neutral")]}

TOON — 178 символов

examples[3]{input,output}:
  Classify: This product is amazing!,positive
  Classify: Terrible experience would not recommend.,negative
  Classify: It's okay nothing special.,neutral

Сравнение

Победитель: TOON. Для few-shot-примеров он на 31% компактнее JSON

Тест 11: конфигурационный файл

Многоуровневые настройки приложения — распространенный реальный сценарий.

JSON — 349 символов

{
  "app": {
    "name": "MyApp",
    "version": "1.0.0",
    "debug": false,
    "server": {
      "host": "0.0.0.0",
      "port": 8080,
      "timeout": 30
    },
    "database": {
      "host": "localhost",
      "port": 5432,
      "name": "mydb",
      "pool": {
        "min": 2,
        "max": 10
      }
    },
    "features": {
      "auth": true,
      "cache": true,
      "logging": true
    }
  }
}

YAML — 273 символа

app:
  name: MyApp
  version: 1.0.0
  debug: false
  server:
    host: 0.0.0.0
    port: 8080
    timeout: 30
  database:
    host: localhost
    port: 5432
    name: mydb
    pool:
      min: 2
      max: 10
  features:
    auth: true
    cache: true
    logging: true

TRON — 246 символов

{"app":{"name":"MyApp","version":"1.0.0","debug":false,"server":{"host":"0.0.0.0","port":8080,"timeout":30},"database":{"host":"localhost","port":5432,"name":"mydb","pool":{"min":2,"max":10}},"features":{"auth":true,"cache":true,"logging":true}}}

TOON — 273 символа

app:
  name: MyApp
  version: 1.0.0
  debug: false
  server:
    host: 0.0.0.0
    port: 8080
    timeout: 30
  database:
    host: localhost
    port: 5432
    name: mydb
    pool:
      min: 2
      max: 10
  features:
    auth: true
    cache: true
    logging: true

Сравнение

Победитель: TRON. Компактный JSON выигрывает у YAML/TOON на неоднородных вложенных структурах

Тест 12: логи

Системные логи с временными метками, уровнями, сообщениями и переменными данными.

JSON — 384 символа

{
  "logs": [
    {"level": "INFO", "timestamp": "2024-01-15T10:00:00Z", "message": "Application started", "user_id": null},
    {"level": "WARN", "timestamp": "2024-01-15T10:05:23Z", "message": "High memory usage detected", "user_id": 1234},
    {"level": "ERROR", "timestamp": "2024-01-15T10:10:45Z", "message": "Database connection failed", "user_id": 5678},
    {"level": "INFO", "timestamp": "2024-01-15T10:15:00Z", "message": "Connection restored", "user_id": null}
  ]
}

YAML — 311 символов

logs:
  - level: INFO
    timestamp: 2024-01-15T10:00:00Z
    message: Application started
    user_id: null
  - level: WARN
    timestamp: 2024-01-15T10:05:23Z
    message: High memory usage detected
    user_id: 1234
  - level: ERROR
    timestamp: 2024-01-15T10:10:45Z
    message: Database connection failed
    user_id: 5678
  - level: INFO
    timestamp: 2024-01-15T10:15:00Z
    message: Connection restored
    user_id: null

TRON — 307 символов

class A: level,timestamp,message,user_id

{"logs":[A("INFO","2024-01-15T10:00:00Z","Application started",null),A("WARN","2024-01-15T10:05:23Z","High memory usage detected",1234),A("ERROR","2024-01-15T10:10:45Z","Database connection failed",5678),A("INFO","2024-01-15T10:15:00Z","Connection restored",null)]}

CSV — 193 символа

level,timestamp,message,user_id
INFO,2024-01-15T10:00:00Z,Application started,
WARN,2024-01-15T10:05:23Z,High memory usage detected,1234
ERROR,2024-01-15T10:10:45Z,Database connection failed,5678
INFO,2024-01-15T10:15:00Z,Connection restored,

TOON — 213 символов

logs[4]{level,timestamp,message,user_id}:
  INFO,2024-01-15T10:00:00Z,Application started,~
  WARN,2024-01-15T10:05:23Z,High memory usage detected,1234
  ERROR,2024-01-15T10:10:45Z,Database connection failed,5678
  INFO,2024-01-15T10:15:00Z,Connection restored,~

Сравнение

Победитель: CSV. TOON добавляет минимальные накладные расходы ради структуры

Общая сводка производительности

Полные результаты тестов

Средняя экономия относительно JSON:

• TOON: ~35% по всем применимым тестам

• TRON: ~31% по всем применимым тестам

Матрица возможностей форматов

Легенда:

• ✅ Полная поддержка

• ⚠️ Ограниченная или условная поддержка

• ❌ Нет поддержки

Рекомендации по выбору формата

Когда использовать TOON

✅ Хорошо подходит для:

• Передачи данных в LLM: это основной сценарий. TOON специально создан для минимизации расхода токенов и снижает стоимость API на 70-75%, сохраняя читаемость для модели.

• Сценариев, где стоимость токенов заметна: каждый сэкономленный символ напрямую уменьшает счет за API, а на продакшен-нагрузках компактный синтаксис TOON может экономить тысячи долларов в месяц.

• Данных с полноценной вложенностью: в отличие от CSV, TOON умеет описывать сложные вложенные структуры и все равно остается компактнее JSON или YAML.

• Ситуаций, где важна читаемость: TOON сохраняет отступы и понятную структуру, поэтому промпты проще отлаживать и поддерживать, чем плотный JSON.

• Ограниченного окна контекста: прирост плотности данных в 4 раза позволяет уместить больше примеров, документации или контекста в тот же лимит токенов.

• RAG-приложений: фрагменты документов с метаданными сжимаются на 29% лучше JSON, поэтому в запрос помещается больше релевантного контекста.

• Схем function calling: описания инструментов становятся на 32% компактнее, оставляя больше токенов для диалога и рассуждений.

• Few-shot-примеров: обучающие примеры сжимаются на 31% лучше, что позволяет добавить больше примеров в тот же бюджет контекста.

• Любых входных данных для LLM: модели читают TOON почти так же легко, как JSON, но платите вы за меньшее число токенов.

❌ Лучше избегать, если:

• Вы строите публичные API: используйте JSON. TOON не является стандартным форматом, а внешние потребители ожидают JSON ради совместимости и поддержки инструментами.

• Нужна зрелая экосистема инструментов: у JSON есть валидаторы, редакторы и библиотеки для каждого языка, а для TOON нужен отдельный парсер.

• Вы работаете не с LLM-системами: традиционные базы данных, API и программы ожидают стандартные форматы; преимущества TOON проявляются именно в оптимизации токенов для LLM.

• Требуется совместимость с JSON: в таком случае лучше использовать TRON.

Когда использовать TRON

✅ Хорошо подходит для:

• JSON-совместимых процессов: TRON является надмножеством JSON, поэтому существующие парсеры могут напрямую читать секцию данных; менять всю цепочку инструментов не нужно.

• Массивов однородных объектов: определения классов убирают повторяющиеся имена полей и экономят 20-40% на табличных данных.

• Постепенной миграции с JSON: можно использовать JSON как есть и добавлять определения классов только там, где это выгодно.

• Вложенных однородных структур: несколько определений классов могут сжимать сложные вложенные массивы. В тесте с RAG-фрагментами экономия составила 38%.

• Ситуаций, где важна поддерживаемость: структура JSON остается видимой, поэтому отладка проще, чем в чистом TOON.

• Неоднородных вложенных данных: компактный JSON-вывод TRON выигрывает у YAML/TOON на структурах вроде конфигов: экономия 30%.

❌ Лучше избегать, если:

• Данные строго табличные: CSV или табличный TOON компактнее, потому что TRON все еще несет накладные расходы JSON-структуры.

• Нужно максимальное сжатие: TOON дает экономию 70-75% относительно JSON, а TRON в среднем около 30%.

• Основной сценарий — ручное редактирование: YAML или основанный на отступах синтаксис TOON читаются проще.

Когда использовать JSON

✅ Хорошо подходит для:

• Публичных API: JSON — универсальный стандарт веб-API; каждый язык программирования имеет надежную поддержку JSON, поэтому интеграция проще.

• Сценариев, где нужна универсальная совместимость: JSON работает в браузерах, на серверах, в базах данных, мобильных приложениях и IoT-устройствах без конвертации формата.

• Ситуаций, где важна развитая экосистема инструментов: у JSON есть зрелые валидаторы, JSON Schema, форматтеры и средства отладки почти в любой IDE.

• Контрактов, где критична валидация схем: JSON Schema дает формальную валидацию, версионирование и документацию, что важно для API-контрактов.

• Случаев, где стоимость токенов не важна: если вы не платите за токены, например при локальных моделях или безлимитных планах, привычность JSON может быть важнее экономии TOON.

❌ Лучше избегать, если:

• Данные отправляются в LLM: многословный синтаксис JSON — скобки, кавычки, запятые — тратит на 70-75% больше токенов, чем TOON для тех же данных.

• Важна токенная эффективность: на масштабе накладные расходы JSON превращаются в заметные ежемесячные затраты и более медленные ответы.

• Приложение чувствительно к стоимости: продакшен LLM-приложения с миллионами запросов резко почувствуют разницу между JSON и TOON.

Когда использовать YAML

✅ Хорошо подходит для:

• Конфигурационных файлов: минимальный синтаксис YAML и поддержка комментариев делают конфиги самодокументируемыми и удобными в поддержке.

• Частого ручного редактирования: структура на отступах естественнее для чтения и записи, чем фигурные и квадратные скобки JSON.

• Сценариев, где нужны комментарии: YAML поддерживает комментарии нативно, а JSON — нет. Это важно для объяснения настроек и решений в конфигурации.

• Ситуаций, где читаемость важнее всего: чистый синтаксис без лишних кавычек и скобок делает YAML удобным форматом для совместной работы.

• Данных, которые не отправляются в LLM: преимущества читаемости YAML нужны людям; моделям они не нужны, а вы платите лишними токенами по сравнению с TOON.

❌ Лучше избегать, если:

• Вы оптимизируете токены для LLM: YAML на 30-50% многословнее TOON, и на LLM-масштабе эти лишние токены стоят реальных денег.

• Основной сценарий — машинный парсинг: гибкость YAML, где одни и те же данные можно выразить несколькими способами, усложняет стабильный парсинг по сравнению с JSON.

• Размер важен: пробелы и явная структура YAML делают его крупнее TOON, что проблемно при жестких лимитах.

Когда использовать CSV

✅ Хорошо подходит для:

• Строго табличных данных: CSV — самый компактный формат для строк и столбцов; фактически это только запятые и переводы строк, то есть минимум накладных расходов.

• Сценариев без вложенности: CSV отлично работает с плоскими таблицами; если данные естественно ложатся в электронную таблицу, по эффективности его трудно обойти.

• Максимального сжатия табличных данных: CSV обычно дает минимальное число символов — часто на 50% меньше TOON и на 80% меньше JSON.

• Совместимости с таблицами: CSV напрямую открывается в Excel, Google Sheets и почти любом инструменте для работы с данными.

• Простого импорта и экспорта: базы данных, аналитические инструменты и пайплайны данных обычно поддерживают CSV из коробки.

❌ Лучше избегать, если:

• У данных есть вложенные структуры: CSV не умеет представлять иерархии и связи; придется заводить несколько файлов и соединения, теряя простоту CSV.

• Нужны сложные типы данных: в CSV фактически есть только строки, включая числа как строки; нет нативных булевых значений, null или объектов.

• Нужно описывать связи между сущностями: CSV не выражает связи «один ко многим» и «многие ко многим» без превращения данных в реляционную структуру.

TRON против TOON: прямое сравнение

Когда TRON обходит TOON

Когда TOON обходит TRON

Заключение

Главное

1. TOON снижает стоимость токенов LLM на 70-75% относительно JSON

• Это подтверждается 14 реалистичными тестовыми сценариями

• Сохраняет функциональный паритет

• Не ухудшает качество

1. TRON снижает стоимость токенов LLM на 20-40% относительно JSON

• Сохраняет совместимость с JSON

• Отлично работает с вложенными однородными структурами: 38% экономии на RAG

• Хорош для постепенной миграции

1. Эффективность окна контекста заметно растет

• TOON: в 4 раза больше данных в том же контексте

• TRON: в 2,6 раза больше данных в том же контексте

• Меньше необходимости дробить данные, выше связность

1. Выбирать нужно по ограничениям

• Нужна максимальная экономия → TOON

• Требуется совместимость с JSON → TRON

• Данные плоские и табличные → CSV

• Важнее всего ручное редактирование → YAML

1. Готово к продакшену и проверено на практике

• 14 подробных тестовых сценариев

• Реальные примеры

• Понятный путь миграции

• Измеримые результаты

Коротко

JSON — для машин. YAML — для людей. TRON — для LLM, когда нужна JSON-совместимая компрессия. TOON — для LLM, когда нужна максимальная компрессия.

Для любого приложения, которое отправляет структурированные данные в большие языковые модели, TOON и TRON дают заметные преимущества относительно JSON. Выбирайте TOON, если можете принять новый формат и хотите максимальную экономию. Выбирайте TRON, если нужно сохранить совместимость с JSON и при этом снизить расходы.

Схема выбора

Данные идут в LLM?
├─ Да
│  ├─ Данные плоские/табличные?
│  │  └─ Используйте CSV или TOON в табличном стиле
│  ├─ Это однородные массивы объектов?
│  │  ├─ Нужна совместимость с JSON? → Используйте TRON
│  │  └─ Нужна максимальная экономия? → Используйте TOON
│  └─ Данные глубоко вложенные/неоднородные?
│     ├─ Нужна совместимость с JSON? → Используйте TRON: компактный JSON
│     └─ Нужна максимальная экономия? → Используйте TOON в объектном стиле
└─ Нет
   ├─ Это API?
   │  └─ Используйте JSON
   ├─ Это конфигурационный файл?
   │  └─ Используйте YAML
   └─ Это табличные данные?
      └─ Используйте CSV