Постоянная память Claude: граф знаний Graphiti + MCP (гайд 2026)

Современные большие языковые модели (LLM) умеют писать код, анализировать документы, вести диалог на десятках языков и проходить сложные экзамены. Но у них есть фундаментальный недостаток: каждая новая сессия начинается с чистого листа. Claude, GPT, Gemini и другие ассистенты не помнят то, что вы им говорили вчера, если только разработчик не добавит специальный механизм памяти. Эта статья посвящена тому, как превратить Claude из «одноразового помощника» в систему с долговременной памятью, которая сохраняет факты, предпочтения и контекст между разговорами.

Мы рассмотрим три уровня памяти: файловую инструкционную память (CLAUDE.md), векторный RAG и граф знаний. Основной фокус — на связке Graphiti + FalkorDB + MCP: открытом стеке, который превращает разговоры в темпоральный граф знаний и подключается к Claude через Model Context Protocol. Вы получите пошаговую инструкцию по развёртыванию, примеры кода, сравнение с альтернативами (mem0, Letta, Cognee, Zep, стандартный MCP memory) и чек-лист внедрения.

Проблема: почему LLM «забывают»

Основная причина «забывчивости» LLM кроется в двух ограничениях архитектуры трансформеров.

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

Второе ограничение — отсутствие состояния между сессиями. LLM по умолчанию не имеют долговременного хранилища. Когда вы закрываете терминал или перезапускаете Claude Desktop, модель не сохраняет ничего: ни ваши предпочтения, ни архитектуру проекта, ни результаты предыдущих обсуждений. Следующий разговор начинается как первый, и вам снова приходится объяснять базовые вещи.

Эти ограничения создают реальные проблемы в работе:

• Повторение контекста. Каждый раз приходится заново рассказывать, какой стек используется в проекте, какие правила оформления кода, какие команды сборки.
• Потеря уроков. Если вчера Claude научился решать специфическую ошибку в вашей среде, сегодня он уже не помнит об этом.
• Невозможность персонализации. Ассистент не накапливает знания о вашем стиле работы, приоритетах и предпочтениях.
• Ошибки из-за устаревших данных. Даже если факты сохранены, модель не всегда понимает, какое из них актуально сейчас, а какое — историческое.

Именно поэтому индустрия активно разрабатывает системы памяти для LLM. Цель — вынести долгосрочные знания за пределы контекстного окна в внешнее хранилище, а затем доставать нужные факты в нужный момент.

Виды памяти для ИИ-ассистента

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

(а) Файловая / инструкционная память (CLAUDE.md)

Это самый простой и надёжный уровень. Вы создаёте в проекте файл CLAUDE.md (или .claude/CLAUDE.md), в котором записываете инструкции, правила и справочную информацию. Claude Code автоматически загружает этот файл в начале каждой сессии. Согласно официальной документации Anthropic, существует несколько уровней памяти: организационный (/Library/Application Support/ClaudeCode/CLAUDE.md), пользовательский (~/.claude/CLAUDE.md), проектный (./CLAUDE.md) и локальный (./CLAUDE.local.md) [1].

Плюсы:

• Полный контроль над содержимым.
• Не требует дополнительных сервисов.
• Работает офлайн.
• Хорошо версионируется в Git.

Минусы:

• Занимает место в контекстном окне.
• Не обновляется автоматически из разговора.
• Плохо масштабируется: слишком длинный CLAUDE.md снижает точность следования инструкциям.

Кроме того, Anthropic добавила функцию Auto memory: Claude сам записывает заметки в ~/.claude/projects/<project>/memory/MEMORY.md на основе ваших поправок и предпочтений. При этом загружаются только первые 200 строк или 25 КБ MEMORY.md, а более детальные тематические файлы читаются по запросу [1].

(б) Векторная память (RAG / embeddings)

Векторный подход хранит фрагменты текста (чанки) в виде эмбеддингов — плотных числовых векторов. Когда пользователь задаёт вопрос, система ищет наиболее семантически близкие чанки и вставляет их в промпт. Это стандартный Retrieval-Augmented Generation (RAG).

Плюсы:

• Хорошо масштабируется на большие документы.
• Простая инфраструктура: достаточно векторной БД (Qdrant, Pinecone, pgvector, Chroma).
• Эффективен для поиска по смыслу.

Минусы:

