# Vector RAG vs GraphRAG vs Agentic RAG: Why There Is No Winner

> Vector RAG, GraphRAG, and Agentic RAG preserve different context. Learn when each works, where each fails, and how to combine them in one app.

Canonical URL: https://rushdb.com/blog/vector-rag-graphrag-agentic-rag-comparison-c203b6
Published: 2026-08-19T10:01:00.000Z
Updated: 2026-08-21T13:44:48.873Z
Author: RushDB
Category: Engineering

> Not everything you need can be reached through connections. Not everything you need can be preserved as a semantic vector. And not every question deserves an agent loop. The sweet spot is one application that can use the right retrieval mode for each part of the problem.

Ask five AI engineers whether GraphRAG replaces vector RAG and you will get five different answers, usually shaped by whichever system they built most recently.

The common story is a maturity ladder:

```mermaid
flowchart LR
    V["Vector RAG"] --> G["GraphRAG"] --> A["Agentic RAG"]
```

It implies a simple progression: start with embeddings, graduate to graphs, then graduate again to agents.

That is the wrong mental model.

**Vector RAG, GraphRAG, and Agentic RAG are not three generations competing for the same job. They preserve and recover different kinds of context.**

- **Vector RAG** is strongest when relevance is semantic: *what means something similar to this?*
- **GraphRAG** is strongest when relevance is relational: *what is connected to this, and how?*
- **Agentic RAG** is strongest when retrieval itself must be planned: *which operations do I need, in what order, to answer this?*

Each has a blind spot. A graph cannot traverse a relationship that does not exist. A vector cannot guarantee that ownership, causality, provenance, sequence, or identity survived the embedding. An agent adds latency, cost, nondeterminism, and more ways to fail.

So the practical goal is not to find a winner. It is to build an application where **the retrieval mode follows the information need**.

