Контекст-инжиниринг для AI-агентов: как файловая система решает проблему нехватки контекста

Проблема, которая сводит с ума всех разработчиков агентов

Ты создал крутого AI-агента. Он умеет всё: анализировать код, писать документацию, искать баги. Но проходит неделя, и ты замечаешь странное поведение. Агент "забывает" детали из прошлых сессий. Ты объясняешь архитектуру проекта вчера, а сегодня он спрашивает базовые вопросы. Каждый раз начинаешь с чистого листа. Звучит знакомо?

Это классическая проблема ограниченного контекстного окна. Даже у GPT-4.7 с его 128K токенов есть лимит. А у локальных моделей типа GLM 4.7 или Kimi K2 ситуация ещё хуже. Контекст сбрасывается после каждой сессии. Агент живёт в вечном настоящем без прошлого.

Файловая система как долговременная память

Представь мозг человека. Есть кратковременная память (контекстное окно LLM) и долговременная (файловая система). Когда ты работаешь над проектом месяц, ты не держишь все детали в голове постоянно. Ты открываешь нужные файлы, смотришь историю изменений, читаешь заметки.

Точно так же работает AI-агент с файловой системой. Это не просто хранилище данных. Это структурированная память с семантическими связями.

Архитектура: как это работает на практике

Не нужно изобретать велосипед. Современные фреймворки типа Deep Agents уже предлагают встроенную файловую систему для агентов. Но понимать механику важно.

1Структура памяти агента

Создаём иерархическую файловую систему:

agent_memory/
├── projects/
│   ├── project_alpha/
│   │   ├── architecture.md
│   │   ├── decisions_log.json
│   │   ├── code_review_notes/
│   │   └── meeting_summaries/
│   └── project_beta/
│       ├── requirements.txt
│       └── api_design.md
├── knowledge_base/
│   ├── coding_patterns/
│   ├── domain_knowledge/
│   └── best_practices/
└── session_logs/
    ├── 2026_01_15_chat.md
    └── 2026_01_16_debugging.md

Каждая папка имеет свою семантику. Projects — активные задачи. Knowledge base — общие знания. Session logs — история взаимодействий.

2Механизм контекстной загрузки

Вот где происходит магия. Когда агент получает задачу, он не загружает всю файловую систему в контекст. Он использует интеллектуальный поиск.

Плохой подход (сжигает токены):

# НЕ ДЕЛАЙ ТАК
context = ""
for root, dirs, files in os.walk('agent_memory'):
    for file in files:
        with open(os.path.join(root, file), 'r') as f:
            context += f.read()
# Теперь у тебя 500K токенов мусора

Умный подход (контекстная выборка):

from langchain_community.vectorstores import Chroma
from langchain_huggingface import HuggingFaceEmbeddings

class ContextLoader:
    def __init__(self, memory_path: str):
        self.memory_path = memory_path
        self.embeddings = HuggingFaceEmbeddings(
            model_name="BAAI/bge-large-zh-v1.5",  # Актуально на 2026
            model_kwargs={'device': 'cpu'}
        )
        
    def load_relevant_context(self, query: str, max_tokens: int = 8000):
        # 1. Семантический поиск по всем файлам
        relevant_files = self.semantic_search(query)
        
        # 2. Приоритизация по типу файла
        prioritized = self.prioritize_by_file_type(relevant_files)
        
        # 3. Обрезка до лимита токенов
        return self.truncate_to_token_limit(prioritized, max_tokens)

Паттерны использования: от теории к практике

Паттерн 1: Контекстное продолжение

Агент работает над задачей несколько дней. Вместо того чтобы каждый раз объяснять всё заново, он читает предыдущие сессии из session_logs.

Пример из реального проекта:

def continue_previous_session(session_id: str):
    """Загружает контекст предыдущей сессии"""
    session_file = f"agent_memory/session_logs/{session_id}.md"
    
    if os.path.exists(session_file):
        with open(session_file, 'r') as f:
            previous_context = f.read()
        
        # Извлекаем только ключевые решения
        key_decisions = extract_decisions(previous_context)
        return f"Продолжаем с прошлой сессии. Ключевые решения:\n{key_decisions}"
    
    return "Начинаем новую сессию"

Паттерн 2: Кросс-проектные знания

Агент находит баг в проекте Alpha. Он проверяет knowledge_base — не сталкивались ли с подобным в проекте Beta? Если да — использует готовое решение.

Паттерн 3: Инкрементальное обучение

Каждая успешная задача попадает в knowledge_base. Агент учится на своих же решениях. Через месяц у тебя не просто инструмент, а опытный специалист.

Интеграция с существующими инструментами

Не нужно писать всё с нуля. Современные фреймворки уже поддерживают файловые системы для агентов.

Мой выбор на 2026 — Deep Agents. У них наиболее продуманная реализация. Файловая система не просто хранит данные — она понимает семантические связи между документами.

Ошибки, которые все совершают (и как их избежать)

Ошибка 1: Хранение всего подряд

Соблазнительно сохранять каждый чих. Через неделю agent_memory весит 10GB, а поиск занимает минуты.

Решение: агрессивная фильтрация. Сохраняй только:

• Ключевые решения с обоснованием
• Успешные решения сложных задач
• Архитектурные изменения
• Обучения на ошибках

Мусорные диалоги вроде "привет, как дела" — удаляй сразу.

Ошибка 2: Отсутствие структуры

Свалка файлов в одной папке. Агент не понимает, что важно, а что нет.