• Теряет структуру: связи между сущностями неявны.
• Не учитывает время: устаревшие и актуальные факты могут смешиваться.
• Плохо справляется с многошаговыми рассуждениями (multi-hop reasoning).
• Результат зависит от размера и качества чанков.

(в) Граф знаний

Граф знаний хранит информацию в виде сущностей (узлов) и связей (рёбер). Например: (Алиса) — [работает в] → (Яндекс). Современные решения, такие как Graphiti, добавляют временную составляющую: каждый факт имеет окно валидности — когда он стал истинным и когда перестал быть актуальным [2].

Плюсы:

• Явная структура: сущности и связи чётко разделены.
• Поддержка многошаговых рассуждений.
• Возможность временных запросов: «что было истинно 3 месяца назад?»
• Лучшая интерпретируемость: можно визуализировать и проверить.

Минусы:

• Более сложная инфраструктура.
• Требует извлечения сущностей из текста (обычно с помощью LLM).
• Накладные расходы на построение и поддержание графа.

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

• CLAUDE.md — для стабильных правил, стиля кода, архитектурных решений, команд сборки.
• Векторный RAG — для больших документов, баз знаний, FAQ, где важен семантический поиск.
• Граф знаний — для динамичных, связанных, персональных данных: предпочтения пользователя, история проекта, эволюция сущностей.

Что такое граф знаний простыми словами

Граф знаний — это способ хранить информацию не в виде плоского текста или таблиц, а в виде сети взаимосвязанных объектов.

Основные понятия

• Сущность (entity) — объект реального мира или предметной области: человек, компания, продукт, проект, технология.
• Связь (relationship / edge) — отношение между двумя сущностями: «работает в», «использует», «зависит от», «предпочитает».
• Факт (fact) — конкретное утверждение, которое можно выразить тройкой «сущность — связь — сущность» или свойством сущности.
• Эпизод (episode) — исходные данные, из которых извлечён факт: сообщение пользователя, документ, лог события.

Пример простого факта:

(Иван) — [работает в] → (Сбер)
(Иван) — [использует] → (Python)
(Сбер) — [находится в] → (Москва)

Чем граф лучше плоского текста и векторов

Темпоральность: факты устаревают

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

Graphiti решает эту проблему через темпоральные метки на каждом рёбре: valid_at — когда факт стал истинным, invalidated_at — когда он перестал быть актуальным. Старый факт не удаляется, а помечается как исторический. Это позволяет задавать вопросы как о текущем состоянии, так и о состоянии на определённый момент времени [2].

Например:

Март 2024: Клиент на тарифе Free
Июль 2024: Клиент перешёл на Enterprise
Сентябрь 2024: Клиент перешёл на Pro

Граф знает, что сейчас клиент на Pro, но при запросе «что было в июне?» вернёт Free.

Постоянная память Claude на практике

Claude Code от Anthropic предлагает встроенную систему памяти, которая работает на двух уровнях: инструкционном и автоматическом.

CLAUDE.md: ручная память

Файл CLAUDE.md — это основной способ передать Claude стабильный контекст. Он автоматически загружается при запуске сессии. Вы можете создать его в корне проекта, в домашней директории или на уровне организации [1].

Правила хорошего CLAUDE.md:

• Держите файл коротким: цель — до 200 строк.
• Пишите конкретные, проверяемые инструкции.
• Используйте заголовки и списки для структуры.
• Для больших проектов разбивайте правила по директориям через .claude/rules/.
• Используйте синтаксис @path/to/file.md для импорта дополнительных файлов.

Пример минимального проектного CLAUDE.md:

# Проект MyAPI

## Стек
- Python 3.12, FastAPI, SQLAlchemy, PostgreSQL
- Тесты: pytest, запускать через `make test`
- Форматирование: ruff, проверка перед коммитом через `make lint`

## Архитектура
- Роутеры FastAPI находятся в `app/routers/`
- Модели базы данных — в `app/models/`
- Все миграции через Alembic в `migrations/`

## Правила
- Все эндпоинты должны возвращать Pydantic-схемы из `app/schemas/`
- Исключения ловить в роутерах, не в сервисах

Auto memory: память, которую пишет сам Claude

Auto memory доступна в актуальных версиях Claude Code и включается по умолчанию. Claude автоматически сохраняет заметки в ~/.claude/projects/<project>/memory/ на основе ваших корректировок и повторяющихся паттернов [1]. Структура:

