FS-Researcher: практический гайд по созданию ИИ-исследователя с файловой системой вместо контекстного окна

Контекстное окно - это тюрьма. Пора сбежать

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

128K токенов у GPT-4 Turbo? 200K у Claude 3.5 Sonnet? Шутки. Для серьезного исследования нужно хранить десятки статей, сотни заметок, тысячи связей. Контекстное окно сжимает ваш ИИ до размеров золотой рыбки.

FS-Researcher - это побег. Не очередной RAG, не векторные базы, не сложные архитектуры. Простая, почти примитивная идея: если LLM не может помнить все, пусть пишет в файлы и читает из них.

Архитектура, которая работает на удивление просто

FS-Researcher - это два агента в тандеме. Не десять, не сложный оркестр. Всего два. Как в хорошем детективе: один собирает улики, второй строит теорию.

1 Собиратель (Gatherer)

Его задача - бегать по интернету, находить информацию и складывать в правильные папки. Как библиотекарь с гиперактивностью.

Структура папок жесткая, почти военная:

research_project/
├── sources/
│   ├── primary/          # Первоисточники
│   ├── secondary/        # Аналитические статьи
│   └── data/            # Статистика, таблицы
├── notes/
│   ├── raw/             # Сырые выдержки
│   ├── processed/       # Обработанные заметки
│   └── connections/     # Связи между источниками
├── drafts/
│   ├── outline.md       # Структура отчета
│   ├── sections/        # Черновики разделов
│   └── references.bib   # Библиография
└── output/
    └── final_report.md  # Готовый результат

2 Аналитик (Analyst)

Этот парень не ходит в интернет. Он сидит в папках, читает файлы, находит связи и пишет отчет. Его контекстное окно - это десятки, сотни файлов, которые он открывает последовательно.

Каждый раз, когда Аналитику нужно что-то вспомнить, он не полагается на память LLM. Он идет в папку, открывает файл, читает. Медленно? Да. Надежно? Абсолютно.

Код, который не стыдно показать на собеседовании

Вот как выглядит ядро Собирателя. Никакого машинного обучения, только чистый Python и здравый смысл.

import os
import json
from datetime import datetime
from typing import List, Dict
import requests
from bs4 import BeautifulSoup

class ResearchGatherer:
    """Агент-собиратель для FS-Researcher"""
    
    def __init__(self, project_path: str):
        self.project_path = project_path
        self.setup_folders()
        
    def setup_folders(self):
        """Создаем структуру папок с нуля"""
        folders = [
            'sources/primary',
            'sources/secondary', 
            'sources/data',
            'notes/raw',
            'notes/processed',
            'notes/connections',
            'drafts/sections',
            'output'
        ]
        
        for folder in folders:
            os.makedirs(os.path.join(self.project_path, folder), exist_ok=True)
    
    def save_source(self, content: str, source_type: str, metadata: Dict):
        """Сохраняем источник с метаданными"""
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        filename = f"{timestamp}_{metadata.get('title', 'source')[:50]}.md"
        
        # Определяем папку по типу источника
        if source_type == 'primary':
            folder = 'sources/primary'
        elif source_type == 'secondary':
            folder = 'sources/secondary'
        else:
            folder = 'sources/data'
        
        filepath = os.path.join(self.project_path, folder, filename)
        
        # Сохраняем с фронтматером YAML
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write('---\n')
            for key, value in metadata.items():
                f.write(f'{key}: {value}\n')
            f.write('---\n\n')
            f.write(content)
        
        return filepath
    
    def extract_key_points(self, content: str, source_id: str) -> List[str]:
        """Извлекаем ключевые моменты для заметок"""
        # Здесь можно использовать локальную LLM
        # Например, через Ollama с моделью Llama 3.2 3B
        key_points = [
            "Основная гипотеза исследования",
            "Методология",
            "Ключевые результаты",
            "Ограничения исследования"
        ]
        
        # Сохраняем как сырую заметку
        note_filename = f"raw_note_{source_id}.md"
        note_path = os.path.join(self.project_path, 'notes/raw', note_filename)
        
        with open(note_path, 'w', encoding='utf-8') as f:
            f.write('\n'.join([f"- {point}" for point in key_points]))
        
        return note_path

Аналитик: как заставить ИИ думать, а не вспоминать

Вот где магия. Аналитик работает с файлами как с расширенной памятью. Его промпт выглядит так:

ANALYST_SYSTEM_PROMPT = """
Ты - исследовательский аналитик. У тебя есть доступ к файловой системе проекта.

ПРАВИЛА РАБОТЫ:
1. НЕ полагайся на свою память (контекстное окно)
2. ВСЕГДА проверяй факты в файлах
3. Когда нужно вспомнить что-то - открой соответствующий файл
4. Делай промежуточные заметки в папке notes/processed
5. Создавай связи между источниками в notes/connections

СТРУКТУРА ПРОЕКТА:
{sources_path} - исходные материалы
{notes_path} - твои заметки
{drafts_path} - черновики отчета

Твоя задача: проанализировать все материалы и написать качественный отчет.
"""

