knowledge-graph-rdbms 0.1.0__tar.gz → 0.1.2__tar.gz

knowledge_graph_rdbms-0.1.2/.github/workflows/ci.yml

@@ -0,0 +1,46 @@
+name: CI
+
+# Runs the test suite on every push to master and every pull request.
+# Make the `ci` job below a required status check in branch protection to
+# gate merges on a green suite.
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: pytest (py${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv venv --python ${{ matrix.python-version }}
+      - run: uv pip install -e ".[dev]"
+      - run: uv run pytest -q
+
+  # Single stable check to require in branch protection — passes only if every
+  # matrix leg above passed (so you don't have to list each Python version).
+  ci:
+    name: ci
+    needs: test
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Verify all test jobs passed
+        run: |
+          if [ "${{ needs.test.result }}" != "success" ]; then
+            echo "test matrix failed: ${{ needs.test.result }}"
+            exit 1
+          fi
+          echo "all test jobs passed"

knowledge_graph_rdbms-0.1.2/.github/workflows/publish.yml

@@ -0,0 +1,45 @@
+name: Publish to PyPI
+
+# Publishes on a version tag (e.g. `git tag v0.1.1 && git push --tags`).
+# Auth is PyPI Trusted Publishing (OIDC) — no token stored anywhere.
+# One-time setup at https://pypi.org/manage/account/publishing/ :
+#   PyPI project name: knowledge-graph-rdbms
+#   Owner:             cunicopia-dev
+#   Repository:        knowledge-graph-rdbms
+#   Workflow name:     publish.yml
+#   Environment:       pypi
+#
+# This workflow uses no event-provided input in run: steps (no injection surface).
+
+on:
+  push:
+    tags: ["v*.*.*"]
+  workflow_dispatch: {}
+
+jobs:
+  build:
+    name: Build sdist + wheel
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+      - run: uv build
+      - run: uvx twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish (Trusted Publishing)
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write          # mint the short-lived OIDC token PyPI verifies
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

{knowledge_graph_rdbms-0.1.0 → knowledge_graph_rdbms-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: knowledge-graph-rdbms
-Version: 0.1.0
+Version: 0.1.2
 Summary: A label property graph on an RDBMS (SQLite): nodes, typed edges, an append-only event log, and an optional MCP server.
 Project-URL: Homepage, https://github.com/cunicopia-dev/knowledge-graph-rdbms
 Project-URL: Repository, https://github.com/cunicopia-dev/knowledge-graph-rdbms
@@ -20,10 +20,13 @@ Provides-Extra: dev
 Requires-Dist: mcp>=1.0; extra == 'dev'
 Requires-Dist: psycopg[binary]>=3.1; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: rdflib>=7.0; extra == 'dev'
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.0; extra == 'mcp'
 Provides-Extra: postgres
 Requires-Dist: psycopg[binary]>=3.1; extra == 'postgres'
+Provides-Extra: rdf
+Requires-Dist: rdflib>=7.0; extra == 'rdf'
 Description-Content-Type: text/markdown
 
 # knowledge-graph-rdbms
@@ -31,7 +34,7 @@ Description-Content-Type: text/markdown
 ![Python](https://img.shields.io/badge/python-3.10%2B-3776AB?logo=python&logoColor=white)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green)
 ![core dependencies: 0](https://img.shields.io/badge/core_dependencies-0-success)
-![tests: 62 passing](https://img.shields.io/badge/tests-62_passing-brightgreen)
+![tests: 79 passing](https://img.shields.io/badge/tests-79_passing-brightgreen)
 ![storage: SQLite](https://img.shields.io/badge/storage-SQLite-003B57?logo=sqlite&logoColor=white)
 ![MCP](https://img.shields.io/badge/MCP-ready-FF6F00)
 
@@ -79,6 +82,7 @@ Small enough to hold in your head. Flexible enough to model anything.
 - [Install](#install)
 - [Quickstart](#quickstart)
 - [Performance](#performance)
+- [RDF interop: export, SPARQL, RDF-star](#rdf-interop-export-sparql-rdf-star)
 - [Command reference](#command-reference)
 - [Project layout](#project-layout)
 - [Development](#development)
@@ -570,7 +574,8 @@ It exposes `kg_`-prefixed tools for reads (`kg_node_get`, `kg_nodes_by_kind`,
 `kg_neighborhood`, `kg_shortest_path`, `kg_descendants`, …), gated writes
 (`kg_node_upsert`, `kg_edge_add`, `kg_node_delete`, …), bulk composition
 (`kg_import` — a whole `{nodes, edges}` batch in one call, so an agent populates
-an ontology in a single tool call instead of dozens), and the event log
+an ontology in a single tool call instead of dozens), RDF interop
+(`kg_rdf_export`, `kg_rdf_import` — see below), and the event log
 (`kg_events_tail`, `kg_event_revert`, `kg_replay`). Every write passes through
 the invariants + policy gate and is recorded — same engine, same file as the
 CLI. Every tool also takes an optional `ontology` name (omit for the default),
@@ -596,7 +601,7 @@ that data by `bench/charts.py`. Run both on your own machine in one command.
 
 ### Writes — the batching lever
 
-![Write throughput — batch the commit, ~10× faster](assets/write_throughput.png)
+![Write throughput — batch the commit, ~10× faster](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/write_throughput.png)
 
 Each single write commits on its own for durability. Wrapping a bulk load in
 `batch()` / `add_nodes` / `add_edges` collapses those per-call commits into one
@@ -607,7 +612,7 @@ thousands per second.
 
 ### Reads — fast, with an honest tail
 
-![Read latency — p50 marker, whisker to p99, log scale](assets/read_latency.png)
+![Read latency — p50 marker, whisker to p99, log scale](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/read_latency.png)
 
 Point lookups land in single-digit microseconds, and multi-node reads hydrate
 the whole result set in a constant number of queries (no N+1 fan-out). The chart
@@ -621,7 +626,7 @@ SQLite engine runs under CPython, Node, and Bun, so the gap between them is pure
 binding overhead — under 2×, and it doesn't even favor one runtime across
 operations.
 
-![Same SQLite across CPython, Node, and Bun](assets/runtimes.png)
+![Same SQLite across CPython, Node, and Bun](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/runtimes.png)
 
 The lever that actually moved the needle was transaction batching (~10×, above),
 not the language. Reproduce it with `python bench/runtimes/compare.py`.
@@ -631,7 +636,7 @@ not the language. Reproduce it with `python bench/runtimes/compare.py`.
 We measured it against Neo4j — same graph, same queries, identical methodology
 (full harness and reproduction in [`bench/neo4j/`](bench/neo4j/README.md)):
 
-![Where the crossover is — kgrdbms vs Neo4j](assets/crossover.png)
+![Where the crossover is — kgrdbms vs Neo4j](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/crossover.png)
 
 Queries compile to SQL over B-tree indexes, so each traversal hop is an index
 lookup — wonderfully cheap for point reads and shallow traversals. An in-process
@@ -672,6 +677,67 @@ ontology to it while the hot, shallow ones stay embedded.
 
 ---
 
+## RDF interop: export, SPARQL, RDF-star
+
+The store stays a label property graph. RDF is a **boundary** format here, not a
+storage model — there is no triplestore, no OWL, no embedded SPARQL engine. The
+project adopts exactly one RDF idea, because it is the only one expensive to
+retrofit: **stable identity** (CURIE node ids). This is where a CURIE finally
+expands into a real IRI.
+
+```bash
+kg rdf export                         # Turtle, to stdout (RDF-star edges)
+kg rdf export --format ntriples --out graph.nt
+kg rdf import graph.nt                 # back in — gated, logged, replayable
+```
+
+Export is **dependency-free**. Node ids round-trip as CURIEs, because the prefix
+binding makes the IRI collapse back to exactly what you stored:
+
+```turtle
+@prefix person: <https://kg.local/person/> .
+@prefix kg:     <https://kg.local/vocab#> .
+
+person:ada a kg:Person ;
+    kg:name "Ada Lovelace" ;
+    prop:born "1815"^^xsd:integer ;
+    rel:influences person:grace .
+
+<< person:ada rel:influences person:grace >> prop:since "2020"^^xsd:integer .
+```
+
+That last line is the interesting one. A plain triple has nowhere to hang an
+**edge's** properties; `--edge-strategy` decides how they cross:
+
+| strategy           | edge `{since: 2020}` becomes                          | when to use                            |
+| ------------------ | ----------------------------------------------------- | -------------------------------------- |
+| `rdf-star` (default) | `<< :ada :influences :grace >> :since 2020`         | star-aware stores (Stardog, Jena 4.3+, Oxigraph) |
+| `reification`      | an `rdf:Statement` node carrying s/p/o + each property | rdflib and any RDF 1.1 tool            |
+| `lossy`            | the bare triple; properties dropped (count reported)  | you only want topology                 |
+
+**SPARQL?** Yes — against the export, in any store. You don't embed a query
+engine (that would betray the zero-dependency, no-SPARQL design); you emit a
+graph a real engine can query:
+
+```python
+import rdflib
+from kgrdbms import rdf
+
+# rdflib is RDF 1.1 — no star — so emit reification for it:
+ttl = rdf.export(graph, "turtle", rdf.IriContext(edge_strategy="reification"))
+store = rdflib.Graph(); store.parse(data=ttl, format="turtle")
+store.query("SELECT ?s ?o WHERE { ?s <https://kg.local/rel/influences> ?o }")
+```
+
+For SPARQL-**star** over the `rdf-star` export, hand the Turtle to a star-native
+store (Stardog, Jena, Oxigraph, GraphDB). Turtle/foreign-RDF *import* needs the
+optional extra (`pip install "knowledge-graph-rdbms[rdf]"`, which pulls
+`rdflib`); N-Triples import and **all** export stay dependency-free. Imported RDF
+rides the same gated, logged path as every other write, so it is audited and
+replayable.
+
+---
+
 ## Command reference
 
 | Command                         | What it does                                  |
@@ -695,6 +761,8 @@ ontology to it while the hot, shallow ones stay embedded.
 | `kg revert EVENT_ID`            | undo an event (compensating event)            |
 | `kg replay [--upto TS]`         | rebuild the projection from the log           |
 | `kg import FILE`                | bulk `{nodes, edges}` import (gated + logged) |
+| `kg rdf export [--format F]`    | serialize to Turtle/N-Triples (RDF-star)      |
+| `kg rdf import FILE`            | load RDF back in (gated + logged)             |
 | `kg ontology list`              | list registered ontologies (the registry)     |
 | `kg ontology create NAME …`     | register an ontology (`--backend`, `--stance`) |
 | `kg serve [--transport T]`      | run the MCP server                            |
@@ -720,6 +788,7 @@ kgrdbms/
 │   ├── sqlite.py   #   live engine (adapter over Graph)
 │   ├── postgres.py #   live engine (psycopg; jsonb + recursive CTEs); [postgres] extra
 │   └── neo4j.py    #   stub (deep-traversal escalation)
+├── rdf.py          # RDF boundary: Turtle/N-Triples export + import (RDF-star); rdflib only for [rdf] import
 ├── cli.py          # the `kg` command (stdlib argparse)
 └── mcp_server.py   # the MCP server (optional [mcp] extra)
 ```

{knowledge_graph_rdbms-0.1.0 → knowledge_graph_rdbms-0.1.2}/README.md

@@ -3,7 +3,7 @@
 ![Python](https://img.shields.io/badge/python-3.10%2B-3776AB?logo=python&logoColor=white)
 ![License: MIT](https://img.shields.io/badge/license-MIT-green)
 ![core dependencies: 0](https://img.shields.io/badge/core_dependencies-0-success)
-![tests: 62 passing](https://img.shields.io/badge/tests-62_passing-brightgreen)
+![tests: 79 passing](https://img.shields.io/badge/tests-79_passing-brightgreen)
 ![storage: SQLite](https://img.shields.io/badge/storage-SQLite-003B57?logo=sqlite&logoColor=white)
 ![MCP](https://img.shields.io/badge/MCP-ready-FF6F00)
 
@@ -51,6 +51,7 @@ Small enough to hold in your head. Flexible enough to model anything.
 - [Install](#install)
 - [Quickstart](#quickstart)
 - [Performance](#performance)
+- [RDF interop: export, SPARQL, RDF-star](#rdf-interop-export-sparql-rdf-star)
 - [Command reference](#command-reference)
 - [Project layout](#project-layout)
 - [Development](#development)
@@ -542,7 +543,8 @@ It exposes `kg_`-prefixed tools for reads (`kg_node_get`, `kg_nodes_by_kind`,
 `kg_neighborhood`, `kg_shortest_path`, `kg_descendants`, …), gated writes
 (`kg_node_upsert`, `kg_edge_add`, `kg_node_delete`, …), bulk composition
 (`kg_import` — a whole `{nodes, edges}` batch in one call, so an agent populates
-an ontology in a single tool call instead of dozens), and the event log
+an ontology in a single tool call instead of dozens), RDF interop
+(`kg_rdf_export`, `kg_rdf_import` — see below), and the event log
 (`kg_events_tail`, `kg_event_revert`, `kg_replay`). Every write passes through
 the invariants + policy gate and is recorded — same engine, same file as the
 CLI. Every tool also takes an optional `ontology` name (omit for the default),
@@ -568,7 +570,7 @@ that data by `bench/charts.py`. Run both on your own machine in one command.
 
 ### Writes — the batching lever
 
-![Write throughput — batch the commit, ~10× faster](assets/write_throughput.png)
+![Write throughput — batch the commit, ~10× faster](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/write_throughput.png)
 
 Each single write commits on its own for durability. Wrapping a bulk load in
 `batch()` / `add_nodes` / `add_edges` collapses those per-call commits into one
@@ -579,7 +581,7 @@ thousands per second.
 
 ### Reads — fast, with an honest tail
 
-![Read latency — p50 marker, whisker to p99, log scale](assets/read_latency.png)
+![Read latency — p50 marker, whisker to p99, log scale](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/read_latency.png)
 
 Point lookups land in single-digit microseconds, and multi-node reads hydrate
 the whole result set in a constant number of queries (no N+1 fan-out). The chart
@@ -593,7 +595,7 @@ SQLite engine runs under CPython, Node, and Bun, so the gap between them is pure
 binding overhead — under 2×, and it doesn't even favor one runtime across
 operations.
 
-![Same SQLite across CPython, Node, and Bun](assets/runtimes.png)
+![Same SQLite across CPython, Node, and Bun](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/runtimes.png)
 
 The lever that actually moved the needle was transaction batching (~10×, above),
 not the language. Reproduce it with `python bench/runtimes/compare.py`.
@@ -603,7 +605,7 @@ not the language. Reproduce it with `python bench/runtimes/compare.py`.
 We measured it against Neo4j — same graph, same queries, identical methodology
 (full harness and reproduction in [`bench/neo4j/`](bench/neo4j/README.md)):
 
-![Where the crossover is — kgrdbms vs Neo4j](assets/crossover.png)
+![Where the crossover is — kgrdbms vs Neo4j](https://raw.githubusercontent.com/cunicopia-dev/knowledge-graph-rdbms/master/assets/crossover.png)
 
 Queries compile to SQL over B-tree indexes, so each traversal hop is an index
 lookup — wonderfully cheap for point reads and shallow traversals. An in-process
@@ -644,6 +646,67 @@ ontology to it while the hot, shallow ones stay embedded.
 
 ---
 
+## RDF interop: export, SPARQL, RDF-star
+
+The store stays a label property graph. RDF is a **boundary** format here, not a
+storage model — there is no triplestore, no OWL, no embedded SPARQL engine. The
+project adopts exactly one RDF idea, because it is the only one expensive to
+retrofit: **stable identity** (CURIE node ids). This is where a CURIE finally
+expands into a real IRI.
+
+```bash
+kg rdf export                         # Turtle, to stdout (RDF-star edges)
+kg rdf export --format ntriples --out graph.nt
+kg rdf import graph.nt                 # back in — gated, logged, replayable
+```
+
+Export is **dependency-free**. Node ids round-trip as CURIEs, because the prefix
+binding makes the IRI collapse back to exactly what you stored:
+
+```turtle
+@prefix person: <https://kg.local/person/> .
+@prefix kg:     <https://kg.local/vocab#> .
+
+person:ada a kg:Person ;
+    kg:name "Ada Lovelace" ;
+    prop:born "1815"^^xsd:integer ;
+    rel:influences person:grace .
+
+<< person:ada rel:influences person:grace >> prop:since "2020"^^xsd:integer .
+```
+
+That last line is the interesting one. A plain triple has nowhere to hang an
+**edge's** properties; `--edge-strategy` decides how they cross:
+
+| strategy           | edge `{since: 2020}` becomes                          | when to use                            |
+| ------------------ | ----------------------------------------------------- | -------------------------------------- |
+| `rdf-star` (default) | `<< :ada :influences :grace >> :since 2020`         | star-aware stores (Stardog, Jena 4.3+, Oxigraph) |
+| `reification`      | an `rdf:Statement` node carrying s/p/o + each property | rdflib and any RDF 1.1 tool            |
+| `lossy`            | the bare triple; properties dropped (count reported)  | you only want topology                 |
+
+**SPARQL?** Yes — against the export, in any store. You don't embed a query
+engine (that would betray the zero-dependency, no-SPARQL design); you emit a
+graph a real engine can query:
+
+```python
+import rdflib
+from kgrdbms import rdf
+
+# rdflib is RDF 1.1 — no star — so emit reification for it:
+ttl = rdf.export(graph, "turtle", rdf.IriContext(edge_strategy="reification"))
+store = rdflib.Graph(); store.parse(data=ttl, format="turtle")
+store.query("SELECT ?s ?o WHERE { ?s <https://kg.local/rel/influences> ?o }")
+```
+
+For SPARQL-**star** over the `rdf-star` export, hand the Turtle to a star-native
+store (Stardog, Jena, Oxigraph, GraphDB). Turtle/foreign-RDF *import* needs the
+optional extra (`pip install "knowledge-graph-rdbms[rdf]"`, which pulls
+`rdflib`); N-Triples import and **all** export stay dependency-free. Imported RDF
+rides the same gated, logged path as every other write, so it is audited and
+replayable.
+
+---
+
 ## Command reference
 
 | Command                         | What it does                                  |
@@ -667,6 +730,8 @@ ontology to it while the hot, shallow ones stay embedded.
 | `kg revert EVENT_ID`            | undo an event (compensating event)            |
 | `kg replay [--upto TS]`         | rebuild the projection from the log           |
 | `kg import FILE`                | bulk `{nodes, edges}` import (gated + logged) |
+| `kg rdf export [--format F]`    | serialize to Turtle/N-Triples (RDF-star)      |
+| `kg rdf import FILE`            | load RDF back in (gated + logged)             |
 | `kg ontology list`              | list registered ontologies (the registry)     |
 | `kg ontology create NAME …`     | register an ontology (`--backend`, `--stance`) |
 | `kg serve [--transport T]`      | run the MCP server                            |
@@ -692,6 +757,7 @@ kgrdbms/
 │   ├── sqlite.py   #   live engine (adapter over Graph)
 │   ├── postgres.py #   live engine (psycopg; jsonb + recursive CTEs); [postgres] extra
 │   └── neo4j.py    #   stub (deep-traversal escalation)
+├── rdf.py          # RDF boundary: Turtle/N-Triples export + import (RDF-star); rdflib only for [rdf] import
 ├── cli.py          # the `kg` command (stdlib argparse)
 └── mcp_server.py   # the MCP server (optional [mcp] extra)
 ```

{knowledge_graph_rdbms-0.1.0 → knowledge_graph_rdbms-0.1.2}/kgrdbms/__init__.py

@@ -12,7 +12,7 @@ A small, dependency-free knowledge-graph core:
 
 from __future__ import annotations
 
-__version__ = "0.1.0"
+__version__ = "0.1.2"
 
 from kgrdbms.graph import Edge, Graph, Node, default_graph_path, slug
 from kgrdbms.events import (

{knowledge_graph_rdbms-0.1.0 → knowledge_graph_rdbms-0.1.2}/kgrdbms/cli.py

@@ -24,7 +24,7 @@ import json
 import sys
 from typing import Any
 
-from kgrdbms import __version__, resolver, service
+from kgrdbms import __version__, rdf, resolver, service
 from kgrdbms.events import EventLog
 from kgrdbms.graph import Edge, Graph, Node
 from kgrdbms.invariants import InvariantViolation
@@ -358,6 +358,53 @@ def cmd_import(app: App, args) -> int:
     return 0
 
 
+def cmd_rdf_export(app: App, args) -> int:
+    """Serialize the whole graph to RDF (Turtle/N-Triples, RDF-star by default).
+
+    Export is dependency-free. `--edge-strategy` chooses how edge properties
+    cross: rdf-star (quoted triples, default), reification (rdf:Statement), or
+    lossy (bare triples — the dropped count is reported, never silent).
+    """
+    ctx = rdf.IriContext(edge_strategy=args.edge_strategy)
+    triples = rdf.export_graph(app.graph, ctx)
+    if args.format in ("turtle", "ttl"):
+        text = rdf.to_turtle(triples, ctx)
+    else:
+        text = rdf.to_ntriples(triples)
+    dropped = getattr(triples, "dropped_edge_props", 0)
+
+    if args.out:
+        with open(args.out, "w", encoding="utf-8") as fh:
+            fh.write(text)
+        note = f" ({dropped} edge-property values dropped by lossy)" if dropped else ""
+        app.emit(
+            {"format": args.format, "triples": len(triples), "out": args.out, "dropped_edge_props": dropped},
+            f"wrote {len(triples):,} triples to {args.out}{note}",
+        )
+    elif app.as_json:
+        app.emit({"format": args.format, "triples": len(triples), "dropped_edge_props": dropped, "rdf": text})
+    else:
+        if dropped:
+            print(f"# note: {dropped} edge-property values dropped by lossy strategy", file=sys.stderr)
+        print(text, end="")  # raw RDF to stdout, pipeable
+    return 0
+
+
+def cmd_rdf_import(app: App, args) -> int:
+    """Load RDF into the graph through the gated + logged path (replayable).
+
+    N-Triples import is dependency-free; Turtle import needs the 'rdf' extra
+    (rdflib). `--edge-strategy` must match how the RDF encoded its edges.
+    """
+    with open(args.file, encoding="utf-8") as fh:
+        text = fh.read()
+    ctx = rdf.IriContext(edge_strategy=args.edge_strategy)
+    res = rdf.import_rdf(app.graph, app.events, text, fmt=args.format, ctx=ctx, actor=args.actor)
+    app.emit(res, f"imported {res['nodes_imported']:,} nodes and "
+                  f"{res['edges_imported']:,} edges from {args.file} (gated + logged)")
+    return 0
+
+
 def cmd_serve(app: App, args) -> int:
     try:
         from kgrdbms import mcp_server
@@ -505,6 +552,29 @@ def build_parser() -> argparse.ArgumentParser:
     a.add_argument("--actor", default="cli-import")
     a.set_defaults(func=cmd_import)
 
+    # ---- RDF boundary ----
+    rdfp = sub.add_parser("rdf", help="export/import RDF (Turtle / N-Triples, RDF-star)")
+    rdfsub = rdfp.add_subparsers(dest="action", required=True)
+
+    a = rdfsub.add_parser("export", help="serialize the graph to RDF (dependency-free)")
+    a.add_argument("--format", default="turtle", choices=["turtle", "ttl", "ntriples", "nt"],
+                   help="turtle (default, human-readable) or ntriples (lossless, dep-free)")
+    a.add_argument("--edge-strategy", dest="edge_strategy", default="rdf-star",
+                   choices=["rdf-star", "reification", "lossy"],
+                   help="how edge properties cross the boundary (default: rdf-star)")
+    a.add_argument("--out", help="write to this file (default: stdout)")
+    a.set_defaults(func=cmd_rdf_export)
+
+    a = rdfsub.add_parser("import", help="load RDF into the graph (gated + logged)")
+    a.add_argument("file")
+    a.add_argument("--format", default="ntriples", choices=["ntriples", "nt", "turtle", "ttl"],
+                   help="ntriples (default, dep-free) or turtle (needs the 'rdf' extra)")
+    a.add_argument("--edge-strategy", dest="edge_strategy", default="rdf-star",
+                   choices=["rdf-star", "reification", "lossy"],
+                   help="strategy the RDF was written with, so edges decode correctly")
+    a.add_argument("--actor", default="rdf-import")
+    a.set_defaults(func=cmd_rdf_import)
+
     a = sub.add_parser("serve", help="run the MCP server (needs the 'mcp' extra)")
     a.add_argument("--transport", default="stdio", choices=["stdio", "sse", "streamable-http"])
     a.set_defaults(func=cmd_serve)

{knowledge_graph_rdbms-0.1.0 → knowledge_graph_rdbms-0.1.2}/kgrdbms/mcp_server.py

@@ -40,6 +40,10 @@ Tool surface (all prefixed kg_):
     kg_import             — bulk {nodes, edges} in ONE call (one batch; use this
                             to compose an ontology instead of N upsert calls)
 
+  rdf boundary
+    kg_rdf_export         — serialize an ontology to Turtle/N-Triples (RDF-star)
+    kg_rdf_import         — load RDF text back in (gated + logged, replayable)
+
   event log
     kg_events_tail        — most recent events
     kg_event_revert       — reverse an event via a compensating event
@@ -55,7 +59,7 @@ from typing import Any
 
 from mcp.server.fastmcp import FastMCP
 
-from kgrdbms import resolver, service
+from kgrdbms import rdf, resolver, service
 from kgrdbms.graph import Edge, Node
 from kgrdbms.resolver import Resolved
 
@@ -366,6 +370,62 @@ def kg_import(
     return {"ontology": b.entry.name, **res}
 
 
+# ---- RDF boundary: export / import ----------------------------------
+
+
+@mcp.tool()
+def kg_rdf_export(
+    format: str = "turtle",
+    edge_strategy: str = "rdf-star",
+    ontology: str | None = None,
+) -> dict:
+    """Serialize an ontology to RDF text (dependency-free).
+
+    Hand the result to any RDF store (Stardog, rdflib, Jena) to run SPARQL —
+    the LPG stays the store of record; RDF is just the boundary format.
+
+      format        — "turtle" (human-readable, default) or "ntriples" (lossless)
+      edge_strategy — how edge properties cross: "rdf-star" (quoted triples,
+                      default), "reification" (rdf:Statement), or "lossy"
+                      (bare triples; dropped count returned, never silent)
+
+    Node ids round-trip as CURIEs (person:ada <-> <https://kg.local/person/ada>).
+    Returns {ontology, format, triples, dropped_edge_props, rdf}.
+    """
+    b = _bundle(ontology)
+    ctx = rdf.IriContext(edge_strategy=edge_strategy)
+    triples = rdf.export_graph(b.backend, ctx)
+    text = rdf.to_turtle(triples, ctx) if format in ("turtle", "ttl") else rdf.to_ntriples(triples)
+    return {
+        "ontology": b.entry.name,
+        "format": format,
+        "triples": len(triples),
+        "dropped_edge_props": getattr(triples, "dropped_edge_props", 0),
+        "rdf": text,
+    }
+
+
+@mcp.tool()
+def kg_rdf_import(
+    text: str,
+    format: str = "ntriples",
+    edge_strategy: str = "rdf-star",
+    actor: str = "rdf-import",
+    ontology: str | None = None,
+) -> dict:
+    """Load RDF text into an ontology through the gated + logged path (replayable).
+
+    N-Triples import is dependency-free; Turtle import needs the [rdf] extra
+    (rdflib). `edge_strategy` must match how the RDF encoded its edges, so the
+    edge properties decode back onto the right edges. Returns
+    {ontology, nodes_imported, edges_imported}.
+    """
+    b = _bundle(ontology)
+    ctx = rdf.IriContext(edge_strategy=edge_strategy)
+    res = rdf.import_rdf(b.backend, b.events, text, fmt=format, ctx=ctx, actor=actor)
+    return {"ontology": b.entry.name, **res}
+
+
 # ---- event log: read + reversal + replay ----------------------------