Skip to content

CausalGraphRAG

Methodology → causal retrieval

Stop retrieving paragraphs. Start retrieving mechanisms.

Classic RAG retrieves text chunks and asks the model to stitch them into an explanation. CausalGraphRAG retrieves paths in a causal graph — then produces a trace you can audit.

brCausalGraphRAG Constraints & SHACL Graphs

Why this matters

A path is constrained

Edges can be typed, validated, and governed. The system can reject paths that violate rules.

A paragraph is not

Text can contain contradictions, missing assumptions, and policy violations while still sounding coherent.

Mechanism > relevance

Similarity finds “about the topic”. Causal traversal targets “explains the outcome”.

Unknown is an output

If no valid path exists, the correct behavior is abstention with a falsification plan.

Debuggable failures

When something goes wrong, you can localize the break: which edge failed validation, which source is missing, or which constraint blocked the path.

Better under change

As policies evolve and evidence shifts, constraints and provenance gates keep behavior stable — and make necessary updates explicit instead of silent.

Advantages (why this is the future)

Decision-grade outputs

Outputs are constrained by structure, not vibes. You get answers that are checkable — and abstention when checks fail.

Auditability by default

Every result is a trace object linked to evidence and versions. That’s how you pass reviews, regulators, and internal postmortems.

Governance becomes enforceable

Policies live as constraints, not paragraphs. The system can deterministically reject invalid paths and forbidden assertions.

Faster iteration

When you change rules, you update constraints and schemas — not prompt folklore. Failures become reproducible and fixable.

Composable across domains

The same primitives and gates work across medicine, finance, security, and law. Only the graph content changes, not the logic.

Lower long-term cost

Model churn stops being existential. When memory and validity live outside the LLM, you can swap models without rewriting reality.

Minimal flow

flowchart TB
%% Styles (brModel Standard)
classDef i fill:#D3D3D3,stroke-width:0px,color:#000;
classDef p fill:#B3D9FF,stroke-width:0px,color:#000;
classDef r fill:#FFFFB3,stroke-width:0px,color:#000;
classDef o fill:#C1F0C1,stroke-width:0px,color:#000;
classDef s fill:#FFB3B3,stroke-width:0px,color:#000;

I_Q(["❓ Question / outcome Y"]):::i
P_S("🎯 Select start nodes"):::p
P_Search("🧭 Constrained path search"):::p
P_Valid("🔒 Validate edges + provenance"):::p
D_OK{"✅ Valid path?"}:::s
R_T(["🧾 Trace object (path + evidence + assumptions)"]):::r
O_A(["✅ Answer with mechanism"]):::o
S_X(["🛑 Abstain + missing data / violated rule"]):::i

I_Q --> P_S --> P_Search --> P_Valid --> D_OK
D_OK -->|"Yes"| R_T --> O_A
D_OK -->|"No"| S_X

%% Clickable nodes
click P_Valid "/methodology/constraints/" "Constraints & SHACL"
click R_T "/methodology/brcausalgraphrag/" "brCausalGraphRAG"

Core loop: start with ❓ outcome Y, choose 🎯 start nodes, search 🧭 constrained paths, then run 🔒 validation. Only a ✅ valid path produces a 🧾 trace object and a ✅ mechanistic answer; otherwise the system 🛑 abstains with a concrete failure reason.

Diagram: why this beats chunk retrieval

 flowchart TB
%% Styles (brModel Standard)
classDef i fill:#D3D3D3,stroke-width:0px,color:#000;
classDef p fill:#B3D9FF,stroke-width:0px,color:#000;
classDef r fill:#FFFFB3,stroke-width:0px,color:#000;
classDef o fill:#C1F0C1,stroke-width:0px,color:#000;
classDef s fill:#FFB3B3,stroke-width:0px,color:#000;

I_Stakes(["Decision context"]):::i
D_Audit{"✅ Need audit and validity?"}:::s

P_RAG("RAG: retrieve chunks"):::p
P_TXT("Text synthesis"):::p
S_Plaus(["⚠️ Plausible narrative (unclear validity)"]):::i

P_CG("Causal graph: retrieve paths"):::p
R_Path(["Mechanism chain (A → B → C)"]):::r
R_Trace(["Trace object (evidence + provenance)"]):::r
O_Audit(["✅ Auditable decision (or refusal)"]):::o

I_Stakes --> D_Audit
D_Audit -->|"No"| P_RAG --> P_TXT --> S_Plaus
D_Audit -->|"Yes"| P_CG --> R_Path --> R_Trace --> O_Audit

%% Clickable nodes
click P_RAG "/methodology/llm-tool-rag/" "LLM + Tool + RAG"
click P_CG "/methodology/causalgraphrag/" "CausalGraphRAG"
click R_Trace "/methodology/brcausalgraphrag/" "brCausalGraphRAG"

Why paths beat chunks: when ✅ audit and validity matter, you must route through 🧠 causal paths that yield a 🧾 trace. When stakes are low, teams often accept 🔎 chunks → text synthesis, but the output remains ⚠️ plausible rather than decision-grade.

Diagram: validity gates (how abstention becomes deterministic)

flowchart TB
%% Styles (brModel Standard)
classDef i fill:#D3D3D3,stroke-width:0px,color:#000;
classDef p fill:#B3D9FF,stroke-width:0px,color:#000;
classDef r fill:#FFFFB3,stroke-width:0px,color:#000;
classDef o fill:#C1F0C1,stroke-width:0px,color:#000;
classDef s fill:#FFB3B3,stroke-width:0px,color:#000;

I_P(["Candidate path"]):::i
P_V1("Edge + type validity"):::p
P_V2("Provenance requirements"):::p
P_V3("Policy + safety constraints"):::p
D_Pass{"✅ All gates pass?"}:::s
R_T(["Emit trace (what passed)"]):::r
O_O(["✅ Continue to answer"]):::o
S_X(["🛑 Refuse (why it failed)"]):::i

I_P --> P_V1 --> P_V2 --> P_V3 --> D_Pass
D_Pass -->|"Yes"| R_T --> O_O
D_Pass -->|"No"| S_X

%% Clickable nodes
click P_V3 "/methodology/constraints/" "Constraints & SHACL"
click R_T "/methodology/brcausalgraphrag/" "brCausalGraphRAG"

Deterministic abstention: validity is enforced as a sequence of gates (types, provenance, policy). If ✅ all gates pass, the system emits a trace of what passed and proceeds; if not, it 🛑 refuses with the specific gate that failed.

What you get (operationally)

  • A mechanistic chain (A → B → C), not a narrative collage
  • A trace object you can store, diff, audit, and replay
  • A crisp “unknown” when the graph has no valid path