Почему графы и эмбеддинги — это новый черный?

Представь, что твой AI знает не только похожие тексты, но и связи между ними. Типичный RAG (пайплайн, который не сломается) выдает факты. Граф знаний объясняет, почему они важны. А теперь представь, что оба слоя живут в одном месте — в графовой базе на Rust. Скорость, контроль, никаких лишних движений данных.

Забудь про клей из Python-скриптов, которые таскают вектора из Pinecone в Neo4j. Rust-движок делает все в памяти, одним запросом. Правда, придется попотеть с borrow checker.

Что у нас есть в арсенале на 2026 год?

Neo4j 6.3 с официальным Rust-драйвером neo4j-rs 0.7 — классика, но с Java под капотом. Чисто Rust-проекты вроде IndraDB 2.1 или MemGraph 4.0 (с Rust core) выглядят агрессивнее. Для экспериментов есть графовая библиотека Petgraph 0.6, но это не база, а инструмент для обработки в памяти.

Инструмент	Плюсы	Минусы
Neo4j + Rust-драйвер	Зрелость, Cypher, масштабирование	Java-рантайм, оверхед
IndraDB 2.1	Нативный Rust, встраиваемая	Меньше инструментов, сыроватый UI
Petgraph 0.6	Легковесная, только алгоритмы	Нет персистентности, самописные запросы

1Ставим движок и готовим данные

Допустим, выбрали IndraDB — она встраивается прямо в Rust-приложение. Добавляем в Cargo.toml. Генерируем эмбеддинги через pplx-embed от Perplexity или любую модель 2026 года (например, OpenAI text-embedding-4-large). Вектор — просто массив f32. Но хранить его как свойство узла — скучно. Лучше сделать узел типа Embedding с вектором внутри, а к нему прицепить узлы Document или Entity.

use indradb::{Database, MemoryDatabase, Vertex, Identifier, Json};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = MemoryDatabase::default();
    
    // Вектор из 1536 измерений (как у text-embedding-4-large)
    let embedding_vec: Vec<f32> = vec![0.1; 1536];
    
    // Сохраняем как узел
    let embedding_vertex = Vertex::new(Identifier::new(\"embedding\")?, json!({
        \"vector\": embedding_vec,
        \"model\": \"text-embedding-4-large\",
        \"timestamp\": chrono::Utc::now().to_rfc3339()
    }));
    
    db.create_vertex(&embedding_vertex).await?;
    println!(&\"Вектор сохранен с id: {}\", embedding_vertex.id);
    Ok(())
}

💡

Не пихай вектор в JSON-строку — используй сериализацию в бинарный формат (например, bincode). Иначе запросы на похожесть будут мучительно медленными.

2Связи — это где начинается магия

Один эмбеддинг — это точка в пространстве. Два эмбеддинга с ребром SIMILAR_TO — уже граф. Добавляем ребра между документами, людьми, событиями. Теперь семантический поиск превращается в навигацию по графу. Например, ищешь \"квантовые вычисления\", а система предлагает связанные концепции из графа знаний.

use indradb::{Edge, Identifier, Json};

// Создаем связь между двумя эмбеддингами
let edge = Edge::new(
    embedding_vertex.id,
    Identifier::new(\"SIMILAR_TO\")?,
    another_embedding_vertex.id,
    json!({
        \"cosine_similarity\": 0.87,
        \"inferred\": true
    })
);

db.create_edge(&edge).await?;

Теперь можно делать запросы вроде \"найди все документы, похожие на этот, но только те, что связаны с финансами\". Это уровень, который не достижим в чисто векторном поиске.

Cypher или собственный запрос? Rust-альтернатива

Neo4j говорит на Cypher. IndraDB и подобные используют GraphQL или собственный API. На Rust часто пишут запросы прямо в коде — это быстрее, но менее выразительно. Компромисс: использовать Anchor Engine V5 для предварительной сборки графа, а потом делать запросы через Petgraph.

Cypher красив, но парсинг и выполнение на Rust — боль. Если база встраиваемая, лучше продумать свой DSL. Или использовать готовый движок вроде Neo4j, но тогда теряешь контроль над памятью.

Графовые нейронные сети на прокачке

В 2026 году GNN (Graph Neural Networks) жуют графы на завтрак. Библиотеки вроде PyTorch Geometric или DGL (Deep Graph Library) умеют работать с графовыми данными. Но как передать граф из Rust-базы в Python для обучения? Ответ: сериализация в формате GraphML или через MCP memory server, который стримит графы по gRPC.

// Экспорт подграфа для обучения GNN
let subgraph = db.get_all_vertices_and_edges().await?;
let graphml = export_to_graphml(&subgraph);
std::fs::write(\"training_subgraph.graphml\", graphml)?;

Обученная GNN может предсказывать новые связи или классифицировать узлы. Например, автоматически помечать эмбеддинги как \"технические\" или \"гуманитарные\".

Кому это реально нужно?

Разработчики RAG-систем, уставшие от латания векторных и графовых баз. Особенно для корпоративных чат-ботов.
Исследователи GNN, которым нужен быстрый доступ к графам без Python-оверхеда.
Инженеры edge-устройств, где память и скорость критичны (Rust здесь король).
Авторы семантических поисковиков, как в аналоге Windows Recall, но с пониманием контекста.

А что, если всё сломается?

Графовые базы на Rust молодые. IndraDB может глючить на больших графах. Neo4j с Rust-драйвером стабильнее, но ты зависишь от Java. Всегда имей план Б: экспорт графа в SQLite или даже в простые файлы. Инструменты вроде VectorDBZ помогут отладить векторную часть, но для графов аналоги пока редкость.

Мой совет: начни с Petgraph и встроенных векторов. Если проект выстрелит, перейдешь на IndraDB или Neo4j. Не пытайся построить граф всех знаний интернета в первый же день. Rust научит тебя дисциплине — или сломает твой код на этапе компиляции. И то, и другое полезно.

Подписаться на канал

Rust-графы для AI: храним эмбеддинги и связи в одном движке