KGLite — Knowledge graph for Python, built for LLM agents

KGLite is an embedded, Cypher-queryable knowledge graph for Python and Rust, built so the same graph can serve an application, an analyst, or an LLM agent. The Python wheel has no required Python runtime dependencies; the graph engine runs in-process without an external database service. Every crate in the workspace ships under MIT — if you are embedding a graph engine in something you distribute, see Licensing and embedded distribution. The distribution also includes a CLI and MCP server, prompt-shaped describe() introspection, and structural validators that compose with Cypher.

Start here

Install → build one graph → query it:

pip install kglite

import kglite

graph = kglite.from_records({"nodes": [{
    "type": "Person", "id_field": "id", "title_field": "name",
    "records": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}],
}]})
print(graph.cypher("MATCH (p:Person) RETURN p.name ORDER BY p.name").to_dicts())

Choose the path that matches what you are doing:

• Getting Started — install, first graph, storage choices
• Python API · Cypher · Fluent API
• MCP and agents · Rust · Operators
• 0.13 → 0.14 migration · all documentation

Upgrading from 0.13? Convert pre-0.14 .kgl, .kgle, disk, and WAL artifacts with kglite 0.13.4 before installing the current Postcard-only release; the migration guide above has the exact paths.

For DataFrame loading, install the optional pandas integration with pip install "kglite[pandas]"; the complete walkthrough is in Quick Start.

kglite is a pure-Rust knowledge graph engine (crates/kglite) packaged for Python via pip install kglite. The interactive shell, Bolt-server, and MCP-server binaries are sibling Rust crates wrapping the same engine. If you want kglite as a Rust library — without the Python wheel in your build — see Use from Rust below.

Interactive shell. pip install kglite also gives you the kglite command — a sqlite3-style REPL: kglite app.kgl opens a Cypher prompt with .import, .dump, .schema, multi-line input, and tab-completion. For a standalone CLI-only install, use pip install kglite-cli or cargo install kglite-cli.

Ecosystem

kglite is the engine. Two companion projects build graphs it serves — each released and versioned on its own cadence:

• kglite — the embedded Cypher knowledge-graph engine (this project): graph + Cypher + fluent API + bundled MCP server.
• codingest — parses codebases into code graphs (14 languages, web-framework route detection). Build with it, query the .kgl here. Requires kglite ≥ 0.14.
• kglite-datasets — fetch-build-cache loaders for public registries (SEC EDGAR, Wikidata, Sodir).
• sonagram — turns a local music library into a kglite knowledge graph via sonara audio analysis (tempo, energy, mood, key); AI agents curate playlists over it through a simple bundled skill and CLI (pip install sonagram).

Upgrading from 0.13? The code-graph builder and dataset loaders moved out of the wheel, and pre-0.14 bincode persistence needs a 0.13.4 conversion — see the 0.13 → 0.14 migration guide. Pin back anytime with pip install "kglite<0.14".

Use cases

The same agent-facing surface works whether the graph holds legal precedents, a Wikidata slice, a SQL warehouse, a RAG corpus, or a parsed codebase.

