What is Grafio?​

Grafio is a lightweight, embeddable graph database that brings the power of graph data structures to JavaScript/TypeScript applications. With native Cypher query language support and pluggable storage backends, Grafio makes working with connected data simple and efficient.

Key Features​

• Native Cypher Support - Write queries in Cypher, the same language used by Neo4j
• TypeScript First - Full type safety and excellent IDE support
• Pluggable Storage - Use in-memory for speed, or plug in Redis/MongoDB for persistence
• Powerful Traversals - Built-in graph traversal and path finding algorithms
• Lightweight - Zero dependencies, tree-shakable, works in Node.js and browsers

Getting Started​

import { CypherEngine } from 'grafio';
import { InMemoryGraphFactory } from 'grafio/storage';

// Create graph via factory
const factory = new InMemoryGraphFactory();
const graph = factory.forGraph('social-network');
const cypher = new CypherEngine(graph);

// Add social network data
graph.addNode({ id: 'alice', label: 'Person', properties: { name: 'Alice', age: 30 } });
graph.addNode({ id: 'bob', label: 'Person', properties: { name: 'Bob', age: 25 } });
graph.addNode({ id: 'charlie', label: 'Person', properties: { name: 'Charlie', age: 35 } });
graph.addEdge({ from: 'alice', to: 'bob', label: 'KNOWS', properties: { since: 2020 } });
graph.addEdge({ from: 'bob', to: 'charlie', label: 'KNOWS', properties: { since: 2019 } });

// Query with Cypher
const friends = cypher.execute('MATCH (p:Person)-[:KNOWS]->(friend:Person) RETURN p.name as name, friend.name as friend');
// Returns: [{"name":"Alice","friend":"Bob"},{"name":"Bob","friend":"Charlie"}]

What's Next?​

• Redis and MongoDB storage providers
• Advanced query optimization
• Graph visualization tools
• Community contributions welcome!

Check out the documentation to get started.

Welcome to Grafio!

Test Environment​

Our benchmarks were conducted on a modern high-performance workstation:

We tested across three scales to understand Grafio's performance characteristics:

• Small: 10,000 nodes / 30,020 edges
• Medium: 50,000 nodes / 150,014 edges
• Large: 100,000 nodes / 300,142 edges

Write Performance​

Grafio's in-memory provider delivers exceptional write throughput:

Single node and edge operations achieve 140,000+ operations per second, making Grafio ideal for high-throughput data ingestion workloads.

Read Performance​

Grafio provides sub-millisecond response times for ID-based lookups:

Type and property-based queries scale linearly:

Navigation Performance​

Edge navigation operations maintain consistent throughput across all scales:

Traversal Performance​

Grafio's traversal engine excels at path finding with type filters:

Typed traversals achieve sub-millisecond performance, enabling real-time graph analytics.

Aggregation Performance​

Complex graph aggregations are handled efficiently:

Memory Efficiency​

Grafio maintains a small memory footprint while handling large graphs:

The memory-to-node ratio is approximately 2 bytes per node, demonstrating excellent efficiency for in-memory graph storage.

Performance Visualization​

Key Takeaways​

1. Write Throughput: 140,000+ ops/sec for single node/edge operations
2. ID-Based Reads: Sub-millisecond response times, 30,000+ ops/sec
3. Typed Traversals: Sub-millisecond performance enables real-time analytics
4. Memory Efficiency: ~190MB for 100K nodes with edges (~2 bytes/node)
5. Linear Scaling: Performance degrades gracefully as dataset grows

Production Recommendations​

For optimal performance in production environments:

• Use ID-based lookups for latency-critical paths
• Leverage typed traversals for graph pattern matching
• Consider indexed storage providers (Redis) for property-heavy workloads
• Batch writes when importing large datasets

Next Steps​

Want to run these benchmarks on your own hardware? Check out our performance testing guide to replicate these results and test against your specific use case.

Grafio's in-memory provider delivers the performance characteristics needed for real-time graph applications, from social network analysis to fraud detection systems.