That is exactly the boundary [RushDB](https://rushdb.com/) draws in one API surface. Its [Semantic Search](https://docs.rushdb.com/learn/semantic-search/) (`db.records.vectorSearch`) handles meaning-based retrieval over an indexed property. Its [Smart Search](https://docs.rushdb.com/learn/search-query/smart-search/) (`db.ai.search`) turns a natural-language request into an inspectable, schema-aware `SearchQuery` for structured and relational retrieval. Its normal [records search](https://docs.rushdb.com/learn/records-and-queries/find-and-query/) handles exact filters, aggregations, and graph traversal. None pretends to solve the others' problem.

## TL;DR

The useful comparison is not `RAG < GraphRAG < Agentic RAG`. It is:

```mermaid
flowchart TD
    Q["What does this query depend on?"]
    Q -->|"Meaning / similarity"| V["Vector RAG"]
    Q -->|"Explicit relationships / topology"| G["GraphRAG"]
    Q -->|"Multiple dependent retrieval steps"| A["Agentic RAG"]
    A --> V
    A --> G
    V --> C["Shared application context"]
    G --> C
    A --> C
```

The sweet spot is a **shared context layer with multiple retrieval modes**:

1. use vector retrieval for fuzzy semantic recall;
2. use graph retrieval when the answer depends on identity, ownership, dependency, provenance, or hierarchy;
3. combine semantic ranking and graph scope when the query needs both;
4. use agentic orchestration only when the sequence of retrieval steps cannot be determined cheaply in advance.

> **Do not force topology into embeddings, and do not force fuzzy meaning into topology. Preserve both representations when your application needs both.**

The architectural test for any system is whether it can do this over the *same* records — whether the vector path and the relational path observe the same data, labels, relationships, and permissions. RushDB keeps those paths on one data model and one [Labeled Meta Property Graph](https://docs.rushdb.com/learn/records-and-queries/labeled-meta-property-graph/), so an application can pick a retrieval mode per query without ever being forced to standardize on a single paradigm.

```mermaid
flowchart LR
    U["One app / one search box"] --> Q{"What does the request need?"}
    Q -->|"Meaning"| V["RushDB Semantic Search"]
    Q -->|"Known structure / relationships"| S["RushDB Smart Search / SearchQuery"]
    Q -->|"Both"| H["Compose semantic + structural retrieval"]
    V --> C["Shared RushDB context"]
    S --> C
    H --> C
```

---

## The problem with the maturity ladder

Vector retrieval, graph retrieval, and agentic orchestration do not optimize the same thing. Vector RAG compresses content into an embedding space where semantic proximity is queryable. GraphRAG preserves explicit entities and relationships so topology is queryable. Agentic RAG gives a model control over retrieval operations so a plan can be adapted as evidence arrives. None strictly contains the other two.

The ecosystem is converging on a more realistic architecture: **one application, several retrieval operators, selected or composed according to query shape.** Microsoft's GraphRAG still exposes vector search alongside local, global, and DRIFT modes;[^ms-query] Neo4j's GraphRAG tooling exposes vector, text-to-Cypher, hybrid, and tool-selecting retrievers.[^neo4j-rag] That is not a compromise between competing paradigms. It is the natural consequence of applications containing different kinds of information.

RushDB takes this to its logical endpoint: rather than bolting several stores together and synchronizing them, it exposes the vector, relational, and natural-language-planning paths over one graph data model. You still select the retrieval operator per query — but all operators read the same records, schema, and permissions, removing a whole class of drift and ACL bugs.

---

## Three capabilities, three blind spots

| Approach | What it preserves best | Best-shaped question | What it does not guarantee |
|---|---|---|---|
| Vector RAG | Semantic similarity in embedding space | “What content means something like this?” | Explicit identity, topology, causality, ownership, sequence |
| GraphRAG | Entities and explicit relationships | “What is connected to this, and how?” | Fuzzy semantic similarity when no useful edge/path exists |
| Agentic RAG | Adaptive retrieval procedure | “What sequence of tools should I use to answer this?” | Better evidence by itself; only as good as its tools and planning |

### Not everything is reachable through connections

Graphs are powerful only where meaningful structure exists. “Find postmortems that describe failures similar to a cascading timeout” has no `SIMILAR_TO` edge to traverse:

```mermaid
flowchart LR
    Q["cascading timeout"] -. semantic proximity .-> D1["Postmortem A"]
    Q -. semantic proximity .-> D2["Incident B"]
    Q -. semantic proximity .-> D3["Runbook note C"]
```

Their similarity exists in language and meaning — a vector question, not a graph traversal. In RushDB terms, this is Semantic Search over an indexed property.

### Not everything can be preserved as a semantic vector

“Which team owns the service affected by INC-204, and which deployment immediately preceded it?” depends on explicit facts:

```mermaid
flowchart LR
    I["INC-204"] -->|AFFECTS| S["Checkout Service"]
    S -->|OWNED_BY| T["Payments Team"]
    D["Deployment 8841"] -->|DEPLOYED_TO| S
    D -->|PRECEDED| I
```

You can serialize these facts and embed them, but nearest-neighbor similarity does not guarantee preservation of relationship semantics, direction, identity, or temporal ordering. The information may be *present* in the corpus while still awkward to *query as a relationship*. Here the correct primitive is structured retrieval: an exact `SearchQuery`, or [Smart Search](https://docs.rushdb.com/learn/search-query/smart-search/) if the user expresses the request in natural language.

### Not every query needs an agent

An exact-ID ownership lookup is cheaper and more predictable as a deterministic graph query than as an LLM plan. A semantic-similarity question needs one vector search. Agentic RAG earns its complexity only when the retrieval plan itself is dynamic.

---

## 1. Vector RAG, and the boundary of embeddings

Vector RAG turns query and content into embeddings and ranks stored vectors by similarity. This is powerful because human questions rarely use the same vocabulary as the source: “How do we stop customers from getting charged twice?” maps to “Duplicate payment capture caused by retry behavior after gateway timeout.”

Vector retrieval is especially strong when the answer is concentrated in one or a few passages, the user's wording differs from the source, and there are no reliable explicit relationships. That describes much documentation search and knowledge-base retrieval.

But embeddings do not magically preserve relational truth. Two nearly identical tickets can belong to different projects and owners; their embeddings may be almost identical, yet “Who owns the checkout timeout affecting Atlas?” is answered by a chain of identity and relationships, not by vector distance.

> **Embeddings encode similarity. They do not guarantee preservation of explicit topology.**

---

## 2. GraphRAG is broader than “use a graph database”

At least four distinct architectures hide under the label:

**Pattern A — graph-enriched local retrieval.** Retrieve something semantically, then expand into connected context (provenance, neighbors, dependencies). Microsoft's local search and RushDB's [GraphRAG tutorial](https://docs.rushdb.com/learn/tutorials/ai-and-rag/graphrag/) both follow this shape: vector-seed for relevant chunks, then traverse `HAS_CHUNK`/`COVERS`-style relationships to enrich context.

**Pattern B — graph-native structured retrieval.** The user asks a relational question directly:

```mermaid
flowchart LR
    C["CUSTOMER"] -->|HAS_INCIDENT| I["INCIDENT<br/>status = open"]
    I -->|AFFECTS| S["SERVICE"]
    S -->|OWNED_BY| T["TEAM<br/>name = Platform"]
```

There is no reason to run vector search. In RushDB this maps to a structured `SearchQuery` via `db.records.find`, or to Smart Search when the request is in natural language.

**Pattern C — graph-generated corpus summaries.** Microsoft's GraphRAG extracts an entity graph, runs community detection, and pre-generates community summaries so global search can reason at corpus level — useful for “what are the major recurring themes?”-style questions, and a structurally different evaluation class than local retrieval.[^ms-paper][^ms-global]

**Pattern D — graph-guided search over operational data.** The graph already exists because the application data is relational (`ACCOUNT → SUBSCRIPTION → INVOICE`, `SERVICE → DEPENDS_ON → SERVICE`). Retrieval is less about document search and more about preserving state, provenance, and causality across an agent's world. This is precisely the class RushDB is built for: nested JSON becomes connected records on import,[^rush-import] so an agent's world model is already a graph rather than a pile of denormalized chunks.

---

## 3. The four most useful hybrid retrieval patterns

### Pattern 1: structured prefilter → vector ranking

Restrict candidates with exact constraints, then rank by similarity. This is frequently the best production pattern because it couples relevance with correctness boundaries such as tenancy, permissions, dates, and lifecycle state.

```mermaid
flowchart TD
    A["All records"] --> F["Structured / graph prefilter"]
    F --> C["Eligible candidates"]
    C --> V["Vector similarity ranking"]
    V --> K["Top-k"]
```

RushDB's `records.vectorSearch()` implements this natively: labels and a `where` clause narrow the candidate set *before* similarity ranking, and `where` supports relationship traversal. Because `where` runs as a graph filter first, a highly selective filter makes semantic search *faster* — fewer records are ranked, not just more correct.[^rush-hybrid]

```sdk
results = db.records.vector_search({
    "labels": ["INCIDENT"],
    "propertyName": "description",
    "query": "authentication failures after a gateway change",
    "where": {
        "customerTier": "enterprise",
        "country": "Germany",
        "createdAt": {"$gte": "2025-07-01"}
    },
    "limit": 10
})

for incident in results.data:
    print(incident.score, incident.data)
___SPLIT___
import RushDB from '@rushdb/javascript-sdk'

const apiKey = process.env.RUSHDB_API_KEY
if (!apiKey) throw new Error('RUSHDB_API_KEY is required')

const db = new RushDB(apiKey)

const results = await db.records.vectorSearch({
  labels: ['INCIDENT'],
  propertyName: 'description',
  query: 'authentication failures after a gateway change',
  where: {
    customerTier: 'enterprise',
    country: 'Germany',
    createdAt: { $gte: '2025-07-01' }
  },
  limit: 10
})

for (const incident of results.data) {
  console.log(incident.score, incident.data)
}
```

### Pattern 2: vector seed → graph expansion

Use vector retrieval to find semantic entry points, then traverse outward to collect context that should not be embedded into every chunk. This is ideal when relevance is fuzzy but context is relational, and it is the pattern behind RushDB's GraphRAG tutorial as well as Neo4j's `VectorCypherRetriever` and LlamaIndex's `VectorContextRetriever`.[^neo4j-rag][^llama-property-graph]

```mermaid
flowchart TD
    Q["Query"] --> V["Vector top-k CHUNK"]
    V --> S["SOURCE"]
    V --> A["AUTHOR"]
    V --> T["TOPIC"]
    V --> I["INCIDENT"]
    S --> C["Context assembly"]
    A --> C
    T --> C
    I --> C
```

### Pattern 3: graph scope → semantic search inside the subgraph

Sometimes you know where in the graph the answer must live, but not which text inside that neighborhood is relevant. Define the relational scope first, then rank semantically only inside it:

```mermaid
flowchart LR
    A["ACCOUNT<br/>name = Acme"] --> P["PROJECT<br/>status = active"]
    P --> N["NOTE candidates"]
    N --> V["Semantic ranking inside scope"]
```

This is stronger than vector search plus metadata when scope depends on relationships that change over time, and safer for authorization-sensitive systems: the candidate universe is structurally bounded *before* semantic relevance is considered. In RushDB it is a relationship traversal inside the `where` of one `vectorSearch` call:

```sdk
results = db.records.vector_search({
    "labels": ["NOTE"],
    "propertyName": "body",
    "query": "migration risk during the move to the new platform",
    "where": {
        "PROJECT": {
            "$relation": {"type": "BELONGS_TO", "direction": "out"},
            "status": "active",
            "ACCOUNT": {
                "$relation": {"type": "OWNS", "direction": "in"},
                "name": "Acme"
            }
        }
    },
    "limit": 10
})
___SPLIT___
const results = await db.records.vectorSearch({
  labels: ['NOTE'],
  propertyName: 'body',
  query: 'migration risk during the move to the new platform',
  where: {
    PROJECT: {
      $relation: { type: 'BELONGS_TO', direction: 'out' },
      status: 'active',
      ACCOUNT: {
        $relation: { type: 'OWNS', direction: 'in' },
        name: 'Acme'
      }
    }
  },
  limit: 10
})
```

That is the difference between “hybrid retrieval” and “vector search plus an application-side join.”

### Pattern 4: parallel retrieval → rank/fuse

Run multiple retrievers independently and merge the results (reciprocal-rank fusion or a learned reranker). Useful when no single retriever dominates, but it executes several paths per query — a good fit when recall matters more than latency, a poor default otherwise. Because RushDB exposes all paths through one client, fusion needs no separate vector, graph, and keyword services.

---

## 4. Agentic RAG is a router and planner, not a better vector index

> **Agentic RAG turns retrieval strategies into tools and gives a model control over which tools to call.**

That is useful when the sequence of steps genuinely cannot be known in advance. But every agentic step carries a tax: another model decision, another round trip, more tokens, another place for tool arguments to be wrong.

> **Do not use an agent to decide something a deterministic router can decide reliably.**

The bigger architectural win for most systems is classifying query shape *before* retrieval. A useful router distinguishes exact lookups, filtered lookups, semantic similarity, relational, hybrid, and multi-step shapes — and a simple deterministic router is enough:

```sdk
def route(query: str, has_ui_filters: bool, has_exact_id: bool, asks_relationships: bool, needs_semantics: bool, needs_multistep: bool) -> str:
    if has_exact_id:
        return "structured"

    if has_ui_filters and not needs_semantics:
        return "structured"

    if asks_relationships:
        return "hybrid" if needs_semantics else "graph"

    if needs_multistep:
        return "agentic"

    return "vector"
___SPLIT___
function route(signals: RouteSignals): string {
  if (signals.hasExactId) return 'structured'

  if (signals.hasUiFilters && !signals.needsSemantics) {
    return 'structured'
  }

  if (signals.asksRelationships) {
    return signals.needsSemantics ? 'hybrid' : 'graph'
  }

  if (signals.needsMultistep) return 'agentic'

  return 'vector'
}
```

This is also where a schema-aware [Smart Search](https://docs.rushdb.com/learn/search-query/smart-search/) fits: instead of handing an agent free rein over arbitrary database operations, RushDB constrains natural-language requests to a bounded, inspectable `SearchQuery` that runs through the normal records path. You get planning where it helps without unbounded tool access.

---

## 5. Cost is more than query latency

**Indexing cost.** A graph extracted from unstructured text requires entity extraction, entity resolution, relationship extraction, and optional community summarization — far more expensive than vector indexing.[^ms-index] LazyGraphRAG explores deferring that cost, but the numbers are implementation-specific, not universal.[^lazy-graphrag] When the source data is already structured (JSON, CSV, a database export), you can model the graph directly: RushDB's JSON import decomposes nested payloads into typed records and creates parent-child relationships during ingestion,[^rush-import] collapsing most graph-construction cost for operational data.

**Query compute.** A vector query is one embedding plus ANN. A graph query is seed identification plus traversal plus filter plus ranking. Global and agentic queries multiply the LLM work.

**Context-window cost.** Retrieval cost is not only database work. An uncontrolled graph expansion turns 5 seeds into ~1,000 candidate facts; the LLM should not receive all of them. GraphRAG needs context budgeting — hop limits, relationship allowlists, per-relation caps, deduplication, reranking, token-budget-aware assembly — just as vector RAG needs top-k tuning.

**Operational complexity.** The hidden cost of hybrid stacks is running a vector database, a graph database, indexing pipelines, synchronization jobs, separate ACL logic, and duplicate deletion paths. The fewer places the vector view and the relational view can disagree, the cheaper the system is to operate — the operational argument for one data model over multiple retrieval operators.[^rush-lmpg]

---

## 6. Freshness and graph quality

**Freshness.** GraphRAG demos assume the graph is correct; production must keep it correct. If ownership is duplicated into dozens of chunks and embeddings, those chunks go stale when the service changes owner. If ownership is a first-class relationship, update it once:

```mermaid
flowchart LR
    S["SERVICE: Checkout"] -->|OWNED_BY| T["TEAM: Commerce Platform"]
```

Separate *semantic evidence* (embeddings) from *operational truth* (explicit records and relationships), and resolve mutable facts — permissions, incident state, account status, active contracts, policy versions — at query time. This is why RushDB's hybrid retrieval keeps `where` as a graph filter executed at query time: tenancy and ownership come from the current graph state, not stale embeddings.[^rush-hybrid]

**Graph quality.** A bad graph makes retrieval worse: duplicated entities fragment traversals, generic `RELATED_TO` edges preserve little queryable meaning, and overconnected neighborhoods stop being selective. Graph construction needs discipline — stable identity, typed relationships, direction, provenance, and explicit separation of observed vs inferred edges. RushDB's relationship-suggestion flow keeps inferred patterns reviewable before approval rather than silently materializing them as truth.[^rush-patterns]

---

## 7. How RushDB removes the need to choose

[RushDB](https://rushdb.com/) is relevant here precisely because its thesis does **not** require every query to become GraphRAG. It puts structured records, relationships, live schema metadata, and semantic indexes behind one data model and API surface, so one application can choose different retrieval paths over the same context. The value is not “graph beats vector”; it is avoiding separate, drifting representations when the application genuinely needs both.

### 7.1 Nested data becomes connected records

Import nested JSON and it becomes a connected shape rather than an opaque blob:[^rush-import]

```sdk
db.records.import_json({
    "label": "PROJECT",
    "data": [{
        "name": "Atlas",
        "ISSUE": [{"title": "Checkout timeout", "status": "open"}],
        "TEAM": [{"name": "Payments"}]
    }]
})
___SPLIT___
await db.records.importJson({
  label: 'PROJECT',
  data: [{
    name: 'Atlas',
    ISSUE: [{ title: 'Checkout timeout', status: 'open' }],
    TEAM: [{ name: 'Payments' }]
  }]
})
```

That topology can later be refined with explicitly typed relationships.

### 7.2 The schema is queryable at runtime

RushDB's [Labeled Meta Property Graph (LMPG)](https://docs.rushdb.com/learn/records-and-queries/labeled-meta-property-graph/) represents property definitions as first-class metadata in the graph, exposing labels, property names, inferred types, value domains, relationship structure, and vector-index metadata as runtime schema.[^rush-lmpg] Query planning is much safer when the model can inspect the actual schema — and application code can discover facets at runtime:

```sdk
properties = db.properties.find({})
facet = next(prop for prop in properties["data"] if prop["name"] == "importance")
values = db.properties.values(facet["id"])
print(json.dumps(values["data"], indent=2))
___SPLIT___
const properties = await db.properties.find({})
const facet = properties.data.find((item) => item.name === "importance")
if (!facet) throw new Error("Property importance is missing")
const values = await db.properties.values(facet.id)
console.log(JSON.stringify(values.data, null, 2))
```

That same runtime schema grounds Smart Search in a real vocabulary — labels, properties, relationships, and semantic indexes from the project, not a static prompt template.

### 7.3 Two senses of “hybrid”

It is useful to separate them, because “one database” does not mean “one query plan”:

**Native hybrid filtering** — relationship + structured constraints, then vector ranking, in one call:

```mermaid
flowchart LR
    R["Relationship + structured constraints"] --> V["Vector ranking"] --> K["Top-k eligible records"]
```

**Multi-stage graph enrichment** — still requires orchestration:

```mermaid
flowchart LR
    V["Vector top-k"] --> T["Traverse from matched records"] --> N["Assemble graph neighborhood"]
```

A real vector-seed → graph-expansion retrieval in RushDB mirrors the [GraphRAG tutorial](https://docs.rushdb.com/learn/tutorials/ai-and-rag/graphrag/):

```sdk
from concurrent.futures import ThreadPoolExecutor
from rushdb import RushDB
import os

db = RushDB(os.environ["RUSHDB_API_KEY"], base_url="https://api.rushdb.com/api/v1")

def graph_rag_retrieve(user_query: str, k: int = 5) -> list[dict]:
    semantic_matches = db.records.vector_search({
        "query": user_query,
        "propertyName": "text",
        "labels": ["CHUNK"],
        "limit": k
    })

    def enrich(chunk):
        source_result = db.records.find({
            "labels": ["SOURCE"],
            "where": {
                "CHUNK": {"$relation": {"type": "HAS_CHUNK", "direction": "out"}, "$id": chunk.id}
            }
        })
        topic_result = db.records.find({
            "labels": ["TOPIC"],
            "where": {
                "CHUNK": {"$relation": {"type": "COVERS", "direction": "out"}, "$id": chunk.id}
            }
        })
        source = source_result.data[0] if source_result.data else None
        return {
            "text": chunk.get("text"),
            "score": chunk.score,
            "source": source.get("filename") if source else "unknown",
            "topics": [topic.get("name") for topic in topic_result.data]
        }

    with ThreadPoolExecutor(max_workers=5) as pool:
        return list(pool.map(enrich, semantic_matches.data))

context = graph_rag_retrieve("How does the caching layer handle invalidation?")
___SPLIT___
import RushDB from '@rushdb/javascript-sdk'

const apiKey = process.env.RUSHDB_API_KEY
if (!apiKey) throw new Error('RUSHDB_API_KEY is required')

const db = new RushDB(apiKey)

async function graphRagRetrieve(userQuery: string, k = 5) {
  const semanticMatches = await db.records.vectorSearch({
    query: userQuery,
    propertyName: 'text',
    labels: ['CHUNK'],
    limit: k
  })

  return Promise.all(
    semanticMatches.data.map(async (chunk) => {
      const [sourceResult, topicResult] = await Promise.all([
        db.records.find({
          labels: ['SOURCE'],
          where: { CHUNK: { $relation: { type: 'HAS_CHUNK', direction: 'out' }, $id: chunk.id } }
        }),
        db.records.find({
          labels: ['TOPIC'],
          where: { CHUNK: { $relation: { type: 'COVERS', direction: 'out' }, $id: chunk.id } }
        })
      ])
      return {
        text: chunk.text,
        score: chunk.score,
        source: sourceResult.data[0]?.filename ?? 'unknown',
        topics: topicResult.data.map((topic) => topic.name)
      }
    })
  )
}

const context = await graphRagRetrieve(
  'How does the caching layer handle invalidation?'
)
```

**Graph-aware filtering can be one retrieval call; graph enrichment is usually a retrieval workflow.**

### 7.4 Smart Search is query planning, not vector ranking

[Smart Search](https://docs.rushdb.com/learn/search-query/smart-search/) translates natural language into an inspectable `SearchQuery`, executes it through the normal records path, and returns the records plus the generated query and warnings. The LLM does not invent arbitrary operations; it produces a constrained query you can inspect, validate, and refine. The docs are explicit: Smart Search is for schema-aware structured, relational, and filtered retrieval — not a substitute for similarity ranking.

The same application uses `db.ai.search` when structure or relationships matter and `db.records.vectorSearch` when meaning matters:

```sdk
# Relational / structured intent: let RushDB plan against the live schema.
relational = db.ai.search(
    "Find active enterprise customers connected to overdue invoices"
)
print(relational.search_query)
print(relational.warnings)
for record in relational:
    print(record.data)

# Semantic intent: rank a known indexed property by meaning.
semantic = db.records.vector_search({
    "labels": ["NOTE"],
    "propertyName": "body",
    "query": "customer may cancel because onboarding is going badly",
    "limit": 10
})
for record in semantic.data:
    print(record.score, record.data)
___SPLIT___
// Relational / structured intent: let RushDB plan against the live schema.
const relational = await db.ai.search(
  'Find active enterprise customers connected to overdue invoices'
)
console.dir(relational.searchQuery, { depth: null })
console.log(relational.warnings)
for (const record of relational.data) {
  console.log(record.data)
}

// Semantic intent: rank a known indexed property by meaning.
const semantic = await db.records.vectorSearch({
  labels: ['NOTE'],
  propertyName: 'body',
  query: 'customer may cancel because onboarding is going badly',
  limit: 10
})
for (const record of semantic.data) {
  console.log(record.score, record.data)
}
```

That is the article's core point implemented literally: **the natural-language interface does not force every request through the same retrieval mechanism.**

Smart Search also lets natural language refine an existing query object via `current_query`/`currentQuery`, turning the generated `SearchQuery` into conversational query-builder state rather than replacing it with an opaque prose-only plan:

```sdk
initial = db.ai.search("Find active enterprise customers created last quarter")
refined = db.ai.search(
    "Only show records from Germany",
    current_query=initial.search_query
)
print(refined.search_query)
print(refined.warnings)
___SPLIT___
const initial = await db.ai.search('Find active enterprise customers created last quarter')
const refined = await db.ai.search('Only show records from Germany', {
  currentQuery: initial.searchQuery
})
console.dir(refined.searchQuery, { depth: null })
console.log(refined.warnings)
```

Raw Cypher remains an escape hatch for projects on a user-owned Neo4j instance,[^rush-raw] but for agent-facing workloads the safer default is the constrained, inspectable query surface.

---

## 8. A worked example: support incident retrieval

A support model with `CUSTOMER → PROJECT → INCIDENT → SERVICE → TEAM`, plus `RUNBOOK` and `DEPLOYMENT`, does not need one universal retrieval endpoint. One search experience can route by intent:

```mermaid
flowchart TD
    U["Support search box"] --> R{"Intent"}
    R -->|"similar failure"| V["vectorSearch(INCIDENT.description)"]
    R -->|"exact ID / relationship"| Q["SearchQuery / Smart Search"]
    R -->|"similar + customer/service scope"| H["where prefilter + vector ranking"]
    R -->|"multi-step evidence"| A["agent/application orchestration"]
    A --> V
    A --> Q
```

- **“Find incidents like this one.”** Vector search over `INCIDENT.description` — no traversal needed.
- **“Find incidents like this one for Acme.”** Acme's structural scope as a prefilter, then semantic ranking: *structure defines eligibility; embeddings rank meaning inside the eligible set.*
- **“Who owns the service affected by INC-204?”** Skip vectors. A deterministic `SearchQuery` — or Smart Search for a natural-language UI — answers directly; adding similarity would not make it more correct.
- **“What runbook should we use for incidents similar to INC-204?”** Get INC-204 → vector-search similar incidents → traverse `INCIDENT → SERVICE → RUNBOOK` → rank/dedupe runbooks.
- **“What failure patterns recur across all incidents this quarter?”** A corpus-level problem: aggregate structured categories, cluster embeddings, or use global/community summaries, depending on whether the patterns exist as explicit data or must be inferred from text.

---

## 9. Evaluate, then migrate

**Evaluate fairly.** A misleading benchmark evaluates every retriever on the same undifferentiated question set. Label queries by information need (semantic-local, exact/structured, relational single/multi-hop, hybrid, global) and report per query class, not just overall. Measure retrieval (Recall@k, MRR/nDCG, path recall), answers (correctness, attribution, unsupported-claim rate), the system (latency, LLM calls, tokens, stale-answer rate), and operational complexity (number of stores, sync pipelines, ACL implementations).[^benchmarkqed]

**Run an ablation, not a migration.** Compare vector-only, vector+filter, vector→graph-expansion, direct-graph, routed hybrid, and agentic hybrid against your query distribution. You may discover vector-only remains best for 60% of traffic, graph traversal improves 20%, hybrid matters for 15%, and only 5% genuinely needs agentic planning. If so, forcing every query through the most expensive pipeline is a regression.

**Migrate incrementally.** Classify failures (semantic miss vs wrong scope vs missing relationship vs global vs multi-step vs stale source), improve vector retrieval first, model only the relationships that matter, add graph scoping (a `where` relationship constraint inside `vectorSearch` — no new infrastructure, because RushDB data is already relational on import),[^rush-import] add graph expansion, add routing, and only then add agentic orchestration where needed.

---

## 10. Decision matrix: where each approach earns its place

| Situation | Vector RAG | GraphRAG | Agentic RAG |
|---|---:|---:|---:|
| Similar-document or semantic search | **Best fit** | Usually unnecessary | Rarely needed |
| Fuzzy question with structured scope | **Best semantic operator**, combined with filters/graph | Useful for scope | Sometimes |
| Exact operational lookup | Weak alone | **Best fit** when relationships matter | Usually unnecessary |
| Multi-hop ownership / dependency / provenance | Weak alone | **Best fit** | Useful if the path must be discovered dynamically |
| Semantic seed + connected evidence | **Needed for fuzzy seed** | **Needed for enrichment** | Optional orchestration |
| Corpus-wide themes | Local vector baseline is weak | Global/community GraphRAG can help | Useful for decomposition |
| Dynamic multi-tool investigation | Useful tool | Useful tool | **Best fit** when the plan changes as evidence arrives |
| Lowest possible latency | Often strongest | Depends on traversal | Usually weakest |
| Rich explicit provenance | Limited unless denormalized | **Strongest** | Depends on tool evidence |

The table is intentionally not a leaderboard. Each bold cell marks a different query shape, not a globally superior architecture.

---

## 11. The sweet spot: one app, multiple retrieval modes

The architecture I would default to is a **shared context layer with multiple retrieval modes**:

```mermaid
flowchart TD
    APP["One application"] --> R["Schema-aware router"]
    R --> V["Vector RAG<br/>semantic similarity"]
    R --> G["GraphRAG<br/>relationships / topology"]
    R --> A["Agentic RAG<br/>adaptive planning"]
    A --> V
    A --> G
    V --> B["Evidence budget"]
    G --> B
    A --> B
    B --> RR["Rerank / validate"]
    RR --> OUT["Answer or action"]
```

The point is not that every request is hybrid. It is that the same application can be vector-only for one query, graph-only for another, and genuinely hybrid for a third. The design principle:

1. preserve semantic information where semantic retrieval is useful;
2. preserve explicit relationships where correctness depends on structure;
3. keep hard filters and permissions deterministic;
4. route simple queries directly;
5. compose retrieval modes only when the query genuinely crosses information types;
6. use an agent only when the sequence cannot be predetermined reliably.

Underneath this is the reason hybrid retrieval exists: applications contain at least two irreducible information spaces.

```mermaid
flowchart LR
    M["Semantic space<br/>meaning, paraphrase, similarity"] --> APP["Application context"]
    T["Topological space<br/>identity, links, provenance, dependency"] --> APP
```

Embedding space excels at the left side; graph structure at the right. Neither is a lossless encoding of the other. Agentic orchestration becomes useful when a task must cross between them — coordination across capabilities, not replacement of them.

The goal is not the most sophisticated retrieval pipeline. It is the least complicated pipeline that still preserves the evidence needed for the answer.

---

## The short decision rule

| The answer depends mainly on... | Start with... |
|---|---|
| semantic similarity, paraphrase, fuzzy meaning | Vector RAG |
| explicit entities, relationships, hierarchy, provenance, ownership | GraphRAG |
| both semantic relevance and structural context | Combine vector + graph |
| an unknown or changing sequence of retrieval steps | Agentic RAG |

And remember the two failure conditions that make a single-paradigm architecture brittle:

> **Not everything is reachable through connections.**
>
> **Not everything can be preserved as a semantic vector.**

The strongest system is not the one that pushes everything into a graph, everything into vectors, or everything through an agent. It is the one that refuses to destroy useful information just to standardize on one retrieval paradigm — and that is the architectural role [RushDB](https://rushdb.com/) occupies: a shared context layer where structured data, relationships, semantic retrieval, and agent-driven querying coexist over the same records. [Semantic Search](https://docs.rushdb.com/learn/semantic-search/) handles meaning; [Smart Search](https://docs.rushdb.com/learn/search-query/smart-search/) plans schema-aware natural-language queries; [Hybrid Retrieval](https://docs.rushdb.com/learn/tutorials/ai-and-rag/hybrid-retrieval/) combines structural constraints with semantic ranking; and [GraphRAG](https://docs.rushdb.com/learn/tutorials/ai-and-rag/graphrag/) shows the multi-stage vector-seed → graph-expansion pattern.

**Right tool. Right query. Same application.**

---

## Sources

[RushDB Features](https://rushdb.com/features)

[^ms-paper]: Darren Edge et al., **From Local to Global: A Graph RAG Approach to Query-Focused Summarization** — https://arxiv.org/abs/2404.16130

[^ms-query]: Microsoft GraphRAG, **Query Engine Overview** — https://microsoft.github.io/graphrag/query/overview/

[^ms-local]: Microsoft GraphRAG, **Local Search** — https://microsoft.github.io/graphrag/query/local_search/

[^ms-global]: Microsoft GraphRAG, **Global Search** — https://microsoft.github.io/graphrag/query/global_search/

[^ms-index]: Microsoft GraphRAG, **Indexing Overview / Methods** — https://microsoft.github.io/graphrag/index/overview/ and https://microsoft.github.io/graphrag/index/methods/

[^lazy-graphrag]: Microsoft Research, **LazyGraphRAG: Setting a new standard for quality and cost** — https://www.microsoft.com/en-us/research/blog/lazygraphrag-setting-a-new-standard-for-quality-and-cost/

[^benchmarkqed]: Microsoft Research, **BenchmarkQED: Automated benchmarking of RAG systems** — https://www.microsoft.com/en-us/research/blog/benchmarkqed-automated-benchmarking-of-rag-systems/

[^neo4j-rag]: Neo4j, **GraphRAG Python User Guide: RAG / Retrievers** — https://neo4j.com/docs/neo4j-graphrag-python/current/user_guide_rag.html

[^llama-property-graph]: LlamaIndex, **Using a Property Graph Index** — https://developers.llamaindex.ai/python/framework/module_guides/indexing/lpg_index_guide/

[^rush-semantic]: RushDB, **Semantic Search** — https://docs.rushdb.com/learn/semantic-search/

[^rush-hybrid]: RushDB, **Hybrid Retrieval: Filters Plus Semantic Search** — https://docs.rushdb.com/learn/tutorials/ai-and-rag/hybrid-retrieval/

[^rush-graphrag]: RushDB, **GraphRAG — Graph-Enriched Retrieval Augmented Generation** — https://docs.rushdb.com/learn/tutorials/ai-and-rag/graphrag/

[^rush-smart]: RushDB, **Smart Search** — https://docs.rushdb.com/learn/search-query/smart-search/

[^rush-lmpg]: RushDB, **Labeled Meta Property Graph** — https://docs.rushdb.com/learn/records-and-queries/labeled-meta-property-graph/

[^rush-import]: RushDB, **Import Data** — https://docs.rushdb.com/learn/records-and-queries/import-data/

[^rush-patterns]: RushDB, **Suggested Relationship Patterns** — https://docs.rushdb.com/learn/relationships/suggested-patterns

[^rush-raw]: RushDB, **Raw Queries** — https://docs.rushdb.com/learn/records-and-queries/raw-queries/
