# LLMApi: Тривожність і життєдіяльність

# Введение

У моєму проекті LLMApi я хотів бути в змозі підтримувати просування за LOTS даних ; але LLM мають дуже обмежену кількість даних, які вони можуть видавати в один раз; і не надто швидкі в цьому плані МSK2

До того ж, була проблема контекстів, чудова функція, але до цього часу контекст тривав так довго, як додаток, тож це додає повної підтримки для скользячої キャッシュи, щоб уникнути потенційного джерела витіку пам 'яті, якщо ви залишаєте симулятор під дією.

<!--category-- AI, LLMApi, LLM, ASP.NET Core, API, Nuget, mockllmapi, SignalR, AI-Article-->
<datetime class="hidden">2025-11-06T13:35</datetime>

# Керування системами Caching &

**Опублікація 1.8.0** - Досконалені результати & Zarządzanie ресурсами

Цей документ описує дві потужні системи, що роблять `mostlylucid.mockllmapi` розумний, ефективнийM SK1 і виробництво- готовийМSK3 **Автоматичний обробка** і **Caching реагування**.

**швидкий старт:** Подивіться [Записи та записи](https://github.com/scottgal/LLMApi/blob/refs/heads/features/big-results-cache/ChunkingAndCaching.http) для готового-на-запуску HTTP прикладів, демонструючи всі характеристикиM SK2

---


## Стосунок

- [Автоматичний обробка](#automatic-chunking)
  - [Що таке Auto-Chunking?](#what-is-auto-chunking)
  - [Konfiguracja](#chunking-configuration)
  - [Як це працює](#how-chunking-works)
  - [Ось приклади використання](#chunking-usage-examples)
  - [Logging & Обсервабельність](#chunking-logging)
- [Caching реагування](#response-caching)
  - [Що таке Caching Response?](#what-is-response-caching)
  - [Konfiguracja](#caching-configuration)
  - [Хіба поведінка в кэші](#cache-behavior)
  - [Ось приклади використання](#caching-usage-examples)
- [Хранение у контексті](#context-storage)
  - [15-Minute Sliding Expiration](#context-expiration)
  - [Konfiguracja](#context-configuration)
- [Найкращі практики](#best-practices)
- [Подолання проблем](#troubleshooting)

---


## Автоматичний обробка

### Що таке Auto-Chunking?

Auto-chunking - це розумна система, яка автоматично розділяє великі запити на оптимальні шматочки, коли вони перевершать ваші LLM **It's включено по умолчанию** і працює прозоро— ви не маєте ' вам не потрібно змінювати API дзвінків

#### Проблема, яка вирішується

Вимагати 100 об 'єктів з складною формою може викликати реакцію, яка перевищує LLM ' межу вихідних टोकенів

#### Рішення

Система:

1. **Оцінки** використання символів на основі складності форми
2. **Вираховує** оптимальні розміри шматків, які вписуються у рамки
3. **Виконує** багато запитів LLM автоматично
4. **Утримують** послідовність по кусках, використовуючи контекст
5. **Об 'єднання** результатом є єдиний безперервний відгук

### Налагодження

Dodaj до `appsettings.json`:

```json
{
  "MockLlmApi": {
    "BaseUrl": "http://localhost:11434/v1/",
    "ModelName": "llama3",

    // Auto-Chunking Settings
    "MaxOutputTokens": 2048,           // LLM output limit (default: 2048)
    "EnableAutoChunking": true,         // Enable automatic chunking (default: true)
    "MaxItems": 1000,                   // Maximum items per response (default: 1000)

    // Input Token Settings
    "MaxInputTokens": 2048              // LLM input limit (default: 2048)
  }
}
```

#### Виsvětlení параметрів конфігурації

| Налаштування МSK1 По замовчуванню МSK2 Описание |
|---------|---------|-------------|
| `MaxOutputTokens` МSK0 2048 ♫ ♫ МSK2 ♫ Максимальні символи, що їх може генерувати ваш LLM ♫
| `EnableAutoChunking` | правда МSK1 Глобально ввімкнути МSK2ушкодити автоматичне відрізання |
| `MaxItems` МSK0 1000 ♫ ♫ МSK2 ♫ жорсткий обмеження на деталі за відповіддю ♫ . ♫ Запити, які перевищують це, огороджені попередженням ♫
| `MaxInputTokens` | 2048 МSK2 Максимальний розмір пропони МSK3 Використовується для відрізання історії контексту, якщо це необхідно

### Як працює друк

#### Обзор потоку

```mermaid
flowchart TD
    A[API Request: ?count=100] --> B{Extract Count}
    B --> C{Check MaxItems}
    C -->|Exceeds| D[Cap at MaxItems]
    C -->|Within| E{Check autoChunk param}
    D --> E
    E -->|false| F[Execute Single Request]
    E -->|true/default| G{Estimate Tokens}
    G --> H{Will Exceed<br/>MaxOutputTokens?}
    H -->|No| F
    H -->|Yes| I[Calculate Chunk Strategy]
    I --> J[Execute Chunk 1]
    J --> K[Build Context for Chunk 2]
    K --> L[Execute Chunk 2]
    L --> M{More Chunks?}
    M -->|Yes| N[Build Context for Next]
    M -->|No| O[Combine All Results]
    N --> L
    O --> P[Return Unified Response]
    F --> P

    style I fill:#e1f5ff
    style O fill:#d4edda
    style P fill:#d4edda
```

#### 1. **Підрахунки**

Система аналізує форму JSON, щоб оцінити символи на товар:

```json
// Simple shape → ~50 tokens/item
{"id": 1, "name": ""}

// Complex nested shape → ~200 tokens/item
{
  "user": {
    "id": 1,
    "profile": {
      "name": "",
      "address": {"street": "", "city": ""},
      "contacts": [{"type": "", "value": ""}]
    }
  }
}
```

Факторы оцінки:

- **Глубина вулика** (+0.5x на рівні, за межами МSK1
- **ЧислоArray** (+0.3x за массив
- **Число об 'єктів** (+0.05x на нерухомість за межами МSK1

```mermaid
flowchart LR
    A[Shape JSON] --> B[Parse Structure]
    B --> C[Count Properties]
    B --> D[Measure Nesting Depth]
    B --> E[Count Arrays]
    C --> F[Base Token Count:<br/>Length / 4]
    D --> G[Complexity Multiplier]
    E --> G
    C --> G
    G --> H[Estimated Tokens/Item:<br/>Base × Multiplier]

```

#### 2. **Вирахунки розміру шматка**

```
Available Output Tokens = MaxOutputTokens × 75%  (25% reserved for prompt overhead)
Items Per Chunk = Available Output Tokens / Estimated Tokens Per Item
Total Chunks = Ceiling(Requested Items / Items Per Chunk)
```

Наприклад:

- Запросити items: M SK1
- Створительная складність
- MaxOutputTokens: M SK1
- Доступні
- Поміщи на шматок: M SK1 ♫ (1536 ♫ ♫ МSK3 ♫
- **РезультатМSK0 10 шматочки МSK2 кожного**

#### 3. **Виведення  Chunk**

Кожен шматок:

1. Отримає змінену форму з обновленим числом
2. Добиває контекст з попередніх шматків для консистенції
3. Виконає незалежний LLM запит
4. Возв 'язує JSON, що's розшифровується і накопичується

#### 4. **Захорона контексту**

Наступні кусочки отримують контекст, на кшталт:

```
IMPORTANT CONTEXT - Multi-part Response (Part 2/10):
This is a continuation of a larger request. Previous parts have generated:
  Part 1: 10 items (first: id=1, name="Alice", last: id=10, name="Jane")

Ensure consistency with the above data (IDs, names, relationships, style).
Continue numbering, IDs, and patterns logically from where the previous part left off.
```

Це гарантує, що ID не будуть перезапускатися.

### До прикладів використання шингінгу

#### До прикладу 1: Базова AutoM SK1Chunking

```http
# Request 100 users
GET /api/mock/users?count=100
Content-Type: application/json

{
  "shape": {
    "id": 1,
    "name": "string",
    "email": "email@example.com"
  }
}
```

**Що відбувається:**

- Системні підрахунки ~100 टोकониM SK1міт
- Вираховує шматки 4 кожного МSK1 елементу
- Виконує запити 4 LLM автоматично
- Відображає сукупність користувачів 100

**Логи:**

```
[INFO] Request needs chunking: 100 items × 100 tokens/item = 10000 tokens > 1536 available
[INFO] AUTO-CHUNKING ENABLED: Breaking request into 4 chunks (25 items/chunk)
[INFO] AUTO-CHUNKING: Executing chunk 1/4 (items 1-25 of 100)
[INFO] AUTO-CHUNKING: Executing chunk 2/4 (items 26-50 of 100)
[INFO] AUTO-CHUNKING: Executing chunk 3/4 (items 51-75 of 100)
[INFO] AUTO-CHUNKING: Executing chunk 4/4 (items 76-100 of 100)
[INFO] AUTO-CHUNKING COMPLETE: Combined 4 chunks into 100 items
```

#### До прикладу 2: Opt-Out Per Request

```http
# Disable chunking for this specific request
GET /api/mock/users?count=100&autoChunk=false
```

Використовуйте коли:

- Випробовує обмеження LLM
- Ви хочете побачити поведінку відрізання
- Розладнання про prompt

#### Наприклад, 3: MaxItems Limit

```http
# Request 2000 items (exceeds MaxItems=1000)
GET /api/mock/products?count=2000
```

**Результат:**

```
[WARN] AUTO-LIMIT: Request for 2000 items exceeds MaxItems limit (1000). Capping to 1000 items
```

Возв 'язує 1000 automatically chunked items

#### До прикладу 4: Комплексні Nested Shapes

```http
POST /api/mock/orders?count=50
Content-Type: application/json

{
  "shape": {
    "orderId": 1,
    "customer": {
      "id": 1,
      "name": "string",
      "address": {
        "street": "string",
        "city": "string",
        "country": "string"
      }
    },
    "items": [
      {"productId": 1, "name": "string", "quantity": 1, "price": 9.99}
    ],
    "shipping": {"method": "string", "trackingNumber": "string"},
    "payment": {"method": "string", "status": "string"}
  }
}
```

**Що відбувається:**

- Система виявляє високу складність (deep nestingM SK1 arrays)
- Підрахунки ~300 टोकониM SK1мин
- Вираховує шматки 10 кожного МSK1 елементу
- Утримує безперервність ID замовлення та стосунки з клієнтами по кусках

### Записування

Усі операції відокремлення зареєстровані для спостереження:

**Записи розладів:**

- Вирахунок видобутку: `Found explicit count in query parameter 'count': 100`
- Немає потреби відокремлювати: `No chunking needed for this request`

**Інформаційні журнали:**

- Приймання рішення: `Request needs chunking: 100 items × 150 tokens = 15000 tokens > 1536 available`
- Стратегия: `Chunking strategy: 100 items → 4 chunks × 25 items/chunk`
- Введення: `AUTO-CHUNKING: Executing chunk 2/4 (items 26-50 of 100)`
- Завершення: `AUTO-CHUNKING COMPLETE: Combined 4 chunks into 100 items`

**Записи про попередження:**

- Перевищена межа: `AUTO-LIMIT: Request for 2000 items exceeds MaxItems (1000). Capping to 1000`

---


## Caching реагування

### Що таке Caching Response?

Керування відповіддю до- генерує багато LLM відповідей для одного запиту, зберігає їх в пам ’ яті і робить їх одними - за допомогою МSK3 один, щоб забезпечити різноманіття без повторюваних LLM дзвінківM SK4

#### Як це відрізняється від

На відміну від традиційного шифрування, ( одна і та ж реакція щоразу

- генерує **Варіанти N** за запит
- Обслуговує кожну вариацію **раз** (швидше вікноМSK1
- **Переповнює у фоні** коли вичерпаний
- Дозволяє **різновид** підтримуючи ефективність

### Konfiguracja Caching

```json
{
  "MockLlmApi": {
    // Cache Settings
    "MaxCachePerKey": 5,                     // Variants per unique request (default: 5)
    "CacheSlidingExpirationMinutes": 15,     // Idle time before expiration (default: 15)
    "CacheAbsoluteExpirationMinutes": 60,    // Max lifetime (default: 60, null = none)
    "CacheRefreshThresholdPercent": 50,      // Trigger refill at % empty (default: 50)
    "MaxItems": 1000,                        // Max total cached items (default: 1000)
    "CachePriority": 1,                      // Memory priority: 0=Low, 1=Normal, 2=High, 3=Never (default: 1)

    // Advanced Cache Options
    "EnableCacheStatistics": false,          // Track cache hits/misses (default: false)
    "EnableCacheCompression": false          // Compress cached responses (default: false)
  }
}
```

### Хіба поведінка в кэші

```mermaid
stateDiagram-v2
    [*] --> ColdCache: First Request
    ColdCache --> Generating: Generate N variants
    Generating --> WarmCache: Store variants
    WarmCache --> ServingFromCache: Subsequent requests
    ServingFromCache --> WarmCache: Variants remaining
    ServingFromCache --> RefillTriggered: Last variant served
    RefillTriggered --> BackgroundRefill: Async refill
    BackgroundRefill --> WarmCache: Refill complete
    ServingFromCache --> Expired: 15min idle
    Expired --> [*]

    note right of ColdCache
        Cache miss
        5x LLM calls
        Slow first response
    end note

    note right of ServingFromCache
        Cache hit
        Instant response
        No LLM call
    end note

    note right of BackgroundRefill
        Transparent refill
        User does not wait
        Fresh variants ready
    end note
```

#### Початковий запит (Cold CacheM SK1

```http
GET /api/mock/users?shape={"id":1,"name":""}
X-Cache-Count: 5
```

**Що відбувається:**

1. Система миттєво генерує 5 варіанти відповідей
2. Служить першій варіації
3. Залишені 4 зберігаються в кэші
4. **Час реагування:** 5× звичайний МSK1 генерує всі варіантиM SK2

#### Наступні вимоги (Warm CacheM SK1

```http
# Request 2
GET /api/mock/users?shape={"id":1,"name":""}
X-Cache-Count: 5
```

**Що відбувається:**

1. Обслуговує другу вариацію з кэшу
2. Зараз в кэші залишилися 3 варіанти
3. **Час реагування:** Моментний дзвінок (без LLM)

```http
# Request 5 (last variant)
GET /api/mock/users?shape={"id":1,"name":""}
X-Cache-Count: 5
```

**Що відбувається:**

1. Подібно до п 'ятої варіації з кэшу
2. Кэш тепер пустий
3. **Триггери фонового заповнення** нових варіантів 5
4. **Час реагування:** Незабаром

```http
# Request 6 (refill in progress)
GET /api/mock/users?shape={"id":1,"name":""}
X-Cache-Count: 5
```

**Що відбувається:**

1. Заповнення завершено, працює з заповненого кэша
2. **Час реагування:** Незабаром

#### Unikальність ключів кэшу

Ключи кэшу базуються на:

- HTTP-metodа (GET, POSTM SK2 і т.д.
- Повний шлях із строком запиту
- Форма JSON

Різні запити підтримують окремі кэши:

```http
GET /api/mock/users?count=10        # Cache Key A
GET /api/mock/users?count=20        # Cache Key B (different count)
GET /api/mock/products?count=10     # Cache Key C (different endpoint)
```

### Приклади використання Caching

#### До прикладу 1: Увімкніть Caching з параметром попиту

```http
GET /api/mock/users?count=10
X-Cache-Count: 3
```

генерує 3 варіанти МSK1 поєднує їх у послідовності

#### До прикладу 2: Включити введення в кэш з властивістю форми

```json
POST /api/mock/users
Content-Type: application/json

{
  "shape": {
    "$cache": 5,
    "id": 1,
    "name": "string"
  }
}
```

генерує 5 варіантиM SK1

#### До прикладу 3: Загніти шифрування

```http
# Don't cache this request
GET /api/mock/random-data?count=10
```

Ні `X-Cache-Count` або `$cache` означає, що не за Caching—нові LLM відповіді кожного разуM SK1

#### Наприклад, 4: Cache з підрядкою

```http
GET /api/mock/users?count=100
X-Cache-Count: 3
```

**Поведение:**

- Це **неможливим** коли ви використовуєте кэш (, щоб уникнути забруднення кэшу
- Якщо запит потребує відокремлення, кэшування обігноровано
- Найкращі практики: Використовувати кэш для малогоM SK1 середніх відповідей , відокремлення для великого

---


## Хранение у контексті

### Вичерпнення контексту

Контексти API (історія обговорення для підтримки консенсусу між запросамиM SK1 зберігаються з **15- Minuтний термін закінчується**.

#### Як це працює

```mermaid
gantt
    title Context Sliding Window Expiration (15 minutes)
    dateFormat mm:ss
    axisFormat %M:%S

    section Context Lifecycle
    Request 1 creates context        :milestone, m1, 00:00, 0m
    Active (15min window)             :active, 00:00, 10m
    Request 2 extends window          :milestone, m2, 10:00, 0m
    Active (window reset)             :active2, 10:00, 15m
    Request 3 after 20min idle        :milestone, m3, 30:00, 0m
    Expired - starts fresh            :crit, 25:00, 5m
```

```http
# Request 1
GET /api/mock/users/123?context=user-session-1

# Creates context "user-session-1" with 15-minute expiration
```

```http
# Request 2 (10 minutes later)
GET /api/mock/orders?context=user-session-1

# Context still exists, expiration resets to 15 minutes
```

```http
# Request 3 (20 minutes after Request 2, no activity for 20 minutes)
GET /api/mock/profile?context=user-session-1

# Context expired, starts fresh
```

### Konfiguracja контексту

Контексти використовують ті ж самі настрої для вичерпування:

```json
{
  "MockLlmApi": {
    "MaxInputTokens": 2048    // Contexts are truncated to fit within this limit
  }
}
```

Контекстовий зберігання застосовується за допомогою `IMemoryCache` з:

- **Вичерпування Sliding:** МSK0 хвилини (швидкошифрованийM SK2
- **Справа-нечутливі іменаM SK1** "UserM SK1Session
- **Автоматична чистка:** Вичерпані контексти автоматично видаляються
- **Немає витіку пам 'яті:** Уникнення зворотнього зв 'язку прибирає пошукові словники

---


## Найкращі практики

### Коли використовувати чорнил

**Використовуйте відрізання, коли:**

- Вимагаємо > МSK1 речей з складними формами
- Працюючи з вбудованими/hierarchічними даними
- Вимагаємо сотень речей

**Не вимкнути блокування, якщо не**

- Випробовуємо LLM обмеження токенів
- Розладнання про prompt
- Ви хочете побачити поведінку відрізання

### Коли використовувати Caching

**Використовуйтеキャッシュування, коли:**

- Модель запиту повторюється: (eM SK1g., дані, що відкидаються
- Варіатива مطلوبа (раздібні макетні користувачі кожного разуM SK1
- Важливість ефективності (реакції миттєвіM SK1

**Не залишайте в кэші, коли**

- Кожна реакція має бути унікальною. (eM SK1g., генерація випадкових даних тесту )
- Дані мають бути специфічними для сеансу
- Об 'єм запиту низький (сумки надрахунків не варті цьогоM SK1

### Оптимальна конфігурація

**Невеликі LLM (e.gM SK2 tinyllama ):**

```json
{
  "MaxOutputTokens": 512,
  "MaxInputTokens": 1024,
  "MaxCachePerKey": 3,
  "EnableAutoChunking": true
}
```

**Середні LLM (e.gM SK2 Llama 3):**

```json
{
  "MaxOutputTokens": 2048,
  "MaxInputTokens": 2048,
  "MaxCachePerKey": 5,
  "EnableAutoChunking": true
}
```

**Великі LLM (e.gM SK2 Llama МSK3 70BMSC5**

```json
{
  "MaxOutputTokens": 4096,
  "MaxInputTokens": 4096,
  "MaxCachePerKey": 5,
  "EnableAutoChunking": true
}
```

---


## Подолання проблем

### Проблеми з проектуванням

**Проблема:** "Попрос на МSK1 items returns only 50"

**Рішення:** Проверяйте журнали для виконання chunkingу. Якщо не chunksM SK1 збільшувати `MaxOutputTokens`:

```json
{
  "MaxOutputTokens": 4096    // Increase limit
}
```

**Проблема:** "Хунки мають неоднозначні ID МSK1ID перезапускаються на МSK2 для кожного кусочкаM SK3

**Рішення:** Це рідкісне порушення поведінки LLM

1. Використовуйте іншу модель
2. Збільшувати `Temperature` для кращої творчості
3. Додайте експлицитні діапазони ID у формі: `{"id": "start at 1 and increment"}`

**Проблема:** "Забагато згенерованих фрагментів

**Рішення:**

1. Полегшити вашу форму (remove unnecessary nestingM SK1
2. Збільшувати `MaxOutputTokens`
3. Скорінити кількість запити
4. Використовувати `?autoChunk=false` якщо вам не потрібні повні дані

### Проблеми Caching

**Проблема:** "Схожа реакція кожного разу, незважаючи на кэш

**Рішення:** Кэш пустий, заповнення фону може бути повільнимM SK1 ПроверкаМSK2

1. Служба LLM реагує
2. Збільшувати `MaxCachePerKey` для більше варіантів
3. Проверка журналів для "Невдалось відвезти повторне заповнення фонуM SK1

**Проблема:** "Кача не вживається

**Рішення:** Упевниться, що ви 'specyfikуєте кэш з будь-якими :

- Параметр питання: `?cache=5`
- Заголовок: `X-Cache-Count: 5`
- Якість форми: `"$cache": 5`

**Проблема:** "Використання пам 'яті зростаєM SK1

**Рішення:**

1. Снижувати `MaxCachePerKey` (менші варіантиM SK1
2. Снижувати `CacheSlidingExpirationMinutes` ( закінчується швидшеM SK1
3. Створити `EnableCacheCompression: true` (торговий процессор для пам 'яті)
4. Снижувати `MaxItems` (важка шапка на розмірі кэшуM SK1

### Проблеми у контексті

**Проблема:** "Контекст втрачений між запитимиM SK1

**Рішення:** Контекст закінчився (15 хвилини неактивностіM SK1 Якщо ви потребуєте більшого:

- Робіть запити частіше, щоб зберегти контекст живим
- Розглянемо використання довготривалого контекстового зберігання (запрос на функцію для майбутнього випускуM SK1

**Проблема:** " Контекст стає надто великимM SK1

**Рішення:** Контексти автоматично підсумовуються, коли вони перевершують `MaxInputTokens`. Проверка

1. В журналах показано: "сумовування контекстуM SK1 повідомлення
2. Збільшувати `MaxInputTokens` якщо необхідно
3. Коротше ім 'я контексту для ефективності

---


## Досконалість вимірювання

### Виступи на сцені

| сценарій МSK1 без відхилення МSK2 з відхилением | покращення
|----------|-------------|--------------|-------------|
МSK0 100 простих речей МSK2 скорочених | повних **Роботи проти. Зазнають невдачі** |
МSK0 50 складні речі МSK2 скорочені | Kompletні | | МSK4 | шматочки | ) | **Роботи проти. Зазнають невдачі** |
МSK0 10 توکي МSK2 | | 2.3 | 4 | 5 | 6 **Жодних витрат** |

### Функція Caching

| сценарій МSK1 без буфера МSK2 з буфером ( теплі
|----------|---------------|-------------------|-------------|
| Простая прохання **1000× швидше** |
| Зовсім складний запит **1800× швидше** |
| Перше запрошення МSK1 МSK2s | | | 4 | 5 | Варіанти **МSK0 повільніше (початковеM SK2** |

### Використовування пам 'яті

| Конфигурація
|--------------|-----------------|
| Без кэшування
| CacheM SK1 5 варіанти МSK3 \100 ключі МSK5 | | +50 MB | МSK7
| CacheM SK1 5 варіанти МSK3 \1000 ключі МSK5 | | +500 MB | МSK7
| Контекстовий накопичувальний простір (100 активний

---


## Історія версії

- **v1.8.0** - Початкова релізація автоматичної МSK1 підключення та покращення кэшування
- **v1.7.0** - Базова система кэшування
- **v1.6.0** - Введемо контекстове зберігання

Для більших деталей, читайте [РELEASE_NOTESM SK1md](https://github.com/scottgal/LLMApi/blob/refs/heads/features/big-results-cache/RELEASENOTES.md).