Introducing GraphQA: An Agent for Asking Graphs Questions

At Catio, we build a copilot for cloud architecture. Early on, we realized something obvious but often overlooked:

A cloud architecture is a graph.

Services rely on databases, talk to one another through APIs, and move data through queues and pipelines. Configurations define how those pieces interact — what connects to what, and under what conditions. To truly reason about an architecture — whether you’re optimizing it, troubleshooting an outage, or planning a redesign — you have to understand those relationships as a graph.

That realization led us to a simple but critical need: an agent that could reason structurally about architecture — tracing dependencies, evaluating impact, and uncovering optimization opportunities.

So we built GraphQA — an agent that treats your systems as graphs and uses real algorithms to reason over them.

And while it started with cloud architecture, the same idea applies far beyond it. GraphQA can power any workflow where structure matters: mapping dependencies in microservice ecosystems, understanding data lineage, analyzing supply-chain risks, or modeling user journeys.

Wherever relationships define behavior, GraphQA helps agents see — and reason over — the structure behind the system.

Graphs: An Important Substrate in AI Reasoning

LLMs are powerful at reasoning over text — they can summarize, explain, and even plan. But when it comes to structure, they struggle. A language model can describe relationships, not compute them.

Graphs fill that gap. They make relationships explicit and computable — paths, dependencies, hierarchies, communities — all the things that give systems their shape. This isn’t new; decades of graph theory have made structural reasoning a solved problem. What’s new is bringing that capability into an agent’s reasoning loop.

Instead of treating a graph as text to be parsed or summarized, GraphQA lets agents use real graph algorithms — exploring neighborhoods, tracing impact, detecting bottlenecks — alongside their language reasoning.

In practice, this means an agent can not only understand what your architecture is but also how it behaves when something changes.

That’s the philosophy behind GraphQA: bringing graph-native reasoning into an agent’s loop.

The Natural Paths We Tried

When we set out to answer questions about graphs, a few “obvious” paths came up — and we learned quickly why they fall short.

Turn the graph into documents and do RAG. We tried this first. Converting nodes and edges into text made the context huge and the answers vague. The model saw more tokens, not more structure.

Build a Cypher agent. Cypher is expressive, but LLM-generated queries were fragile. Minor schema changes broke prompts, and debugging was painful. It also tied the solution to one backend — not ideal when graphs can live anywhere.

Build GraphQA. Instead of generating queries, we gave the agent direct access to graph algorithms. It could now reason structurally — traversing, ranking, and analyzing relationships — while keeping the flexibility to plug into any graph backend.

That approach clicked. It was fast, interpretable, and agent-friendly — a foundation we could actually build on.

How GraphQA Works Under the Hood

GraphQA isn’t a new query language — it’s an agentic interface for graph reasoning built on a modular, extensible stack. Instead of generating Cypher or Gremlin queries, it lets an agent reason directly through graph algorithms, chaining steps just like a human would.

At its core:

LangGraph orchestrates the reasoning loop — managing tool calls, memory, and intermediate results.
Langfuse provides observability — every reasoning step, tool invocation, and LLM decision is logged and measurable.
The LLM (e.g., OpenAI) interprets natural-language questions and determines which graph operation to run next.
Graph tools are exposed through NetworkX (with optional GPU acceleration via cuGraph) and cover exploration, shortest paths, centrality, clustering, and more.
The system is extensible by design — today it uses NetworkX; tomorrow it can route to your own custom algorithms without changing the agent logic.

Together, these pieces form a reasoning loop where language and structure meet — the LLM interprets intent, LangGraph manages the process, and NetworkX makes relationships computable.

Here’s what that looks like:

A user asks a question through the CLI or API. The GraphQA Agent, orchestrated by LangGraph, interprets the question and invokes the right graph tool (via NetworkX or another backend) to compute dependencies, paths, or patterns from the Graph Data Store. The results feed back into the reasoning loop and are logged in Langfuse for traceability.

The result: an agent that doesn’t just talk about your graph — it actually computes over it, combining the flexibility of natural language with the rigor of algorithmic reasoning.

Examples

Let’s look at how GraphQA compares to Cypher.

Example 1: Blast Radius Analysis

Question: “If this database fails, which services are impacted?”

Cypher:

MATCH (db:Database {name: "orders-db"})<-[:DEPENDS_ON*]-(s:Service)
RETURN DISTINCT s.name;

GraphQA:

{"query_type": "explore_neighborhood", "parameters": {"node_id": "orders-db", "depth": 2}}

Typical Output:

🧠 I found 12 services depending (directly or indirectly) on orders-db.
Top impacted: checkout-service, analytics-service, notifications-service.
Impact depth: up to 3 levels.

GraphQA automatically chose a neighborhood traversal algorithm (multi-hop dependency search) and computed the dependency graph.

Example 2: Detecting Resource Imbalance

Question: “Which of my databases are over- or under-used?”

Cypher + Graph Data Science:

CALL gds.degree.stream({
  nodeProjection: 'Database',
  relationshipProjection: {
    DEPENDS_ON: {
      type: 'DEPENDS_ON',
      orientation: 'REVERSE'
    }
  }
})
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).name AS database, score
ORDER BY score DESC;

GraphQA:

{"stat_type": "centrality", "top_k": 10}

Typical output:

📊 Found 5 databases with unusually high dependency counts:
 - orders-db (21 connections)
 - payments-db (17 connections)

2 under-used databases detected with low centrality scores:
 - logs-db
 - archive-db

GraphQA identified this as a centrality problem, ran degree and betweenness centrality algorithms, and summarized results — all automatically.

Why We’re Releasing It

We built GraphQA because our agents needed to reason over structure — a gap LLMs and traditional RAG systems still can’t fill.

Graphs are everywhere: in cloud architectures, supply chains, social networks, biological systems — yet the ability to reason over them remains locked behind specialized query languages and vendor ecosystems.

GraphQA bridges that gap — giving agents a clean, universal interface for algorithmic reasoning over graphs, regardless of the backend.

We designed it for our own copilots first, because without graph-native reasoning, even the smartest LLM agents are effectively blind to structure.

GraphQA is our attempt at a middle ground:

Agent-first – ask natural questions, get graph-native answers.
Algorithmic core – deterministic reasoning, not prompt gymnastics.
Open & extensible – built on NetworkX today, with support for GPU backends like cuGraph and graph databases such as Neo4j GDS or TigerGraph planned next.

GraphQA isn’t about replacing databases or query languages — it’s about giving agents access to the structural reasoning layer they’ve been missing.

Join Us

GraphQA already powers our recommendation and chat modules at Catio — helping our agents trace dependencies, analyze impact, and make architectural reasoning explainable.

But we think it can be useful far beyond cloud architecture.

If you build with graphs, we’d love for you to:

Try it → github.com/catio-tech/graphqa
Contribute → Add new algorithms, connect other backends, or experiment with new agent flows.
Share → Show us what kinds of questions you ask your graphs.

We believe graphs are the reasoning substrate of modern systems — and with GraphQA, that reasoning is now accessible, agent-friendly, and open to everyone.

‍