GraphRAG is retrieval-augmented generation grounded in a knowledge graph. Instead of returning isolated text chunks by vector similarity alone, retrieval follows the relationships between entities, so the model receives connected context: who did what, when, and how it relates to the question.

GraphRAG, in one engine

Q: Why run GraphRAG on SurrealDB rather than two databases?

GraphRAG needs graph traversal, vector search, and full-text ranking on the same data. Running them in one engine removes the synchronisation problem between a vector store and a graph store, keeps results in one consistent snapshot, and cuts a network hop from every retrieval.

Q: Do I need Agent Memory to use GraphRAG?

No. GraphRAG is a pattern you can build directly on SurrealDB with SurrealQL, and this page shows the core query shape. Agent Memory is the managed option: it assembles the knowledge graph and serves retrieval for you, and is currently in early access.

Flat vector search returns disconnected chunks. GraphRAG grounds retrieval in the relationships between your entities - and SurrealDB runs the traversal, the vector search, and the ranking in a single query.

Start free with SurrealDB View documentation

WHY GRAPHRAG

Retrieval that understands relationships

A vector store can tell you which chunks look similar to a question. It cannot tell you how those chunks relate: which customer raised the ticket, which system the incident touched, which decision superseded which. GraphRAG keeps that structure in the retrieval path, so agents answer from connected context rather than isolated fragments.

Traverse, don't just match

Typed graph edges are first-class records. Retrieval walks from a matched document to the entities, decisions, and events around it in the same query. No second system, no join gymnastics.

Hybrid ranking built in

HNSW vector indexes and BM25 full-text search live beside your operational data. Combine semantic similarity, keyword relevance, and reciprocal rank fusion natively in SurrealQL.

One round trip

No stitching a vector database to a graph database and reconciling results in application code. One engine, one query, one consistent snapshot, and lower latency on every agent turn.

HOW IT WORKS

Three retrieval modes, one SurrealQL query

Embed the question, recall semantically similar passages, rank them against keyword relevance, then walk the graph from the winners to the entities that ground the answer.

-- Embed the question once
LET $q = "why did the deployment fail on Tuesday?";
LET $vec = fn::embed($q);

-- Hybrid recall: vector similarity fused with BM25
LET $passages = search::rrf([
    (SELECT id, title,
        (1 - vector::distance::knn()) AS vec_score
    FROM document
    WHERE embedding <|10,40|> $vec),
    (SELECT id, title,
        search::score(1) AS bm25_score
    FROM document
    WHERE content @1@ $q
    ORDER BY bm25_score DESC)
], 10);

-- Ground the winners: walk to the entities around them
SELECT id, title,
    ->mentions->entity.* AS entities,
    ->mentions->entity->relates_to->entity.* AS related
FROM $passages;

MANAGED OR HAND-BUILT

Build GraphRAG yourself, or let agent memory build it for you

Everything on this page is available in the database today: you design the schema, own the graph, and compose the queries. Agent Memory, our agent memory layer in early access, runs the same pipeline for you - extracting entities, building the knowledge graph, and serving hybrid retrieval from your conversations, documents, and systems.

FREQUENTLY ASKED QUESTIONS