~/.claude/projects/<project>/memory/
├── MEMORY.md          # индекс, загружается в сессию
├── debugging.md       # заметки об отладке
├── api-conventions.md # соглашения по API
└── ...

Ограничения Auto memory:

• Загружается только первые 200 строк или 25 КБ MEMORY.md.
• Хранится локально на машине, не синхронизируется между устройствами.
• Не заменяет командные соглашения — для них лучше CLAUDE.md.

Projects memory в Claude

Claude Projects (в веб-версии и приложении) позволяют прикреплять документы к проекту. Это похоже на статический RAG: вы загружаете файлы, и Claude использует их при ответах в рамках проекта. Этот механизм хорош для баз знаний, но не обновляется динамически из разговора.

Расширение памяти через MCP

Чтобы выйти за рамки встроенной памяти, Anthropic предложила Model Context Protocol (MCP) — открытый стандарт для подключения внешних инструментов и источников данных к LLM [3]. MCP-сервер выступает посредником между Claude и внешним хранилищем. Claude видит доступные инструменты (tools) и может вызывать их для записи, чтения или поиска фактов.

Именно через MCP можно подключить к Claude граф знаний Graphiti, векторное хранилище mem0 или стандартный MCP memory server.

Graphiti + FalkorDB как «мозг» ассистента

Что такое Graphiti

Graphiti — это открытый фреймворк от компании Zep для построения темпоральных контекстных графов (temporal context graphs) для ИИ-агентов. В отличие от статических knowledge graphs, Graphiti отслеживает, как факты меняются со временем, сохраняет происхождение каждого факта (provenance) и поддерживает гибридный поиск [2].

Graphiti является основой коммерческой платформы Zep, но выложен в открытый доступ как самостоятельный движок. Zep управляет контекстными графами в масштабе, а Graphiti позволяет строить и запрашивать отдельные графы самостоятельно [4].

Архитектура Graphiti

Graphiti состоит из нескольких слоёв:

1. Источники данных (episodes) — сырые тексты: сообщения чата, документы, JSON-события.
2. LLM-извлечение — модель извлекает сущности и связи из эпизодов.
3. Графовое хранилище — узлы (сущности) и рёбра (факты/связи) с временными метками.
4. Эмбеддинги — векторные представления для семантического поиска.
5. Гибридный поиск — комбинация векторного сходства, полнотекстового поиска (BM25) и обхода графа.

Темпоральная модель

Каждый факт в Graphiti — это ребро с метаданными:

• valid_at — момент, когда факт стал истинным.
• invalidated_at — момент, когда факт перестал быть актуальным (если применимо).
• created_at — когда Graphiti узнал о факте.
• episode_id — ссылка на исходный эпизод.

Когда поступает новая информация, противоречащая старой, Graphiti не удаляет старое ребро, а помечает его как инвалидированное и создаёт новое. Это позволяет отвечать на вопросы о текущем состоянии и о состоянии в прошлом [2].

Почему это сильнее обычного RAG

Graphiti демонстрирует высокие результаты на бенчмарках памяти агентов: 94.7% точности на LoCoMo и 90.2% на LongMemEval при задержке около 150–160 мс [4].

FalkorDB как хранилище

FalkorDB — это высокопроизводительная графовая база данных, построенная как модуль Redis. Она использует разреженные матрицы смежности на основе GraphBLAS, поддерживает язык запросов OpenCypher, полнотекстовый поиск, векторный поиск и протоколы RESP/Bolt [5].

Graphiti может работать поверх Neo4j, FalkorDB и Amazon Neptune. В MCP-варианте от FalkorDB используется именно FalkorDB как база по умолчанию, что обеспечивает низкую задержку и простоту локального развёртывания [6].

Пошаговые инструкции: Claude + Graphiti + FalkorDB

В этом разделе мы развёртываем полный стек: FalkorDB в Docker, Graphiti MCP server и подключаем его к Claude Desktop или Claude Code.

Шаг 1. Поднимаем FalkorDB в Docker

Самый быстрый способ запустить FalkorDB — использовать официальный образ. Откройте терминал и выполните:

# Создаём директорию для данных
mkdir -p falkordb-data