Каждый раз, когда Аналитик начинает новый раздел отчета, он:

1. Сканирует папку sources/ на наличие релевантных материалов
2. Читает файлы последовательно (по 3-5 за раз, чтобы не перегружать контекст)
3. Делает выжимку в notes/processed
4. Ищет связи с другими материалами через перекрестные ссылки
5. Пишет черновик раздела

Это медленнее, чем засунуть все в одно контекстное окно? Да, в 5-10 раз медленнее. Но результат в 100 раз качественнее.

Почему файловая система лучше векторных баз

Все помешались на RAG и векторных базах. Закинул документы, ищешь семантическое сходство, получаешь релевантные чанки. Красиво. И бесполезно для исследований.

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

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

Настройка агентов: инструкции, которые работают

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

Вот как выглядит полный промпт для Собирателя:

GATHERER_INSTRUCTIONS = """
Ты - исследователь-собиратель. Твоя единственная задача - находить и систематизировать информацию.

ШАГИ РАБОТЫ:
1. ПОЛУЧИ ТЕМУ ИССЛЕДОВАНИЯ
2. СОСТАВЬ СПИСОК КЛЮЧЕВЫХ СЛОВ
3. ИЩИ В:
   - Google Scholar (академические статьи)
   - arXiv (препринты)
   - Конференции (NeurIPS, ICML, ICLR)
   - Отраслевые блоги
4. ДЛЯ КАЖДОГО ИСТОЧНИКА:
   - Определи тип (primary/secondary/data)
   - Извлеки полный текст
   - Сохрани в правильную папку
   - Добавь метаданные:
     * title
     * authors
     * year
     * url
     * key_findings (3-5 пунктов)
5. ЕСЛИ источник важен - сразу создай сырую заметку

НЕ анализируй. НЕ делай выводов. Только собирай и систематизируй.
"""

Обратите внимание на последнюю строку: "НЕ анализируй. НЕ делай выводов." Это критически важно. Собиратель, который начинает анализировать, - это катастрофа. Он будет тратить время на размышления вместо сбора.

Интеграция с локальными моделями

Запускать FS-Researcher на GPT-4 - это как ехать на Ferrari за хлебом. Дорого и бессмысленно. Вся архитектура заточена под локальные модели.

Вот минимальная конфигурация:

# config.yaml
models:
  gatherer:
    provider: "ollama"
    model: "llama3.2:3b"  # Для сбора информации хватит
    temperature: 0.1
    
  analyst:
    provider: "ollama"
    model: "qwen2.5:7b"   # Для анализа нужно больше мощи
    temperature: 0.3
    
storage:
  project_root: "./research_projects"
  max_file_size_mb: 10
  backup_interval_hours: 6

search:
  google_api_key: "${GOOGLE_API_KEY}"
  scholar_max_results: 50
  use_proxy: false

Llama 3.2 3B отлично справляется с классификацией источников и извлечением ключевых пунктов. Qwen 2.5 7B (последняя стабильная версия на 04.02.2026) достаточно умна для анализа и написания отчета.

Если нужна максимальная производительность, посмотрите мой полный каталог инструментов для локального ИИ. Там есть все, от инференса до тонкой настройки.

Ошибки, которые сломают ваш FS-Researcher

Я видел десятки попыток реализовать эту архитектуру. Вот что не работает:

Ошибка 1: Один агент вместо двух

"Да зачем мне два агента? Сделаю одного универсального!" - говорит начинающий разработчик. Через неделю его агент путает сбор информации с анализом, теряет фокус, начинает генерировать ерунду.

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

Ошибка 2: Слабая структура папок

"Создам папку sources и буду все туда кидать". Через три дня у вас 200 файлов без метаданных, без классификации, без связей. Аналитик не сможет в этом разобраться.

Жесткая структура изначально кажется излишней. Через неделю вы понимаете, что она спасает проект.

Ошибка 3: Экономия на метаданных

Сохранять только текст статьи - преступление. Без авторов, года публикации, URL, типа источника (первичный/вторичный) ваш анализ будет поверхностным.

Каждый файл должен начинаться с YAML-фронтматера:

---
title: "Attention Is All You Need"
authors: ["Vaswani, Ashish", "Shazeer, Noam", "Parmar, Niki"]
year: 2017
url: "https://arxiv.org/abs/1706.03762"
source_type: "primary"
key_findings:
  - "Представлен механизм внимания без RNN/CNN"
  - "Архитектура Transformer"
  - "Параллельная обработка последовательностей"
importance_score: 9.5
---

Практический пример: исследование новых архитектур LLM

Допустим, мы хотим исследовать новые архитектуры LLM, появившиеся в 2025-2026 годах. Вот как работает FS-Researcher:

1. Собиратель ищет статьи по ключевым словам: "LLM architecture 2025", "Transformer alternatives", "Mamba architecture", "Hybrid models"
2. Находит 30+ статей, сохраняет в sources/primary и sources/secondary
3. Для каждой статьи создает сырую заметку с ключевыми пунктами
4. Аналитик начинает работу: читает по 3-4 статьи за раз
5. Создает связи: "Архитектура X использует подход из статьи Y, но улучшает Z"
6. Пишет сравнительную таблицу в notes/processed
7. Формирует структуру отчета в drafts/outline.md
8. Пишет разделы, постоянно сверяясь с источниками
9. Генерирует итоговый отчет в output/final_report.md