Решение: жёсткая иерархия. Каждый тип данных в своей папке. Используй метаданные:

{
  "file_type": "decision_log",
  "project": "alpha",
  "importance": "high",
  "created_at": "2026-01-20",
  "expires_at": "2026-12-31"
}

Ошибка 3: Игнорирование контекстного окна модели

Даже с файловой системой нужно следить за токенами. Если загрузишь 50K токенов в модель с лимитом 8K — получишь обрезанный контекст.

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

Продвинутые техники для production

Техника 1: Контекстное сжатие на лету

Перед загрузкой в LLM сжимай контекст. Не просто обрезай, а суммаризируй:

def compress_context_for_llm(
    raw_context: str, 
    target_tokens: int,
    model_name: str = "gpt-4.7-turbo"  # Актуально на 2026
) -> str:
    """Сжимает контекст до целевого количества токенов"""
    
    # Если уже влезает — возвращаем как есть
    current_tokens = count_tokens(raw_context, model_name)
    if current_tokens <= target_tokens:
        return raw_context
    
    # Иначе суммаризируем менее важные части
    segmented = segment_by_importance(raw_context)
    
    # Сохраняем важные сегменты полностью
    # Суммаризируем менее важные
    compressed = []
    tokens_used = 0
    
    for segment, importance in segmented:
        if importance == "high":
            compressed.append(segment)
            tokens_used += count_tokens(segment, model_name)
        else:
            summary = summarize_segment(segment, model_name)
            compressed.append(f"[Суммаризировано] {summary}")
            tokens_used += count_tokens(summary, model_name)
            
        if tokens_used >= target_tokens:
            break
            
    return "\n\n".join(compressed)

Техника 2: Семантическое версионирование

Файлы меняются. Агент должен понимать, какая версия актуальна. Реализуй git-like систему для knowledge_base:

class KnowledgeVersionControl:
    def __init__(self, base_path: str):
        self.base_path = base_path
        self.version_file = os.path.join(base_path, ".versions.json")
        
    def commit_change(self, file_path: str, change_reason: str):
        """Фиксирует изменение в файле знаний"""
        # Сохраняем предыдущую версию
        # Записываем метаданные: кто изменил, когда, почему
        # Обновляем семантические индексы

Техника 3: Контекстные подсказки для разных моделей

GPT-4.7 и Kimi K2 требуют разного подхода к контексту. У них разные сильные стороны.

Для GPT-4.7 с большим контекстом можно загружать больше сырых данных. Для Kimi K2 с её ограниченным окном нужна агрессивная суммаризация.

Реальный пример: агент для код-ревью

Давай посмотрим, как файловая система решает конкретную проблему.

Задача: агент проводит код-ревью в большом проекте. За месяц накопилось 200 pull request'ов. Новый разработчик прислал PR с потенциальной проблемой.

Без файловой системы: агент анализирует только текущий PR. Не видит историю, не знает контекст проекта.

С файловой системой:

1. Агент проверяет knowledge_base/project_x/code_patterns/ — там записаны типичные ошибки проекта
2. Ищет в session_logs/ похожие PR — находит 3 случая
3. Проверяет decisions_log.json — видит, почему определённые паттерны были запрещены
4. Формирует контекст из 5 самых релевантных источников (вместо 200)
5. Даёт рекомендацию с ссылками на прошлые решения

Разница как между стажёром и senior-разработчиком. Один видит строчку кода, другой — историю проекта.

Интеграция с мультиагентными системами

Если читал статью про мультиагентные команды, понимаешь проблему: как синхронизировать контекст между агентами?

Файловая система решает и это. Она становится единым источником истины. Все агенты работают с одной памятью.

class SharedAgentMemory:
    def __init__(self, storage_path: str):
        self.storage_path = storage_path
        self.lock = FileLock(os.path.join(storage_path, ".lock"))
        
    def write_context(self, agent_id: str, context: dict):
        """Агент записывает свой контекст"""
        with self.lock:
            file_path = f"{self.storage_path}/shared/{agent_id}.json"
            # Атомарная запись
            # Обновление индексов
            # Уведомление других агентов об изменении

Теперь код-ревьюер и архитектор видят одни и те же decisions_log. Нет рассинхронизации.

Что дальше? Будущее контекст-инжиниринга

На 2026 год это уже не экспериментальная техника, а must-have для production систем. Но развитие не стоит на месте.

Тренды, которые я вижу:

• Автономное обучение агентов — файловая система становится тренировочной базой. Агент анализирует свои прошлые ошибки и улучшает промпты
• Межпроектный перенос знаний — агент, обученный на проекте Alpha, быстрее адаптируется к проекту Beta
• Семантическое сжатие — не просто удаление слов, а понимание смысла и его конденсация
• Прогностическая загрузка контекста — агент предсказывает, какие файлы понадобятся, и загружает их заранее

С чего начать сегодня?

Не нужно переписывать всю систему. Начни с малого:

1. Добавь простую файловую систему для логов сессий
2. Реализуй базовый семантический поиск по прошлым диалогам
3. Начни сохранять ключевые решения в структурированном формате
4. Постепенно добавляй новые типы данных: архитектура, баги, learnings

Через месяц у тебя будет агент, который помнит всё. Не просто поисковик по документам, а полноценный коллега с памятью и опытом.

И последнее: не переусердствуй с оптимизацией. Иногда проще купить больше токенов у OpenAI, чем тратить недели на идеальную файловую систему. Но если твой агент работает с конфиденциальными данными или должен помнить месяцы работы — без файловой системы не обойтись.

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