# Запускаем FalkorDB
docker run -d --name falkordb \
  -p 6379:6379 \
  -p 3000:3000 \
  -v "$PWD/falkordb-data:/var/lib/falkordb/data" \
  --restart unless-stopped \
  falkordb/falkordb:latest

После запуска веб-интерфейс доступен по адресу http://localhost:3000. Порт 6379 используется для подключения клиентов через RESP/Bolt.

Проверьте, что контейнер работает:

docker ps --filter name=falkordb

Шаг 2. Устанавливаем Graphiti (Python venv)

Если вы хотите использовать Graphiti как библиотеку или запустить MCP server вручную, создайте виртуальное окружение:

# Создаём окружение
python -m venv .venv

# Активируем (Linux/macOS)
source .venv/bin/activate

# Активируем (Windows)
# .venv\Scripts\activate

# Устанавливаем Graphiti с поддержкой FalkorDB
pip install graphiti-core[falkordb]

Убедитесь, что у вас установлен Python 3.10 или выше. Для работы LLM-извлечения потребуется ключ OpenAI, Anthropic или другого поддерживаемого провайдера.

Шаг 3. Запускаем Graphiti MCP server

Репозиторий Graphiti содержит готовый MCP server. Самый простой путь — использовать Docker Compose из репозитория, который поднимает и FalkorDB, и MCP server [6]:

git clone https://github.com/getzep/graphiti
cd graphiti/mcp_server
docker-compose up

Эта команда запускает:

• FalkorDB на порту 6379
• веб-интерфейс FalkorDB на порту 3000
• Graphiti MCP server на порту 8000

Если вы хотите запустить MCP server вручную (например, для отладки), после установки graphiti-core[falkordb] задайте переменные окружения:

export FALKORDB_HOST=localhost
export FALKORDB_PORT=6379
export OPENAI_API_KEY="sk-..."
export GROUP_ID="my_project"

и запустите сервер из директории mcp_server.

Шаг 4. Подключаем Graphiti MCP server к Claude

Claude Desktop

Для Claude Desktop создайте или отредактируйте файл конфигурации claude_desktop_config.json [6]:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
• Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "graphiti": {
      "command": "mcp-remote",
      "args": [
        "http://127.0.0.1:8000/mcp/"
      ]
    }
  }
}

Сохраните файл и перезапустите Claude Desktop. Теперь Claude может обращаться к инструментам Graphiti.

Claude Code

В Claude Code MCP-серверы настраиваются через файл mcp.json или командой claude mcp add. Пример конфигурации:

{
  "mcpServers": {
    "graphiti": {
      "command": "mcp-remote",
      "args": ["http://127.0.0.1:8000/mcp/"]
    }
  }
}

Или через CLI:

claude mcp add-json graphiti '{
  "command": "mcp-remote",
  "args": ["http://127.0.0.1:8000/mcp/"]
}'

Шаг 5. Какие инструменты появляются

Graphiti MCP server предоставляет набор инструментов для работы с памятью [6]. Типичный набор включает:

• add_episode — добавить эпизод (сообщение, документ, факт) в граф.
• search_nodes — найти сущности по запросу.
• search_facts — найти факты/связи по запросу.
• get_node — получить информацию о конкретной сущности.
• get_neighbors — получить соседей сущности в графе.

Точные имена и сигнатуры могут меняться между версиями, поэтому после подключения полезно спросить Claude: «Какие инструменты Graphiti тебе доступны?»

Шаг 6. Пример: добавить факт в граф и найти его

После подключения вы можете попросить Claude сохранить информацию:

Пользователь: «Запомни, что наш проект использует FastAPI и PostgreSQL, а деплой идёт на Railway.»

Claude вызовет add_episode с этим текстом. Graphiti извлечёт сущности:

• Project (наш проект)
• FastAPI
• PostgreSQL
• Railway

и связи:

• Project uses FastAPI
• Project uses PostgreSQL
• Project deploys_to Railway

Позже, в новой сессии:

Пользователь: «Какой стек у нашего проекта?»

Claude вызовет search_facts или search_nodes, получит связи и ответит:

Шаг 7. Интеграция в рабочий цикл ассистента

Чтобы память работала автоматически, можно построить простой цикл:

1. Перед генерацией ответа Claude вызывает search_facts с текстом запроса пользователя.
2. Полученные факты добавляются в системный промпт как контекст.
3. После ответа Claude вызывает add_episode с новым сообщением пользователя и своим ответом.
4. Graphiti извлекает новые сущности и связи, обновляя граф.