Весь процесс занимает 4-6 часов вместо 2-3 дней ручной работы. И самое главное - качество. Отчет будет содержать десятки ссылок на источники, глубокий анализ, сравнение архитектур.

FS-Researcher vs. DeepResearch: что выбрать?

Яндекс сделал крутой DeepResearch, который умеет искать в интернете, анализировать, сравнивать. Но у него есть фундаментальная проблема: он облачный, проприетарный, и вы не контролируете данные.

FS-Researcher - это open-source альтернатива, которую вы разворачиваете у себя. Все данные остаются на ваших серверах. Вы можете:

• Добавлять собственные источники (внутренние документы, базы знаний)
• Настраивать агентов под конкретные задачи
• Интегрировать с другими системами (Jira, Confluence, Git)
• Запускать на своем железе без интернета

Для корпоративных исследований, особенно в условиях российского ИИ-комплаенса, это не преимущество, а необходимость.

Советы по масштабированию

Когда проект вырастает до 500+ файлов, нужна оптимизация:

Индексация

Добавьте простой индексный файл:

def update_index(project_path):
    """Создает JSON-индекс всех файлов проекта"""
    index = {
        "sources": [],
        "notes": [],
        "connections": []
    }
    
    for root, dirs, files in os.walk(project_path):
        for file in files:
            if file.endswith('.md'):
                filepath = os.path.join(root, file)
                rel_path = os.path.relpath(filepath, project_path)
                
                # Читаем метаданные из фронтматера
                with open(filepath, 'r', encoding='utf-8') as f:
                    content = f.read()
                    
                if content.startswith('---'):
                    # Парсим YAML фронтматер
                    pass
                
                index_entry = {
                    "path": rel_path,
                    "size": os.path.getsize(filepath),
                    "modified": os.path.getmtime(filepath)
                }
                
                # Добавляем в нужный раздел
                if 'sources' in rel_path:
                    index["sources"].append(index_entry)
                elif 'notes' in rel_path:
                    index["notes"].append(index_entry)
    
    # Сохраняем индекс
    index_path = os.path.join(project_path, "project_index.json")
    with open(index_path, 'w', encoding='utf-8') as f:
        json.dump(index, f, indent=2)

Кэширование

Аналитик не должен каждый раз перечитывать все файлы. Добавьте кэш семантических эмбеддингов для быстрого поиска:

from sentence_transformers import SentenceTransformer
import numpy as np

class SemanticCache:
    def __init__(self):
        # Используем легкую модель для эмбеддингов
        self.model = SentenceTransformer('all-MiniLM-L6-v2')
        self.cache = {}
    
    def get_similar(self, query: str, files: list, top_k: int = 5):
        """Находит наиболее релевантные файлы"""
        query_embedding = self.model.encode(query)
        
        similarities = []
        for filepath in files:
            if filepath not in self.cache:
                # Читаем и кэшируем эмбеддинг
                with open(filepath, 'r', encoding='utf-8') as f:
                    content = f.read()[:1000]  # Первые 1000 символов
                self.cache[filepath] = self.model.encode(content)
            
            sim = np.dot(query_embedding, self.cache[filepath])
            similarities.append((filepath, sim))
        
        # Сортируем по сходству
        similarities.sort(key=lambda x: x[1], reverse=True)
        return [path for path, _ in similarities[:top_k]]

Что дальше? От файловой системы к когнитивной ОС

FS-Researcher - это первый шаг. Следующий уровень - это когнитивная операционная система, где файловая система становится долговременной памятью, а агенты - процессами.

Представьте:

• Агент-наблюдатель, который следит за новыми публикациями по теме
• Агент-рецензент, который проверяет качество анализа
• Агент-визуализатор, который создает графики и диаграммы
• Версионность исследований: ветки, мержи, пул-реквесты

Это уже не инструмент для исследования. Это лаборатория в коде.

Стартовый набор

Хватит читать, пора делать. Вот минимальный рабочий код:

# 1. Установите зависимости
pip install requests beautifulsoup4 sentence-transformers

# 2. Установите Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 3. Скачайте модели
ollama pull llama3.2:3b
ollama pull qwen2.5:7b

# 4. Создайте проект
mkdir my_research && cd my_research
mkdir -p {sources/{primary,secondary,data},notes/{raw,processed,connections},drafts/sections,output}

# 5. Напишите скрипт агентов (код выше)
# 6. Запустите сбор информации
python gatherer.py --topic "Новые архитектуры LLM 2025-2026"

# 7. Запустите анализ
python analyst.py --project ./my_research

Через час у вас будет первый отчет. Сырой, неидеальный, но уже лучше, чем 90% того, что пишут люди за день.

Файловая система победила контекстное окно. Просто потому, что у нее нет ограничений.