Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

··Feeds·Contact·Privacy·© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
slater — Low-memory graphdb with Bolt+tls support, at-rest encryption & vectors designed for local replica graph use cases. | Kitploit
Tools/GitHubGitHub/hikari-systems/slater
Authentication & AuthorizationEncryption/Decryption ToolsNetwork SecurityCloud SecurityUtilities & FrameworksDatabase Security
GitHubhikari-systems/slater

slater

Low-memory graphdb with Bolt+tls support, at-rest encryption & vectors designed for local replica graph use cases.

View Repository
1002181 month agoReviewed by Kitploit

Most Popular

View all →

Discover the most used tools by our community.

Explore all tools

Browse our collection of tools

View all tools →
Share

Slater

CI Release

Current version: v0.25.2 — all releases.

In one line: Slater serves graphs that don't fit in memory — hundreds of millions of nodes and billions of edges in low hundreds of MB of RAM — over standard Bolt, so any neo4j driver just works, with disk-native vector search sitting next to the graph, and it takes live, durable writes without giving that up. Resident memory is set by a cache budget you choose, not by the size of the graph.


Shortcuts

Why Slater existsReads and writesWhat you getFeatures
Running with DockerHow it worksThe writable layerStorage backends
MountsConfigurationACLHealth check
Worked exampleDevelopmentPerformanceLicense
Graphiti memory store📖 Full manual

Why Slater exists

A graph database stores data as things (nodes) and the relationships between them (edges), with the relationships as first-class citizens. That's what you want when your questions are about connections rather than rows — "who's within three hops of this account?", "what's the full dependency chain behind this build?", "which accounts share a device, an address, and a card?" — the queries that become a swamp of recursive joins in SQL but fall out naturally in a graph.

The most common complaint about graph databases is that they don't scale past what you can hold in RAM. Many of them (eg neo4j, Memgraph, FalkorDB, etc) keep the whole graph resident: a 40 GB graph wants 40 GB of memory — per instance. Want a replica per region, per tenant, or per pod? Multiply the bill. And past a certain size they simply won't load: eg the 90 million node / 1.5B-edge Wikidata graph needs ~64–128 GiB resident, so the in-memory engines can't open it at all.

Slater is the rebuttal. Rather than loading the graph into memory, it compiles it once, offline: slater-build turns your data into a content-addressed, immutable on-disk image, and any number of Slater servers then serve that image over Bolt (so your existing neo4j drivers just work), paging blocks in on demand and holding only a fixed cache budget resident. That is how the same 90M-node graph serves from a few hundred MB of RAM — graph size and memory bill are decoupled. A 4 GB graph and a 400 GB graph cost the same RAM to serve, so you fan out cheap, stateless read replicas and let the store, not the heap, hold the graph.

That makes it a natural fit for knowledge graphs behind RAG, recommendation and identity graphs, dependency graphs — anything large and connected you want to query cheaply and often. Disk-native vector search lives right next to the graph, so the same engine is the retrieval layer for embeddings too.

Compiled once does not mean frozen, though. That image is a base, not a final state: an opt-in write layer sits above it, so a live graph can be corrected and extended without rebuilding anything.

Reads and writes

The core is immutable; the graph is not. Turn the writable layer on (delta.enabled) and you write over Bolt — correct one property, add a node, retract an edge — and the change lands durably, with no rebuild of the image. What keeps it cheap on the read side is where the writes live.

Writes accumulate in a log-structured-merge (LSM) layer over the immutable core: a write-ahead log and an in-memory table, spilling to immutable delta segments, folded back into a fresh core by a periodic consolidation. What that buys you:

  • Reads over an unwritten graph cost exactly what they did before. An empty delta is a single predictable branch, not a merge — the read path is byte-identical whether or not the writable layer is on.
  • The read cost of a write scales with the size of the delta, not the size of the graph. Whole-graph answers — count(*), the label and relationship-type marginals — stay metadata reads even with writes outstanding: the delta keeps its own counters, so a count(*) over a 91.6M-node core with half a million pending writes still answers in tens of milliseconds without touching a single block.
  • Acknowledged means durable. A single writer drains the queue and returns SUCCESS only after the fsync that covers the write. Group your writes and they're cheap — a write-UNWIND commits one fsync per batch rather than per row.
  • Business-key writes, in either dialect. MERGE / MATCH … SET / DELETE (and CREATE / REMOVE, detach delete, relationship writes) keyed on a node's identity property — or the equivalent ISO GQL data-modifying statements (INSERT / SET / REMOVE / DELETE), which lower onto the same path. Correct, insert, upsert and retract, over nodes and edges, addressed the way your data already is.

With the layer off — the default — Slater serves the pure immutable core and refuses writes. See The writable layer for the full model.

On the name. Slater is named after the CIA agent in Archer (a great show) who insists on going by a single name — "Just… Slater" — and one of my favourite characters in it. See the character wiki page.

What you get

  • RAM set by your cache budget, not your graph size — fan out as many read replicas as you like; the graph never has to fit in memory.
  • A drop-in for the graph — speaks Bolt, so any standard neo4j driver (JS, Python, Go…) works unchanged. It's Cypher (plus a slice of ISO GQL, reads and writes); nothing new to learn.
  • Live, durable writes — an opt-in LSM layer over the immutable core: business-key MERGE / SET / DELETE over nodes and edges, group-committed and fsync-durable, folded back into a fresh core by consolidation. Reads don't pay for it.
  • Deployment by file swap — build a new content-hashed generation offline, atomically flip the current pointer, and servers pick it up. Every block is checksummed, so a half-copied image is refused rather than served.
  • Vector search built in — disk-native approximate-nearest-neighbour (cosine, L2, or dot KNN) sits right next to your graph, for when this is the retrieval layer behind a RAG pipeline, and embeddings are writable in place — no offline rebuild to add or change a vector.
  • Locked down by design — read and write grants are independent, plus optional at-rest encryption, TLS Bolt, argon2id-hashed ACLs, and a read-only container rootfs for read replicas. Configure a master key and the on-disk image is authenticated as well as encrypted — its manifest carries a keyed MAC, so an attacker with write access to the data directory but no key cannot forge a manifest the server will accept. Without a key you still get the content hash, which catches a half-copied or corrupted image — but not a deliberate one. Which configuration buys what.

Features

Download Tool