В Claude Desktop и Claude Code часть этого цикла выполняется автоматически, если MCP server предоставляет соответствующие инструменты. В собственных приложениях цикл реализуется вручную:

import asyncio
from graphiti_core import Graphiti

async def chat_loop(graphiti: Graphiti, user_input: str, group_id: str):
    # 1. Поиск релевантных фактов
    facts = await graphiti.search_facts(user_input, group_id=group_id)
    context = "\n".join([f"- {fact.name}" for fact in facts])

    # 2. Генерация ответа (псевдокод)
    response = generate_llm_response(user_input, context)

    # 3. Сохранение эпизода
    await graphiti.add_episode(
        name="user_turn",
        episode_body=f"User: {user_input}\nAssistant: {response}",
        source="conversation",
        source_description="chat turn",
        group_id=group_id,
    )

    return response

Шаг 8. Общая память для нескольких ИИ-клиентов

Одно из ключевых преимуществ MCP + Graphiti + FalkorDB — возможность подключить несколько клиентов к одному хранилищу. Например:

• Claude Desktop на рабочем компьютере
• Claude Code в терминале
• Собственный Python-скрипт
• Другие MCP-совместимые клиенты (Cursor, Cline и др.)

Graphiti обеспечивает изоляцию через group_id: каждый проект, пользователь или рабочая область получает свой граф. Это предотвращает утечку данных между разными клиентами и командами [6].

Пример конфигурации для двух проектов:

# Проект A
export GROUP_ID="project_alpha"

# Проект B
export GROUP_ID="project_beta"

Если оба проекта подключены к одному FalkorDB, их графы остаются изолированными на уровне group_id.

Обзор существующих решений

Рынок систем памяти для LLM активно растёт. Рассмотрим ключевые решения, которые мы изучили в ходе подготовки статьи.

Anthropic Claude Code memory

Официальная документация Claude Code описывает два механизма: CLAUDE.md (ручные инструкции) и Auto memory (автоматические заметки). Файлы CLAUDE.md загружаются в начале каждой сессии, поддерживают импорты через @path, иерархию уровней (managed, user, project, local) и правила для конкретных путей [1]. Auto memory сохраняет уроки в локальную директорию, но ограничена 200 строками/25 КБ индекса и не синхронизируется между устройствами.

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

Graphiti и Zep

Graphiti — открытый движок темпоральных контекстных графов, созданный Zep. Он превращает эпизоды в сущности и связи с временными метками, поддерживает гибридный поиск и работает на Neo4j, FalkorDB, Amazon Neptune [2]. Zep — управляемая платформа поверх Graphiti с SDK, дашбордом и SLA [4].

Польза: явная структура, темпоральность, высокая точность на бенчмарках. Ограничения: требует графовой базы данных, LLM для извлечения, настройки инфраструктуры.

MCP memory server от Anthropic

Стандартный MCP memory server хранит знания в локальном knowledge graph (сущности, наблюдения, связи) в файле JSONL или SQLite. Подключается к Claude Desktop через npx @modelcontextprotocol/server-memory [7].

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

mem0

mem0 — популярный уровень памяти для персонализированного ИИ. Доступен как open-source библиотека, self-hosted сервер и облачная платформа. Извлекает факты из разговоров, хранит векторные эмбеддинги, поддерживает графовую память (graph memory) поверх Neo4j и пользовательскую изоляцию [8].

Польза: простой API, широкая интеграция (LangChain, CrewAI, Vercel AI SDK), гибридный поиск. Ограничения: основной фокус на векторах; графовая память требует дополнительной настройки; облако платное.

Letta (ранее MemGPT)

Letta — фреймворк для stateful агентов, основанный на идее «LLM как операционная система». Использует иерархическую память: core memory (всегда в контексте), archival memory (поиск по требованию), conversational memory и external files. Агент может сам редактировать блоки памяти через инструменты [9].

Польза: глубокая архитектура управления памятью, self-editing, подходит для долгоживущих агентов. Ограничения: более крутая кривая обучения; менее ориентирован на простую интеграцию с Claude.

Cognee

