GraQle — The Knowledge Graph Your AI Coding Assistant Doesn't Have

Your AI assistant guesses. GraQle knows.

Let's be honest about what's happening right now

You paste context into Claude Code. You craft careful prompts for Codex. You babysit every response because your AI assistant has no idea what your architecture actually looks like.

It doesn't know that PaymentService has 47 downstream consumers. It doesn't know that the last three times someone touched auth/middleware.ts, it broke the session graph. It doesn't know your team decided six months ago to never use inheritance in the domain layer.

You know. But your AI doesn't. So you compensate. You over-prompt. You review everything twice. You are the context window.

GraQle fixes this.

What GraQle actually is

GraQle is a knowledge graph reasoning engine that sits underneath your AI coding assistant — Claude Code, Codex, Cursor, Aider, or anything that speaks MCP. It scans your codebase, builds a full architectural graph (modules, dependencies, constraints, risk surfaces, historical lessons), and exposes that graph as structured reasoning context.

Your AI assistant stops guessing. It starts knowing.

GraQle is not:

• An AI coding assistant
• A Copilot competitor
• Autocomplete
• Another chat sidebar

GraQle is:

• The #1 pairing tool for Claude Code, Cursor, and OpenAI Codex
• A knowledge graph that scales to 12,000+ nodes
• A governance layer that runs before code changes happen
• The memory your AI assistant should have had from day one

Five things GraQle does that nothing else can

1. Preflight Governance

Before your AI writes a single line, GraQle runs preflight checks against your architecture graph. Constraint violations, naming conventions, domain boundaries — caught before the diff exists, not after.

"The best code review is the one that never needs to happen."

2. Impact Analysis Across 12,000+ Node Graphs

Ask: "What breaks if I refactor UserService?" GraQle traverses your full dependency graph — not just imports, but consumers, risk surfaces, constraint propagation, and transitive impact chains. Real graph traversal. Not keyword search.

3. Lesson Memory

GraQle remembers what went wrong. That production incident from the auth refactor? Encoded as a lesson node in the graph. Next time any AI agent (or human) touches that surface area, the lesson activates automatically. Your team stops repeating mistakes. Intelligence compounds.

4. Graph-of-Agents

Every node in your knowledge graph can act as an autonomous reasoning agent. Modules debate each other. Subsystems raise concerns. Convergent message passing resolves conflicts across multi-round deliberation. This isn't a pipeline — it's a reasoning parliament for your codebase.

5. Fold-Back Predictions

GraQle doesn't just answer queries — it feeds reasoning results back into the graph, strengthening future predictions. Every interaction makes the system smarter. Intelligence that compounds, not decays.

Works with everything you already use

12+ LLM Backends

Anthropic (Claude), OpenAI (GPT-4, Codex), AWS Bedrock, Ollama (fully local), Google Gemini, Groq, DeepSeek, Together AI, Mistral, vLLM, llama.cpp, and custom OpenAI-compatible endpoints. Vendor-agnostic by design.

AI Coding Tools

Claude Code, OpenAI Codex CLI, Cursor, Aider, Continue, Cline — anything that speaks MCP (Model Context Protocol) connects natively. 35+ MCP tools exposed out of the box.

Graph Backends

Neo4j or local NetworkX/JSON. Start local, scale to production graph databases when ready. Neptune support available via web API.

Getting Started

Free tier. No auth. No API key. Just start.

1. Install this extension from the VS Code Marketplace
2. Install the CLI:

   pip install graqle
   

3. Scan your workspace — open the Command Palette (Ctrl+Shift+P) and run GraQle: Scan Workspace
4. Start asking — open the chat panel with Ctrl+Shift+G and ask about your architecture

That's it. GraQle scans your codebase, builds the knowledge graph, and starts serving reasoning context to your AI tools. The free tier includes all core features — preflight governance, impact analysis, lesson memory, graph visualization, and MCP tools.

No external telemetry. No phone-home. Fully offline capable.

Commands

Settings

Plans

View all plans

How it Works

Your codebase
     |
  graq scan          <- builds knowledge graph (graqle.json)
     |
  graq mcp serve     <- GraQle reasoning server (stdio JSON-RPC)
     |
  VS Code extension  <- connects, queries, displays results

The extension spawns graq mcp serve as a local process. All reasoning happens on your machine or via your configured LLM backend — your code never leaves your environment unless you explicitly configure a cloud backend.

Who this is for

GraQle is built for senior developers, staff engineers, and tech leads who already use Claude Code or Codex and have hit the ceiling.

You've noticed your AI assistant:

• Suggests changes that violate architectural decisions made months ago
• Can't reason about impact beyond the current file
• Has no memory of past incidents or lessons
• Treats your 200-service monorepo the same as a todo app

You've been compensating with longer prompts, more context stuffing, and manual review. GraQle replaces all of that with a structured knowledge graph your AI can actually reason over.

The uncomfortable truth

Every AI coding tool on the market is building better language models. None of them are building better knowledge of your system.

A smarter model with no architectural context is just a more confident guesser.

GraQle is the architectural context.

Your AI assistant guesses. GraQle knows.

Privacy

• Your code is not sent to GraQle servers during reasoning
• The knowledge graph is stored locally at graqle.json in your workspace
• Authentication uses API keys stored in VS Code's encrypted SecretStorage
• GraQle Cloud is used only for authentication and plan tier verification
• No external telemetry, fully offline capable

Links

• Website
• Documentation
• Pricing
• GitHub
• Issues
• Security