MCP.Market

Knowledge Graph RDBMS MCP server

by cunicopia-dev·io.github.cunicopia-dev/knowledge-graph-rdbms·v0.1.9·1 stars
No reviews yet

A label property graph on SQLite/Postgres with multi-ontology routing and a gated MCP server.

A88/100grade A
Write a reviewInstall
What users say
No reviews yet
Be the first
Safety scan
A88/100

full report

Adoption
New

1 stars34 downloads/wk

Reviews

Write one

Nobody has reviewed Knowledge Graph RDBMS yet.

If you have run it, two minutes of your experience saves the next person an afternoon.

Knowledge Graph RDBMS tools (28, 6 write)

write = sends, deletes, buys or posts

Read from the package source without running it. The installed server may list more.

  • kg_descendants

    All nodes reachable from `id` by following only `edge_type` edges.

  • kg_edge_add

    Add an edge. Triples (from, type, to) are unique; repeats update properties.

  • kg_edge_removewrite action

    Remove a specific edge by (from, type, to). Idempotent. Logged + reversible.

  • kg_edges

    Edges of a node, optionally filtered by `edge_type`. `direction` is "out" (default), "in", or "both". Each result is the edge plus the node on the other end: {direction, id, from, to, type, properties, node}.

  • kg_event_revert

    Reverse an event by emitting a compensating event. The original is never deleted.

  • kg_events_tail

    The most recent events from the append-only log.

  • kg_find

    Find nodes by `kind` and/or `label`, each tagged with its source ontology ([{ontology, node}]). Give a kind, a label, or both (both = nodes of that kind that also carry that label).

  • kg_identity

    The materialized SAME_AS cluster of a node — every leaf node explicitly asserted (transitively) to be the same real-world entity, fetched live and tagged by ontology ([{ontology, node}]). Pairs with kg_link(type=SAME_AS).

  • kg_import

    Bulk-create many nodes and edges in ONE call (one gated + logged transaction).

  • kg_link

    Assert a typed relationship between nodes in two DIFFERENT ontologies (impossible as a normal edge — those can't cross files). For "same real-world entity", use type="SAME_AS" with symmetric=True (read the cluster back with kg_identity). symmetric=True also writes the reverse. Gated + logged.

  • kg_links_of

    Every cross-ontology link touching a node (both directions).

  • kg_neighborhood

    Undirected BFS from a node within `depth` hops (inclusive of self).

  • kg_node_deletewrite action

    Delete a node (cascade removes its edges/properties).

  • kg_node_get

    Fetch a node by id. One graph: returns the node, or null if absent.

  • kg_node_upsertwrite action

    Create or update a node — also the way to add labels or set properties (pass `labels=[...]` / `properties={...}`; both merge into the existing node). Properties are JSON-serializable.

  • kg_ontologies_list

    List registered ontologies: name, backend engine, extraction stance, path.

  • kg_ontology_createwrite action

    Register a new ontology (or update an existing one's metadata).

  • kg_ontology_deletewrite action

    Remove an ontology from the registry (inverse of kg_ontology_create).

  • kg_prefix_add

    Bind a CURIE prefix to an IRI base (e.g. person -> https://kg.local/person/).

  • kg_prefix_resolve

    Resolve the prefix/IRI registry. With `curie`, expand it to its full IRI ({curie, iri}); without, return every prefix -> IRI-base binding.

  • kg_rdf_export

    Serialize an ontology to RDF text (dependency-free).

  • kg_rdf_import

    Load RDF text into an ontology through the gated + logged path (replayable).

  • kg_replay

    Rebuild the graph projection from the event log.

  • kg_schema

    The observed schema — CALL THIS FIRST when you don't know what an ontology contains, before kg_find / kg_node_get. Returns the exact vocabulary so you never guess: kinds, edge types, labels, property keys per kind (+counts), and node/edge totals.

  • kg_shortest_path

    Shortest undirected path between two node ids, or None if no path.

  • kg_virtual_edge_add

    Bind an edge TYPE to a query that resolves its instances live from an external source — no rows are copied into the graph (Ontology-Based Data Access). At traversal time kg_edges runs `query`, parameterized by the node you're standing on, and synthesizes the edges; results carry `_virtual: true`.

  • kg_virtual_edge_removewrite action

    Remove a virtual-edge binding by type. The external source is untouched.

  • kg_virtual_edges_list

    List the ontology's virtual-edge bindings (edge type, source, directions, target shape, and the query). The connection string is shown by reference (`dsn_env`) or literal (`dsn`) exactly as stored.

Public scan report

scanner v0.1.9 · 2026-09-26 · same rubric, same numbers if you re-run it

no findings
  • Code scan21 source files scanned25/25
  • –Live reliabilityno gateway calls yet and no remote to proben/a
  • –Tool poisoningtools not inspected (local package is not executed); not countedn/a
  • Auth qualitylocal package, no credentials required12/15
  • Maintenancelast push 48 days ago12/15
  • Maintainer identityregistry namespace matches repository owner; GitHub account older than a year8/10
Overall 88/100. Components that don't apply are left out of the denominator. Any critical finding is an F.RubricAppeal a findingJSON

How Knowledge Graph RDBMS compares

Against every graded Databases MCP server, from our own scans and uptime checks. Updated after each scan run.

Safety score
88/100
higher than 75% of 802 Databases servers
Tools
28
the typical Databases server has 8
Tools that change things
21%
typical: 10%. Fewer write tools means less an agent can break
GitHub stars
1
more than 45% of 602 Databases servers
Downloads a week
34
more than 20% of 328 Databases servers with a package

What its tools let an agent do: 22 read · 6 change

Install Knowledge Graph RDBMS in Claude Code, Cursor or VS Code

claude mcp add knowledge-graph-rdbms -- uvx knowledge-graph-rdbms
Add to Cursor

What the publisher says

From the Knowledge Graph RDBMS repository's README, as published. We do not edit it. Read it on GitHub

knowledge-graph-rdbms

<!-- mcp-name: io.github.cunicopia-dev/knowledge-graph-rdbms -->

An embedded knowledge graph you own completely — in one SQLite file.

SQLite-native · zero-dependency core · MCP-ready · event-sourced · reversible.

Model anything as entities and relationships — agent memory, app ontologies, declarative datasets, "SQLite but my data is a graph" — without running Neo4j, RDF, Docker, or a separate graph service. No Cypher, no JVM, no server: five tables and one file you can copy, inspect, and version.

pip install "knowledge-graph-rdbms[mcp]"

# write a fact — auto-creates the graph in one SQLite file
kg node add person:ada --kind Person --name "Ada Lovelace"

# every write is logged; tail the log and roll any event back by id
kg events -n 5
kg revert <event_id>

# rebuild the graph as of any past moment — literal time travel
kg replay --upto 2026-01-01T00:00:00

# expose the whole graph to an AI agent over MCP
kg serve
Agent / CLI / Python
            │
     gated + logged writes
            │
   SQLite label property graph
            │
    replay · revert · time-travel

Python 3.10+ · MIT · zero-dependency core · library + CLI + MCP

The world isn't rows in a table — it's things, the kinds of things they are, and how they relate. A label property graph captures exactly that, and not much more: nodes (entities), typed edges (relationships), labels (sets), and JSON properties (everything else). There's no schema to design up front; meaning accretes as facts, and the shape stays as flexible as the domain it describes.

That flexibility is what makes it a natural substrate for AI agents. Hand an agent an MCP connection to this graph and it can do what agents are uniquely good at: read a domain, model what it learns, connect ideas, and reason over structure instead of prose. Every write is gated, attributed, and appended to an event log — so an agent can reshape the graph freely while you keep the receipts: audit it, replay it to any point in time, or roll a change back with one command. A memory that records why, not just what — in one embeddable file that travels wherever the agent runs: a laptop, a CI job, a serverless function, a Pi.

Small enough to hold in your head. Flexible enough to model anything.

Contents

Shortened. The full README is on GitHub.

Nothing above is checked by us. What we check is on the safety report.

Knowledge Graph RDBMS: common questions

Is Knowledge Graph RDBMS MCP server safe?
Yes, by our scan: it is graded A (88/100). Read the Knowledge Graph RDBMS safety report
How do I install Knowledge Graph RDBMS?
It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.
Does Knowledge Graph RDBMS need an API key?
No secret keys are declared. It reads 2 settings from the environment.
Is Knowledge Graph RDBMS maintained?
The last commit was 87 days ago (2026-08-09). The latest release is v0.1.9.
What can I use instead of Knowledge Graph RDBMS?
Servers from other publishers that do the same job: AlphaFold Sovereign MCP server, Local Memory MCP server and ArcadeDB MCP Server.
How does Knowledge Graph RDBMS compare with other Databases MCP servers?
safety score 88/100 (higher than 75% of 802 Databases servers); tools 28 (the typical Databases server has 8); tools that change things 21% (typical: 10%. Fewer write tools means less an agent can break). Full comparison.

Alternatives to Knowledge Graph RDBMS

Same job from other publishers: the closest match first, then the best rated.

  • AlphaFold Sovereign MCP
    MCP server for AlphaFold and 8 other biomedical data sources with a local SQLite knowledge graph
    A
  • Local Memory
    Persistent local AI memory. SQLite + FTS5 + vector search, knowledge graph. No cloud, no API keys.
    A
  • ArcadeDB MCP Server
    Built-in MCP server for ArcadeDB multi-model database (graph, document, vector, time-series)
    B
  • Quarry
    Safety-railed database access: Postgres, MySQL, SQLite, Redis. Read-only by default.
    A
  • sqlite-graph-memory
    Recall over your markdown notes: vector search plus your [[wikilinks]] as a graph, in SQLite.
    A

More from cunicopia-dev →