Cognee — открытая AI-платформа памяти, которая превращает неструктурированные данные в knowledge graph. API состоит из четырёх операций: remember, recall, forget, improve. Поддерживает множество бэкендов (Neo4j, Kuzu, NetworkX, Postgres, Qdrant, LanceDB), имеет плагин для Claude Code [10].

Польза: гибкость бэкендов, улучшение памяти через обратную связь, мультимодальность. Ограничения: молодой проект, API ещё стабилизируется, требует понимания pipeline.

FalkorDB и Neo4j

FalkorDB — высокопроизводительная графовая БД на базе Redis, оптимизированная для GraphRAG и агентской памяти [5]. Neo4j — лидер среди графовых баз, имеет обширную экосистему интеграций с LLM, включая LLM Knowledge Graph Builder и Google Gen AI Toolbox [11].

Польза: зрелые решения для хранения графов, хорошая производительность, большое сообщество. Ограничения: FalkorDB использует SSPL-лицензию, Neo4j требует лицензирования для некоторых enterprise-функций.

Сравнительная таблица

Выбор решения зависит от задачи:

• Нужна быстрая локальная память без инфраструктуры — MCP memory server.
• Нужна персонализация чат-бота с простым API — mem0.
• Нужны долгоживущие агенты с self-editing — Letta.
• Нужен гибкий knowledge graph с темпоральностью — Graphiti/Zep.
• Нужна универсальная AI-память с множеством бэкендов — Cognee.

Типичные ошибки и подводные камни

Даже при правильном выборе инструментов внедрение памяти для LLM сопряжено с рисками. Вот наиболее частые проблемы.

Лимиты токенов при извлечении

Graphiti, mem0 и другие системы используют LLM для извлечения сущностей и связей из текста. Каждый эпизод расходует токены. Если вы сохраняете каждое сообщение чата, расходы на LLM-вызовы могут существенно вырасти. Решение — фильтровать эпизоды, сохранять только значимые, использовать дешёвые модели для извлечения.

Дубли сущностей

Один и тот же объект может быть назван по-разному: «Яндекс», «Yandex», «Yandex LLC». Без нормализации имен в графе появляются дубли, что портит поиск и рассуждения. Graphiti и некоторые форки MCP memory server решают это через entity name normalization, но на практике требуется контроль качества.

Приватность данных

Память хранит персональные данные, корпоративную информацию и интеллектуальную собственность. При использовании облачных версий (Zep Cloud, Mem0 Cloud, Letta Cloud) данные покидают вашу инфраструктуру. Для чувствительных сценариев выбирайте self-hosted варианты и шифруйте хранилище.

Стоимость LLM-вызовов

Постоянная память — это не разовая настройка. Каждое добавление эпизода, каждый поиск фактов, каждое обновление графа может требовать вызовов LLM. В проектах с высокой нагрузкой это заметная статья расходов. Планируйте бюджет и используйте кэширование.

Неправильная изоляция tenant

Если несколько пользователей или проектов работают с одним графом, важно правильно настроить group_id или аналогичный механизм изоляции. Без этого память одного пользователя может «просочиться» к другому. Graphiti решает это через group_id [6], mem0 — через user_id и agent_id.

Переоценка возможностей памяти

Память не делает модель разумнее. Она только даёт доступ к фактам. Если изначальные данные неточные или противоречивые, модель будет выдавать неточные ответы. Регулярно аудируйте сохранённые факты.

Конфликт с CLAUDE.md

Если CLAUDE.md и граф знаний дают противоречивые указания, Claude может вести себя непредсказуемо. Важно разделять ответственность: CLAUDE.md — для стабильных правил, граф — для динамичных фактов.

FAQ

1. Обязательно ли использовать FalkorDB с Graphiti?

Нет. Graphiti поддерживает Neo4j, FalkorDB и Amazon Neptune. FalkorDB удобен для локального развёртывания из-за простоты Docker-образа и низкой задержки, но в production вы можете выбрать другой бэкенд [2].

2. Можно ли использовать Graphiti без Claude?

Да. Graphiti — это Python-библиотека с открытым API. Вы можете использовать её в собственных приложениях, агентах или через REST/MCP server. Подключение к Claude — лишь один из сценариев [2].

3. Что лучше для начала: MCP memory server или Graphiti?

Если вам нужна простая локальная память без лишней инфраструктуры — начните с MCP memory server. Если вам важны структура, связи, темпоральность и масштаб — выбирайте Graphiti [7].

