Managed graph database
The graph database for AI agents
CognoDB is a fully managed graph database — nodes, relationships and millisecond traversals over Bolt and Cypher. Every official Neo4j driver connects unchanged, with no cluster to run.
Loads from where your data already lives, and speaks Bolt to your app.
Amazon S3
Google Cloud Storage
Azure Blob Storage
BigQuery
Snowflake
PostgreSQLAmazon S3Google Cloud StorageAzure Blob StorageBigQuerySnowflakePostgreSQLAmazon S3Google Cloud StorageAzure Blob StorageBigQuerySnowflakePostgreSQLAmazon S3Google Cloud StorageAzure Blob StorageBigQuerySnowflakePostgreSQL
Apache Kafka
Apache Spark
Delta Lake
Apache Iceberg
CSV & Parquet uploadApache KafkaApache SparkDelta LakeApache IcebergCSV & Parquet uploadApache KafkaApache SparkDelta LakeApache IcebergCSV & Parquet uploadApache KafkaApache SparkDelta LakeApache IcebergCSV & Parquet uploadWhy a graph
Some questions are about connections, not similarity
Vector and relational stores each answer a different question well. When the answer is a path — who's connected to what, and how — a graph is the model that fits.
| What an agent needs | Similarity search | Rows & joins | Context graph |
|---|---|---|---|
| Find what's connected, not just similar | Cosine distance only — no concept of an edge | A join per relationship type | Typed edges are the data model |
| “What depends on X?” at unknown depth | No traversal at all | Recursive CTEs, tuned per query | [*1..n] — depth is a parameter |
| Provenance on every fact | Metadata blob, invisible to search | Another audit table to maintain | An edge property — returned with the path |
| A private graph per agent or tenant | Namespaces in a shared index | A schema per tenant, migrations forever | An instance each — a credential boundary |
| Explain why this answer | A score, unexplained | Reconstruct the join path by hand | The path IS the answer — return it |
Token economics
Cut LLM token costs by ~98.7%.
Instead of dumping the whole knowledge base into context every turn, CognoDB retrieves only the connected neighbourhood relevant to the current query. At 2,000 entities, that drops from 202,285 tokens per query to 2,668 — and the gap widens as the graph grows, because baseline tokens scale with corpus size while graph-retrieval tokens stay bounded by neighbourhood size.
Token counts measured with the GPT-4 BPE tokenizer (cl100k_base) against the public entity-graph benchmark. Savings scale with knowledge-base size; retrieval stays bounded by neighbourhood, not corpus.
- Baseline tokens
- 202,285per query @ 2K entities
- Graph retrieval
- 2,668per query @ 2K entities
- Saved per query
- ~199,617tokens avoided
- Cost saved / 1K queries
- ~$599at $3 / 1M input tokens
Connect
Your existing drivers already work
CognoDB speaks Bolt 5.0–5.4 and understands Cypher. Point the official driver for your language at the instance URI — the code doesn't change.
from neo4j import GraphDatabase
driver = GraphDatabase.driver(
"bolt+ssc://db-7f3a2c1e.databases.cognodb.cloud",
auth=("cognodb", DB_PASSWORD),
)
with driver.session() as session:
result = session.run(
"MATCH (p:Person)-[:FOLLOWS]->(f) "
"WHERE p.name = $name RETURN f.name AS name",
name="Ada",
)
for record in result:
print(record["name"])See it run
Watch a query run in CognoDB
A three-hop traversal across customers, orders and products — written the way you'd ask it, answered in a single query over Bolt.
MATCH (c:Customer {id: "C-1042"})-[:PLACED]->(o:Order)
-[:CONTAINS]->(p:Product)<-[:CONTAINS]-(other:Order)
RETURN p.name, count(other) AS also_bought
ORDER BY also_bought DESC LIMIT 3| p.name | also_bought |
|---|---|
| Trail Runner GTX | 214 |
| Merino Base Layer | 187 |
| Ultralight Rain Shell | 141 |
Illustrative session — measured figures live in the benchmark band, with methodology.
The console
Provision, connect and monitor in one place
Create a database, get a connection string, and watch it run — status, connection counts and cost per month on one screen.
Instances, not infrastructure.
Create a database, pick a size and a region, and watch it come up — status, live connection counts and cost per month on one card.
Why CognoDB
Built to be provisioned, then forgotten
In production
“Every relationship, document reference and workflow dependency is a graph node, traversed in real time as agents answer questions and take actions.”
In production since 2025 · a knowledge graph under continuous writes from four ingestion paths.
The numbers on this page come from that live workload and from the benchmark and compatibility suites that run on every release build — measured, not projected.
- 1Read-only throughput — 40 concurrent clients replaying a seeded workload for 60 s. The mixed run (10% writes) sustained 62,189/s. July 2026 graph benchmark: SNAP soc-Pokec (1.63 M nodes, up to 30.6 M edges) on one n2-standard-8 (8 vCPU / 32 GiB), CognoDB on defaults, median of 3 reps after warm-up.
- 2p95 latency for a two-hop, friends-of-friends traversal against the loaded graph. July 2026 graph benchmark: SNAP soc-Pokec (1.63 M nodes, up to 30.6 M edges) on one n2-standard-8 (8 vCPU / 32 GiB), CognoDB on defaults, median of 3 reps after warm-up.
- 3Edges merged per second over a fixed 60 s window (CognoDB wrote 2.70 M edges in its minute). July 2026 graph benchmark: SNAP soc-Pokec (1.63 M nodes, up to 30.6 M edges) on one n2-standard-8 (8 vCPU / 32 GiB), CognoDB on defaults, median of 3 reps after warm-up.
- 4On-disk store size divided by edges loaded, read from the container's cgroup counters — a compact store keeps the working set cached. July 2026 graph benchmark: SNAP soc-Pokec (1.63 M nodes, up to 30.6 M edges) on one n2-standard-8 (8 vCPU / 32 GiB), CognoDB on defaults, median of 3 reps after warm-up.
Learn
New to graphs? Start here
Short, honest explainers — what a graph database is, how Cypher reads, and where GraphRAG helps ground an LLM. Every example runs on the free tier.
Concepts
What is a graph database?
Nodes, relationships, and why traversals beat joins.
Read →Cypher
What is Cypher?
The query language that reads like the question.
Read →GraphRAG
What is GraphRAG?
Grounding an LLM by traversing a knowledge graph.
Read →GraphRAG
Graph RAG vs vector RAG
When to use each — and why it's usually both.
Read →Questions
Questions we get
How does a graph cut LLM token costs?
By retrieving the connected neighbourhood instead of the whole knowledge base. At 2,000 entities, dumping everything into context costs about 202,285 tokens per query; traversing to just the relevant subgraph costs about 2,668. The gap widens as the graph grows, because retrieval stays bounded by neighbourhood size, not corpus size.
Do I have to rewrite my queries?
No. If your code talks to Neo4j, it already talks to CognoDB. CognoDB understands Cypher and speaks Bolt 5.0 through 5.4, so the official drivers for Python, JavaScript, Go, Java and .NET connect without modification — migration is usually a one-line URI change.
Can I run CognoDB myself?
CognoDB is available as a managed cloud service. You provision instances from the console or the API and we run them; there is no self-hosted distribution to install or operate.
What does the free tier include?
One c0 instance — 0.5 vCPU, 256 MB of memory and 1 GB of storage, with 200 connections. It costs nothing and needs no card. It runs on burstable shared capacity, which is why we can offer it at no charge.
How is pricing calculated?
You pay the underlying infrastructure cost, itemized. Compute is $26.04 per vCPU-month, memory $3.49 per GB-month, storage $0.113 per GiB-month, and daily backups $0.057 per GiB-month, plus a flat $1.50 network share. Billing is by the second, so a paused instance costs only its storage.
Where do instances run?
Three regions today: us-east4 in Northern Virginia, us-central1 in Iowa, and europe-west1 in Belgium. You pick the region when you create an instance.
What happens to my data if I stop paying?
Instances are soft-deleted with a final snapshot and retained for 30 days before permanent removal, so an accidental lapse is recoverable. You can export at any time.
Can my AI agents query the graph directly?
Yes. CognoDB ships an MCP server, so Claude, Cursor and any other MCP-compatible client can inspect the schema and run queries against your instance without you writing an integration layer. Agents traverse what they know — from the user, to what they prefer, to what's blocking the task — instead of re-reading transcripts.
Why not just use a vector store for agent memory?
Vector stores find what's similar; they cannot find what's connected. There's no concept of an edge, so "what depends on X?" has no answer, and provenance is a metadata blob rather than a relationship you can walk. Many stacks run both — the graph is the part that makes an agent's answers structural and auditable.
When should I use a graph database instead of a relational one?
When the relationships are the point. If your hardest queries follow connections — recommendations, fraud rings, dependency chains, identity resolution, agent memory — each hop is a join in SQL but a single step in a graph. If your queries are mostly get-by-id, sum-a-column or find-similar-text, a relational, columnar or vector store is the better fit. Our guide on when not to use a graph database walks through the trade-offs.
Does CognoDB do vector search or GraphRAG?
CognoDB is the graph and traversal layer, so it powers the graph half of a GraphRAG stack — it doesn't compute embeddings or run vector similarity. Pair it with your existing vector store: use vectors to find entry points and the CognoDB graph to expand and cite them. It does ship full-text BM25 search for keyword lookups inside the graph. See our explainer on graph RAG vs vector RAG.
What is GraphRAG, briefly?
GraphRAG is retrieval-augmented generation where the retrieval step traverses a knowledge graph rather than only fetching similar text chunks. It lets a model answer multi-hop questions and return an auditable path showing where each fact came from — which is why graph retrieval stays compact as the knowledge base grows. Full explainer: what is GraphRAG.
Put your first graph up in a minute
A free instance takes about a minute and no card. Write a couple of MERGE statements and you have a living graph, provenance included.