GraphProbe AI: Building an Agentic GraphRAG System with TigerGraph

sreevalli — Thu, 01 Oct 2026 17:55:56 +0000

GraphProbe AI: Building an Agentic GraphRAG System with TigerGraph

Modern RAG systems are good at finding relevant pieces of information. But when a question requires connecting multiple entities, following relationships, checking evidence, and deciding what information is still missing, simple retrieval can fall short.

That is the problem we explored with GraphProbe AI.

Investigate. Connect. Verify.

GraphProbe AI is an Agentic GraphRAG system designed to investigate questions by combining graph relationships, retrieval, evidence evaluation, and multi-step reasoning.

The Problem

A conventional retrieval pipeline generally follows a straightforward pattern:

Question → Retrieve Documents → Generate Answer

This works well when the answer exists directly inside a relevant document.

But consider questions such as:

Which entities are connected through multiple relationships?
What relationships connect several companies?
What evidence supports those relationships?
Which additional information is needed before an answer can be verified?

These questions require more than finding similar text.

The system needs to identify entities, understand relationships, traverse a graph, retrieve supporting information, evaluate the evidence, and potentially perform another retrieval step.

That is where GraphProbe AI focuses.

Our Approach

GraphProbe AI combines three retrieval approaches:

RAG

Retrieves relevant textual information.

GraphRAG

Uses graph entities and relationships to provide structural context.

Agentic GraphRAG

Allows an orchestrator to decide what to do next based on the original question, discovered entities, previous evidence, and remaining information gaps.

The resulting workflow is:

Question → Entity Linking → Graph Traversal → Similarity Search → Evidence Evaluation → Verification → Answer

The important part is that this is not simply a fixed sequence.

The investigation can adapt depending on what the system discovers.

Agentic Investigation

The core idea is an orchestrator that coordinates specialized investigation steps.

Depending on the question and available evidence, the system can use capabilities such as:

Entity linking
Graph traversal
Similarity search
Document retrieval
Evidence aggregation
Multi-hop reasoning
Evidence evaluation
Verification

For example, an investigation might follow:

Entity Linking → Graph Traversal → Answer

while another question may require:

Similarity Search → Entity Identification → Graph Traversal → Supporting Documents → Evidence Evaluation → Answer

This allows the investigation strategy to change according to the information available.

Why TigerGraph?

Relationships are central to the problems GraphProbe AI investigates.

A graph makes it possible to represent entities and their connections explicitly rather than treating every piece of information as isolated text.

TigerGraph provides the graph foundation used by our system to explore these relationships and support multi-hop investigation.

Instead of only asking:

"Which text looks similar to this question?"

we can also ask:

"Which entities are connected, how are they connected, and what evidence supports those connections?"

This combination is especially useful for relationship-heavy questions.

Evidence Matters

Generating an answer is only one part of an investigation.

GraphProbe AI also tracks evidence used during the investigation.

The system records information such as:

Retrieved evidence
Connected entities
Graph traversal results
Retrieval operations
Evidence evaluation
Verification steps
Agentic trace
Tokens used
Investigation latency
Stopping reason

This creates an investigation trace rather than only returning a final paragraph.

Agentic Trace

One of the key outputs of GraphProbe AI is the agentic trace.

A simplified investigation can look like:

QUESTION
   ↓
ENTITY LINKING
   ↓
GRAPH TRAVERSAL
   ↓
VECTOR SEARCH
   ↓
EVALUATE EVIDENCE
   ↓
VERIFY
   ↓
FINAL ANSWER

Each step records what the system attempted and what information was obtained.

This makes the reasoning process easier to inspect and helps identify whether an answer is supported by the available evidence.

Knowing When to Stop

An investigation should not continue indefinitely.

GraphProbe AI therefore includes evidence evaluation and verification as part of the workflow.

The system can determine whether the available evidence is sufficient for the current investigation and record why the process stopped.

This gives the final result additional context:

What did we find?

How did we find it?

What evidence supports it?

Why did the investigation stop?

Comparing Retrieval Strategies

GraphProbe AI also provides a comparison between:

Pipeline	Approach
RAG	Document-focused retrieval
GraphRAG	Graph + retrieval
Agentic GraphRAG	Adaptive multi-step investigation

The comparison helps us examine differences in retrieval behavior, evidence usage, token consumption, latency, and investigation traces.

The benchmark results are generated from actual system execution rather than manually entered values.

Technology Stack

The project uses:

Python for the backend and investigation logic
FastAPI for the API layer
TigerGraph for graph-based investigation
GraphRAG for combining graph and retrieval context
Groq for language-model generation
Vercel for the frontend
Render for backend deployment

The architecture is designed around a clear separation between the investigation engine, graph layer, retrieval capabilities, and user interface.

What We Built

The final application provides an investigation workspace where a user can submit a question and inspect:

The generated answer
Connected entities
Supporting evidence
Agentic investigation trace
Tokens used
Latency
Confidence information
Investigation ID
Stopping reason

There are also dedicated views for comparing retrieval approaches and examining benchmark metrics.

Evaluation

For the hackathon evaluation, GraphProbe AI was tested against the provided evaluation questions.

The system produces raw outputs containing:

Answers
Tokens used
Agentic traces

We also evaluate the behavior of the different retrieval pipelines using runtime-generated results.

We intentionally avoid presenting manually fabricated accuracy or performance numbers. The goal is for every reported result to correspond to an actual system execution.

What We Learned

Building GraphProbe AI highlighted an important difference between traditional retrieval and agentic retrieval.

A useful investigation is not necessarily about retrieving more information.

It is about retrieving the right information, understanding relationships between entities, evaluating evidence, and deciding what to investigate next.

Graph-based context can provide structure that pure text retrieval does not naturally expose, while an agentic layer can adapt the investigation strategy instead of following a single fixed pipeline.

What's Next

There are several directions we would like to explore:

More sophisticated entity resolution
Improved multi-hop planning
Stronger evidence ranking
More efficient retrieval strategies
Larger graph datasets
Better evaluation of agentic stopping decisions
More detailed investigation analytics

Conclusion

GraphProbe AI is our exploration of what happens when GraphRAG becomes an adaptive investigation process rather than a single retrieval step.

The core idea is simple:

Investigate. Connect. Verify.

By combining TigerGraph, retrieval, specialized investigation capabilities, evidence evaluation, and an orchestrator, GraphProbe AI turns complex questions into traceable multi-step investigations.

The result is not just an answer.

It is an answer accompanied by the path, evidence, and reasoning process used to reach it.

Project

GraphProbe AI

Repository:
https://github.com/Sreevalli20/agentic-tiger

Live Application:
https://frontend-gamma-ecru-m8dndislo7.vercel.app

Backend:
https://graphprobe-ai-backend.onrender.com

DEV Community: sreevalli

GraphProbe AI: Building an Agentic GraphRAG System with TigerGraph

GraphProbe AI: Building an Agentic GraphRAG System with TigerGraph

The Problem

Our Approach

Agentic Investigation

Why TigerGraph?

Evidence Matters

Agentic Trace

Knowing When to Stop

Comparing Retrieval Strategies

Technology Stack

What We Built

Evaluation

What We Learned

What's Next

Conclusion

Project