4. Как защитить данные в графе знаний?

Используйте self-hosted развёртывание, шифруйте дисковое хранилище, настраивайте изоляцию через group_id/user_id, ограничивайте сетевой доступ к FalkorDB и регулярно делайте резервные копии.

5. Платно ли использование Graphiti?

Сам Graphiti распространяется под Apache 2.0 и бесплатен. Вы платите только за инфраструктуру (сервер, базу данных) и за вызовы LLM/API эмбеддингов. Zep предлагает платное управляемое облако поверх Graphiti [4].

6. Можно ли совместить CLAUDE.md, Auto memory и Graphiti?

Да, и это рекомендуемый подход. CLAUDE.md задаёт стабильные правила, Auto memory собирает локальные уроки, а Graphiti хранит структурированные факты и связи между сессиями.

7. Какие модели LLM подходят для извлечения сущностей?

Graphiti официально поддерживает OpenAI, Anthropic, Azure OpenAI, Google Gemini и Groq (у последнего есть бесплатный API-ключ — удобно для экспериментов). Для извлечения сущностей обычно достаточно компактных моделей вроде GPT-4o mini или Claude Haiku, чтобы снизить стоимость [2].

8. Что произойдёт, если удалить контейнер FalkorDB?

Если вы запускали контейнер без volume (-v), данные пропадут. В инструкции выше мы использовали -v "$PWD/falkordb-data:/var/lib/falkordb/data", поэтому данные сохранятся на диске хоста даже после удаления контейнера.

Заключение

Постоянная память превращает LLM из одноразового помощника в долгосрочного партнёра. Для Claude существует несколько уровней памяти: файловая (CLAUDE.md), автоматическая (Auto memory) и внешняя (через MCP). Граф знаний — самый мощный из внешних подходов, особенно когда данные связаны, динамичны и требуют временной точности.

Связка Graphiti + FalkorDB + MCP даёт открытое, локально развёртываемое решение для агентской памяти. Она превращает разговоры в структурированный темпоральный граф, поддерживает гибридный поиск и легко подключается к Claude Desktop и Claude Code. Альтернативы вроде mem0, Letta и Cognee решают близкие задачи, но с разными компромиссами по сложности, функциональности и стоимости.

Чек-лист внедрения

• Определить, какие данные нужно помнить между сессиями.
• Настроить проектный CLAUDE.md со стабильными правилами.
• Включить Auto memory в Claude Code (если используете CLI).
• Выбрать систему внешней памяти: MCP memory server, mem0, Letta, Cognee или Graphiti.
• Для Graphiti: развернуть FalkorDB в Docker, запустить Graphiti MCP server.
• Подключить MCP server к Claude Desktop / Claude Code.
• Проверить изоляцию через group_id (для нескольких проектов/пользователей).
• Настроить LLM-провайдер для извлечения сущностей.
• Протестировать запись и поиск фактов.
• Настроить резервное копирование хранилища.
• Оценить стоимость LLM-вызовов и оптимизировать частоту записи.
• Провести аудит сохранённых фактов на предмет дублей и устаревших данных.

Источники

1. Anthropic. Claude Code: Memory. code.claude.com/docs/en/memory
2. getzep/graphiti. GitHub repository. github.com/getzep/graphiti
3. Model Context Protocol. Official website. modelcontextprotocol.io
4. Zep. Graphiti: The Context Graph framework. getzep.com/platform/graphiti
5. FalkorDB. Official documentation. docs.falkordb.com
6. FalkorDB blog. Knowledge Graph MCP: Graphiti + FalkorDB memory. falkordb.com
7. modelcontextprotocol/servers. Knowledge Graph Memory Server. github.com
8. mem0ai/mem0. GitHub repository. github.com/mem0ai/mem0
9. letta-ai/letta. GitHub repository. github.com/letta-ai/letta
10. topoteretes/cognee. GitHub repository. github.com/topoteretes/cognee
11. Neo4j blog. Build AI agents with knowledge graphs. neo4j.com
12. Graphiti documentation. Welcome to Graphiti. help.getzep.com/graphiti/getting-started/welcome
13. mem0 documentation. docs.mem0.ai
14. Letta documentation. docs.letta.com
15. Datastudios. Claude Code Memory, CLAUDE.md, Persistent Instructions. datastudios.org