The problem
Blockchains generate an enormous amount of activity every few seconds: transfers, swaps, mints, burns. All of this is technically public, but in practice, most people can’t access it. Why?
- The data comes in raw, encoded formats that require deep technical knowledge (ABIs, RPC calls, event decoding).
- Analysts have to build custom indexers or wrangle rigid dashboards that only answer a narrow set of questions.
- For non-developers, the barrier is even higher — turning blockchain’s “open data” into real-world insights is nearly impossible.
And with the recent rise of Layer-2 (L2) chains like Base, Optimism, and Arbitrum, the challenge has only grown. L2s are designed to scale Ethereum by batching and processing transactions faster and cheaper — but that means the raw data volume is exploding. On Ethereum mainnet, activity was already complex; on L2s, we now see multiples of that load, every second. Some even operate on “optimistic” assumptions (treating transactions as valid until proven otherwise), which further accelerates throughput.
This creates a paradox: blockchains are the most transparent systems ever built, yet the insights remain inaccessible to most of the people who need them — investors, builders, researchers, even everyday token holders.
Goals
- Natural language → Cypher, safely and consistently
- Multi-tenant subgraphs, with strong isolation and access control
- Real-time UX, including streaming responses and step visibility
- A scalable operating model for subgraph creation, lifecycle management, and monetization (credits, subscriptions)
Our Solution
We engineered the GraphAI Chat Interface as a production-grade system around two core ideas:
- Clean subgraph boundaries so answers stay relevant and trustworthy.
- A tool-driven agent that can plan, query, recover from errors, and synthesize results into human-readable responses.
How It Works
1) Query Execution Pipeline
When a user asks a question, the platform runs a structured pipeline: authentication, credit checks, dynamic schema and context construction, agent execution, result synthesis, and persistence.
2) Streaming Responses (SSE)
Instead of making users wait for a single final answer, GraphAI streams progress in real time using Server-Sent Events, including status updates, intermediate agent steps, parallel tool executions, and the final response.
3) Deep Agent (Tool-Based Reasoning)
At the core is a LangChain-based “Deep Agent” that can do multi-step planning, parallel execution, and iterative refinement when errors occur.
The agent’s primary capability is a read-only Cypher execution tool with guardrails:
- Blocks write operations (CREATE, MERGE, SET, DELETE, etc.)
- Automatically enforces subgraph isolation
- Limits results to keep queries safe and predictable
Subgraphs: From Request to Live Data
GraphAI isn’t just “chat over a database.” It includes an operational workflow for creating and managing subgraphs:
- Users submit a request (natural language or YAML)
- YAML is generated and validated
- Admin review approves or rejects
- Infrastructure provisioning creates queueing and subscriptions
- The subgraph activates and becomes queryable
The system supports core on-chain event types (transfers, swaps, mints, burns, native transfers), plus configurable backfills for historical data.
It also automatically enriches subgraphs with token and pool metadata via external sources (for example, token metadata via Alchemy and pool metadata via DexScreener).
“Lens” Design: Purpose-Built Subgraphs
To make subgraphs easier to configure correctly, we implemented specialized lens types optimized for common analysis goals:
- Wallet Lens: wallet-centric activity and monitoring
- Token Lens: token contract activity and holder patterns
- DEX Lens: pool activity, swaps, and liquidity behavior
Platform Features That Make It Deployable
Credits and Subscriptions
GraphAI includes a built-in monetization and control layer (query credits, subgraph creation costs, and plan limits).
A background enforcement service can pause and resume subgraphs automatically based on subscription status and limits, including notification flows.
Multi-Channel Access
Beyond the web interface, GraphAI supports:
- Telegram bot experiences (mobile-first querying)
- Discord bot experiences (slash commands, mentions, rich embeds)
- MCP server integration, exposing GraphAI tools to other AI applications
Observability and Reliability
The platform ships with Prometheus metrics, runtime logging, and latency breakdowns so the system can be tuned like a real production service.
Security and Guardrails
GraphAI’s query layer is designed to be safe by default: read-only validation, enforced subgraph isolation, timeouts, result limits, authentication, and row-level controls.
Outcome
GraphAI now has a modern foundation for “natural language blockchain analytics” that is:
- Fast and understandable (streamed execution and synthesized answers)
- Accurate by construction (subgraph isolation + schema-aware prompting)
- Operationally scalable (managed subgraph workflow, backfills, metadata enrichment)
- Deployable as a business (credits, subscriptions, enforcement, notifications, bots, MCP)