Руководство по экономии токенов в мультиагентном ИИ

Введение

Когда несколько ИИ-агентов объединяются для совместной работы над сложными задачами, объём токенов — текстовых единиц, из которых складываются запросы и ответы — быстро растёт. В ход идут журналы памяти, подробные спецификации инструментов, системные инструкции и многое другое. Всё это замедляет выполнение и истощает вычислительный бюджет.

Поэтому управлять расходом токенов критически важно для разработчиков, работающих с современными ИИ-системами. Хорошая новость: масштабирование мультиагентной архитектуры не обязательно ведёт к пропорциональному росту затрат, если правильно применять стратегии экономии. В этой статье мы рассмотрим четыре таких подхода на практике.

Четыре ключевые стратегии экономии токенов

Ниже — четыре распространённые практики для оптимизации мультиагентных ИИ-решений и сокращения расхода токенов.

1. Статическое кэширование инструкций (Prefix-Match Caching)

Это можно назвать правилом «не повторяйся». Большие языковые модели (LLM), без которых немыслимы современные ИИ-агенты, тратят много вычислительных ресурсов на повторное чтение одних и тех же системных промтов при каждом новом запросе. Prefix-кэширование, основанное на хранении пар ключ-значение, решает эту проблему: статичные длинные инструкции сохраняются как заранее подготовленный справочник. Вместо того чтобы заново читать весь «свод правил» агента, модель «запоминает» сжатое состояние при получении первого запроса. При последующих обращениях она просто обращается к этой закладке и сразу переходит к обработке нового промта. В результате задержки подготовки заметно сокращаются, а вместе с ними — расход токенов.

2. Семантическое кэширование: распознавание намерений

Если ИИ-агент уже решал похожую задачу, зачем генерировать ответ с нуля? Эта стратегия использует эмбеддинги — векторные числовые представления текста, которые сохраняют семантические свойства, — чтобы быстро находить совпадения по смыслу с прошлыми запросами. Например, промты вроде «Как перезагрузить роутер?» и «Подскажите шаги для перезапуска Wi-Fi-коробки» будут распознаны как одинаковое намерение благодаря семантическому кэшированию. В некоторых случаях это позволяет вовсе обойти обращение к LLM, выдав готовый ответ из кэша.

3. Just-in-Time инструментарий (ленивая загрузка)

Этот подход, также известный как ленивая загрузка, борется с частой ошибкой при проектировании ИИ-агентов: перегрузкой контекстного окна «справочниками» по каждому API, инструменту и схеме базы данных. Такой подход ведёт к раздутым, шумным промтам и лишнему расходу токенов. Вместо этого лучше дать агенту компактный высокоуровневый перечень его возможностей. Только когда агенту нужно выполнить конкретную задачу, он запрашивает детальные инструкции и параметры именно для этого инструмента.

4. Эскалация задач: экономичная маршрутизация моделей

Не каждый пользовательский запрос требует привлечения «тяжёлой» модели. Эффективные мультиагентные архитектуры работают как сортировочные центры: в них есть слой маршрутизации, который анализирует каждую задачу по её характеру и сложности. Простые действия — форматирование данных, суммаризация текста, классификация намерений — направляются к легковесным, зачастую бесплатным моделям, способным выполнить их локально. А вычислительно ёмкие модели, где важен каждый токен, резервируются исключительно для сложных задач — таких как глубокое логическое рассуждение или многошаговая оркестрация.

Пример реализации в двух словах

Теперь, когда мы разобрали четыре практические стратегии оптимизации токенов в мультиагентных ИИ-приложениях, давайте проиллюстрируем их работу на высокоуровневом примере.

Этот фрагмент кода демонстрирует, как объединить две из них: семантическое кэширование и маршрутизацию моделей. В коде используется реальная модель — sentence transformer — для преобразования текста в эмбеддинги, необходимые для семантического кэширования. Вызовы LLM замоканы, но вы легко можете заменить код (особенно для легковесной модели) на реальную модель с открытыми весами, например, доступную через Groq, как показано в этой статье, например.

import numpy as np
from sentence_transformers import SentenceTransformer

# Loading a free, local model to convert text into embeddings
embedder = SentenceTransformer('all-MiniLM-L6-v2')

# In-memory semantic cache and similarity threshold (0.90 = 90% similar)
semantic_cache = {}
SIMILARITY_THRESHOLD = 0.90

def cosine_similarity(vec1, vec2):
    """Calculates how closely related two queries are."""
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

def route_and_respond(user_query):
    # 1. Converting the current query into an embedding vector
    query_vector = embedder.encode(user_query)

    # 2. Semantic Caching: Check if a similar problem was solved recently
    for cached_vector, past_response in semantic_cache.values():
        if cosine_similarity(query_vector, cached_vector) >= SIMILARITY_THRESHOLD:
            return f"[Served from Cache] {past_response}"

    # 3. Model Routing: Triage the task based on complexity
    # Simple tasks get routed to a free, locally hosted model (e.g. Llama 3 via Ollama)
    # This routing logic is illustrative-only; not be used in production
    if "summarize" in user_query.lower() or len(user_query) < 100:
        response = call_free_local_agent(user_query)
    else:
        # Complex multi-step reasoning escalates to a larger orchestration agent
        response = call_heavy_reasoning_agent(user_query)

    # 4. Save the new vector and response to our cache for future users
    semantic_cache[user_query] = (query_vector, response)
    return response

# --- Mocking Agent Functions for Illustration: no actual LLMs invoked here ---
def call_free_local_agent(prompt):
    return "Action completed by local, zero-cost model."

def call_heavy_reasoning_agent(prompt):
    return "Action completed by complex orchestration agent."

# Example Usage: mocking the alternate use of different agents/models
# Comment/uncomment to try both examples and try your own
print(route_and_respond("Summarize today's server logs"))
# print(route_and_respond("Draft an optimal one-month itinerary for my upcoming Japan trip. Take into consideration the set of documents, public transport timetables and other documents provided, along with real-time API information"))

Сложность задачи, переданной в промте функции route_and_respond(), определяет, какая модель будет использована.

Результат выполнения этого кода будет одним из двух сообщений, возвращаемых этими функциями:

def call_free_local_agent(prompt):
    return "Action completed by local, zero-cost model."

def call_heavy_reasoning_agent(prompt):
    return "Action completed by complex orchestration agent."

Заключение

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