• 🏛️ Domain knowledge for agents. Legal precedents + citations, regulatory rules, medical ontologies, manufacturing BOMs, scientific catalogues — anything with structure becomes a queryable graph an MCP-capable agent can reason over. See the legal-graph example for a Norwegian-Supreme-Court walk-through (laws + decisions + citation edges + judge metadata).
• 📊 Business data → queryable graph. Any tabular source — SQL, CSV, Parquet, REST API responses, pandas DataFrames — goes straight in via add_nodes(df, ...) and add_connections(df, ...). Layer a graph on top of your warehouse and the agent reasons over the relationships without you writing a server. → Data Loading guide.
• 🌐 Public datasets. Pre-packaged loaders for SEC EDGAR, Wikidata, and Sodir live in the companion kglite-datasets project — they handle the fetch + build + cache cycle and return a queryable KnowledgeGraph. kglite's mapped and disk storage then query graphs that don't fit in RAM — a billion-edge Wikidata graph on a 16 GB laptop. → See Public datasets below.
• 📚 RAG with structure. Documents, chunks, entities, and the edges between them in one graph. Combine text_score() vector similarity with Cypher traversal — "find court cases semantically similar to my fact pattern, then walk one hop to related precedents" — hybrid retrieval in one query, no second vector DB. Scale to large corpora with an opt-in HNSW index (build_vector_index()). → Semantic Search guide.
• 📂 Codebase analysis. The codingest builder parses 14 languages into Function / Class / Module / Route nodes with web-framework route detection (Flask, FastAPI, Django). Build from any git revision, or merge several into one multi-revision graph for structural diffs (multi-rev builds). kglite serves and queries those graphs. The builder and the code → Claude Desktop workflow live in the codingest project.
• 🤝 A shared graph as an agent contract. One .kgl can be the two-way contract between collaborating agents (e.g. a research agent that batch-rebuilds specs and coding agents that plan and mutate status live). The primitives that make this safe are first-class: ownership layers (define_schema(layer='managed'|'runtime') + add_nodes(managed_reload=True) so a rebuild provably can't clobber agent-owned nodes), role-scoped writes (cypher(..., write_scope=[...]) rejects out-of-scope CREATE/SET), a verbatim instructions slot at the top of describe() (set_instructions(text)), native list properties, JSON-native ingestion (from_records(spec)), and a dependency frontier (CALL ready_set(...)) to find the next actionable work. Keep the graph general — these are small, opt-in building blocks, not a baked-in workflow.
• 🧠 Markdown knowledge bases & agent memory. kglite.okf.build(dir) ingests an Open Knowledge Format bundle — or a Claude memory dir, skills folder, or Obsidian vault — into a graph: frontmatter → node properties, markdown links → typed edges. Then cluster it (CALL leiden), find orphaned or stale notes, and surface dangling references — the query engine OKF itself doesn't ship. → OKF guide.

Why Cypher?

Questions over connected data — which insiders sold this stock, who sits on two boards, what cites this case — are pattern matches. In SQL they become multi-table joins; in Cypher the pattern is the query:

-- Insider sells, most recent first
MATCH (t:InsiderTransaction {direction: 'sale'})-[:BY_INSIDER]->(p:Person)
MATCH (t)-[:IN_COMPANY]->(c:Company)
RETURN p.title, c.title, t.shares, t.price_per_share
ORDER BY t.transaction_date DESC LIMIT 10

Cypher pays off most when the data has real structure and your questions traverse it.

How it compares

Pick KGLite when you want one embedded package that combines Python and pure-Rust Cypher APIs with a bundled MCP binary, prompt-shaped describe(), and agent-contract primitives: role-scoped writes (write_scope), ownership layers, set_instructions, and CALL ready_set(...) — with companion projects (codingest, kglite-datasets) that build code and public-registry graphs it serves. Pick LadybugDB when columnar analytical scans and its broader language ecosystem are the priority; it also provides Rust bindings and a separately installed MCP server. Pick NetworkX when you need its enormous graph-algorithm library and your data fits in RAM. Pick rustworkx when you want a Rust-backed Python graph API with no query language. Pick Neo4j Embedded when you've standardised on server-mode Cypher and want the in-process driver for tests.

📊 Benchmarks → — wall-to-wall time per topic (load, filter/aggregate, traversal, pathfinding, algorithms, mutations) against other embedded graph engines, NetworkX, rustworkx, igraph, and DuckDB on one shared synthetic graph. Reproduce with python benchmarks/benchmark.py.

Licensing and embedded distribution

If the graph engine ships inside something you distribute, the licence is a design constraint rather than a line item.

kglite is MIT-licensed throughout — every crate in the workspace ships under MIT. There is no separate commercial tier, no distinction between development and production use, and no copyleft obligation attached to shipping it: if you can use kglite, you can distribute it inside your own product.

One honest qualification, because it is a statement about the default build: the optional fastembed embedding backend is itself Apache-2.0 and is off by default in every crate that can enable it, so neither the published wheel nor the default MCP-server binary contains it. A build that opts into --features fastembed pulls one transitive MPL-2.0 crate (option-ext, four dependencies down); MPL-2.0 is file-level weak copyleft and kglite does not modify it. The reviewed dependency-licence policy is documented in dependency licences.

Primary store, or derived index?

Two shapes, both supported, with different guarantees. Knowing which one you are building saves a lot of argument later.

• Derived index — the authoritative copy lives elsewhere (a warehouse, an API, a directory, a repo) and the graph is a rebuildable projection you query. This is what most kglite deployments are, and it is the cheapest correct answer. → Derived index guide.
• Primary store — the graph is the authoritative copy. open() is crash-safe by default for the in-memory and mapped backends (disk checkpoints on save() instead), statements are atomic, readers get snapshot isolation, UNIQUE / NOT NULL / node-key constraints are enforced on every write path including the bulk loaders, and for in-memory graphs the cost of a write scales with the size of the change rather than the size of the graph. One process owns the writes; the scope statement lists the limits rather than softening them. → Primary store: scope and limits.

Quick Start

# Python (the headline distribution path)
pip install kglite

# Optional extras
pip install 'kglite[pandas]'   # DataFrame loading used in the walkthrough below
pip install fastembed            # (or sentence-transformers) embedding models for text_score() — bring your own
pip install 'kglite[neo4j]'      # Neo4j Python driver for Bolt-server tests

import pandas as pd
import kglite

# Three storage modes — pick by graph size:
#   default (in-memory)   — small/medium graphs, fastest queries
#   storage="mapped"      — mmap columns, RAM-friendly as you grow
#   storage="disk", path=…  — 100M+ nodes, Wikidata-scale, loaded lazily
graph = kglite.KnowledgeGraph()

# Bulk-load nodes from a DataFrame.
people = pd.DataFrame({
    "id":   ["alice", "bob", "eve"],
    "name": ["Alice", "Bob", "Eve"],
    "age":  [28, 35, 41],
    "city": ["Oslo", "Bergen", "Trondheim"],
})
graph.add_nodes(people, node_type="Person", unique_id_field="id", node_title_field="name")

# Bulk-load relationships the same way.
knows = pd.DataFrame({"src": ["alice", "bob"], "tgt": ["bob", "eve"]})
graph.add_connections(knows, connection_type="KNOWS",
                      source_type="Person", source_id_field="src",
                      target_type="Person", target_id_field="tgt")

# Query — returns a ResultView; eligible projections stay lazy until accessed.
for row in graph.cypher("""
    MATCH (p:Person) WHERE p.age > 30
    RETURN p.name AS name, p.city AS city
    ORDER BY p.age DESC
"""):
    print(row['name'], row['city'])

# Or get a pandas DataFrame directly.
df = graph.cypher("MATCH (p:Person) RETURN p.name, p.age ORDER BY p.age", to_df=True)

# Persist to disk and reload. save() is atomic + fsync by default (crash-safe —
# no torn file); load() raises a typed kglite.FileFormatError on a corrupt file.
graph.save("my_graph.kgl")
loaded = kglite.load("my_graph.kgl")

# Or serialize to/from bytes (no filesystem path):
blob = graph.to_bytes(); loaded = kglite.from_bytes(blob)

# Share read-only across threads with an immutable, lock-free snapshot:
snapshot = graph.freeze()        # concurrent snapshot.cypher(...) from many threads

# No data yet? Generate a realistic demo graph in one line (bundled, no extra deps):
demo = kglite.graphgen("medium")               # ~25k nodes, ready to query
# kglite.graphgen("huge", out="/tmp/g")        # stream millions of nodes to CSV, bounded memory

→ Getting Started guide · Cypher reference · API reference.

Prefer a runnable file? examples/csv_to_graph.py loads real CSVs end to end.

Serve it to an agent

Use the KGLite MCP server when you want a graph kept warm across many calls, with typed graph-query and lifecycle tools. Code-graph construction, repository cloning, and code-watch workflows belong to codingest-mcp, which embeds the same KGLite graph-serving surface.

One command — any current .kgl becomes an MCP server

kglite-mcp-server --graph path/to/graph.kgl

The server exposes cypher_query, graph_overview, schema introspection, and structural validators over MCP stdio. When a valid source_root is configured, it also exposes source-file read/search tools. Drop it into Claude Desktop, Cursor, or another MCP-capable client and any KGLite graph is queryable.

When you register it, point command at the absolute path to the binary (/abs/path/to/venv/bin/kglite-mcp-server), not a bare name — a bare command can silently launch an older PATH-shadowing install. Then confirm it with kglite-mcp-server --selftest --graph path/to/graph.kgl, which drives a real handshake and prints green/red per capability.

Two ready-made code-intelligence recipes ship in examples/ — both build code graphs, so run them under codingest-mcp (it embeds this same tool surface and injects the builder):

• Clone-and-explore GitHub repos — open_source_workspace_mcp.yaml: the agent calls repo_management('org/repo') to clone and build a code graph on demand.
• Review a local directory — local_code_review_mcp.yaml: point it at a checked-out tree, set_root_dir(path) to swap roots, watch-mode auto-rebuild.

Customise with a YAML manifest

Drop <basename>_mcp.yaml next to the graph (e.g. wikidata_mcp.yaml beside wikidata.kgl) and the server auto-loads it at boot.

name: Wikidata Explorer
source_root: /path/to/related/source        # exposes read/grep/list
skills: true                                # load bundled + project tool guidance
trust:
  allow_embedder: true
extensions:
  embedder: { library: fastembed, model: BAAI/bge-small-en-v1.5 }  # enables text_score()
  csv_http_server: true                              # bulk CSV exports
tools:                                               # inline parameterised Cypher
  - name: who_invented
    cypher: |
      MATCH (i:Q5)-[:P61]->(t {label:$thing})
      RETURN i.label LIMIT 5

No fork required for most customisation. → MCP server guide.

Teach the MCP agent with bundled tool skills

With skills: true, Markdown skill files (<basename>.skills/*.md) provide methodology for each tool. The agent reads cypher_query.md to learn your schema conventions, read_code_source.md to know when to drill into source vs. query the graph, etc. Three layers compose: kglite-bundled defaults + your project's .skills/ overrides + operator-declared domain packs. Skills with applies_when: predicates only activate when the graph contains the relevant node types — so a non-code graph never sees read_code_source methodology.

Net effect: the agent comes pre-loaded with how to use your graph, rather than discovering it through trial-and-error. → AI Agents guide.

Public datasets

Pre-packaged loaders that turn well-known public sources into queryable graphs — SEC EDGAR filings (insider transactions, institutional holdings, board composition, XBRL financials), Wikidata (the full latest-truthy RDF dump, parallel-decoded and built into a billion-edge graph), and Sodir (Norwegian Offshore Directorate petroleum data) — live in the companion kglite-datasets project. Install it separately with pip install kglite-datasets; its Python package supplies the dataset-specific loaders while KGLite supplies the graph:

import kglite_datasets  # choose a loader from the companion documentation

Each loader handles the fetch + build + cache cycle and returns a KnowledgeGraph you can cypher() against; kglite serves and queries the graphs they produce. The core graph engine does not require network access; fetching public data is an explicit companion-project operation.

Recipes

Short patterns for the most-common shapes. Each is self-contained.

Hybrid semantic + structural retrieval

Combine vector similarity (text_score()) with Cypher pattern matching in one query:

graph.cypher("""
    MATCH (c:Chunk)-[:IN_DOC]->(d:Document)
    RETURN c.text, d.title,
           text_score(c.embedding, $query_vec) AS score
    ORDER BY score DESC LIMIT 5
""", params={"query_vec": query_embedding})

Vector embeddings via a bring-your-own embedder — pip install fastembed (or sentence-transformers) and pass it to g.set_embedder(...). → Semantic Search guide.

Structural validators — surface data-integrity gaps

Fourteen built-in CALL procedures find the gaps that aren't visible from normal queries: orphan nodes, missing-required-edge violations, two-step cycles, duplicate titles, parallel edges, cardinality violations, more. They compose with the rest of Cypher.

# Wellbores in our sodir graph that lack a production licence
graph.cypher("""
    CALL missing_required_edge({type: 'Wellbore', edge: 'IN_LICENCE'}) YIELD node
    RETURN node.id, node.title
""")

missing_required_edge and missing_inbound_edge validate the (type, edge) direction against the graph's actual schema and refuse to execute when misused. → Full procedure list in the Cypher reference.

Graph algorithms

Shortest path (BFS or Dijkstra), centrality, community detection, clustering — all in Cypher:

graph.cypher("""
    MATCH path = shortestPath((a:User {name:'Alice'})-[*]-(b:User {name:'Eve'}))
    RETURN path
""")

→ Graph algorithms guide · Traversal patterns · Recipes index.

Use from Rust

The same engine is available as a pure-Rust crate — embed it in a Rust binary without the Python wheel in your build:

# Cargo.toml
[dependencies]
kglite = "0.14"

use kglite::api::{io::load_file, session, Value};
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let graph = load_file("my_graph.kgl")?;     // same .kgl as Python writes
    let params = HashMap::new();
    let opts = session::ExecuteOptions::eager(&params);
    let outcome = session::execute_read(
        &graph,
        "MATCH (p:Person) RETURN p.name LIMIT 5",
        &opts,
    )?;
    for row in &outcome.result.rows {
        if let Some(Value::String(name)) = row.first() {
            println!("{}", name);
        }
    }
    Ok(())
}

Zero PyO3 in the dependency tree: cargo tree -p your-crate | rg pyo3 → empty.

• Rust quickstart — load + query + transaction examples.
• Embedding guide — workspace layout, the kglite::api::* surface, cgo / napi / JNI sketches.
• Session abstraction — binding-implementer reference for the canonical Cypher pipeline.
• API reference (docs.rs) — per-symbol Rust API docs.

The Bolt server (crates/kglite-bolt-server) and the Rust MCP server (crates/kglite-mcp-server) are standalone binaries built on the same engine — see the Operators guide for deployment.

For non-Rust language bindings (Go via cgo, JavaScript via napi, JVM via JNI, .NET via P/Invoke), the crates/kglite-c crate exposes the engine through a stable C ABI covering lifecycle, sessions, Cypher, results, persistence, and embedders, plus a cbindgen-generated kglite.h. See docs/rust/c-abi.md for the design and docs/rust/implementing-a-binding.md for cgo / napi / JNI worked examples.

Examples

The examples/ directory has runnable, self-contained artifacts:

• open_source_workspace_mcp.yaml — annotated workspace-mode manifest for the github-clone-tracker pattern. Walked through in the workspace manifest example.
• csv_to_graph.py — minimal pd.read_csv → add_nodes / add_connections walkthrough on a tiny org chart, with a few Cypher queries. The fastest way in.
• incremental_update.py — merge a second data snapshot into an existing graph with add_nodes(conflict_handling='update').
• legal_graph.py — end-to-end add_nodes / add_connections from pandas DataFrames, covering laws, regulations, court decisions with citation edges.
• spatial_graph.py — declarative CSV→graph loading via a JSON blueprint; lat/lon coordinates and pipeline-path traversal queries.
• crates/kglite-mcp-server/ — Rust-native single-binary MCP server (built on rmcp + the mcp-methods framework). Reach for it when the manifest doesn't express what you need; the binary is the reference for layering domain-specific tools on top of the generic surface.

Benchmarks

Reproducible, versioned comparisons live in BENCHMARKS.md. Run the public harness with python benchmarks/benchmark.py; maintainer-only storage and release-regression probes live under tests/benchmarks/.

Key Features

Quick reference. Each links into the appropriate guide.

Documentation

Full docs at kglite.readthedocs.io — five tracks by audience.

Python track — pip install kglite

• Getting Started — installation, first graph, core concepts
• Cypher Guide — MATCH, MERGE, mutations, parameters, validators
• Data Loading — DataFrames in, DataFrames out
• Graph algorithms — shortest path, PageRank, community detection
• Semantic Search — embeddings, vector search, hybrid retrieval
• Derived index — rebuildable graph over a system of record you don't own
• Primary store — scope and limits when the graph is the authoritative copy
• OKF ingestion — okf.build, markdown knowledge bases & agent memory
• MCP server config — manifests, skills, extensions
• Spatial · Timeseries · Blueprints · Import/Export · Traversal & hierarchy · AI Agents
• Recipes index — copy-paste patterns for common shapes

Rust track — cargo add kglite

• Rust quickstart — load, query, transactions
• Embedding kglite — surface tour, language-binding sketches
• Session abstraction — pipeline + CoW transactions
• API manifest + per-symbol docs.rs

Operators — running the protocol servers

• Bolt server — Neo4j wire compat for cluster-aware drivers

Reference — cross-binding

• Cypher reference — the supported Cypher subset
• Fluent API reference — programmatic graph construction
• Python API (auto) — auto-generated from stubs

Concepts — architecture + contributor docs

• Architecture · Design decisions · Cypher conformance · Concurrency

Requirements

CPython 3.10+ | macOS (arm64/x86_64), Linux (glibc/musl; x86_64 and best-effort aarch64), Windows (x86_64). The base wheel has no Python runtime dependencies; integrations install their named extras. See the artifact support policy for the tested/build-only tiers, libc floors, PyPy status, and source-build fallback.

Stability

KGLite is beta software and remains pre-1.0. Patch releases preserve public source APIs; a 0.x minor release may make an intentional breaking source-API change when it is documented with a migration path. Saved graph files have a separate format lifecycle: a release either reads an older format or refuses it with an explicit rebuild/migration error. See the current 0.13 → 0.14 migration guide and CHANGELOG.md. Storage parity and differential Cypher oracles run on every change.

License

MIT — see LICENSE for details. Every crate in the workspace ships under MIT; Licensing and embedded distribution covers what that means when kglite ships inside a product you distribute.