# How to Export Knowledge Graphs from Semantica to RDF, Parquet, Cypher, or JSON-LD

> Export knowledge graphs from Semantica to RDF, Parquet, Cypher, or JSON-LD using dedicated exporter classes. Learn how to serialize your graph data efficiently.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: how-to-guide
- Published: 2026-08-21

---

**Semantica provides dedicated exporter classes—`ParquetExporter`, `RDFExporter`, and `LPGExporter`—that serialize knowledge graphs to Apache Parquet, RDF/OWL (Turtle, JSON-LD, N-Triples), and Cypher formats through methods like `export_knowledge_graph()` and `export()`.**

The `semantica-agi/semantica` repository includes a modular export layer in `semantica/export/` that converts internal knowledge graph structures—standard Python dictionaries containing `entities` and `relationships`—into validated, industry-standard interchange formats. Each exporter enforces strict schemas, handles namespace mapping, and integrates with the global `ProgressTracker` for long-running operations.

## Exporting Knowledge Graphs to Apache Parquet

The `ParquetExporter` class in [`semantica/export/parquet_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/parquet_exporter.py) serializes entities and relationships into columnar Arrow tables using explicit PyArrow schemas.

### Schema Architecture

The exporter defines two immutable schemas that eliminate runtime inference:

```python

# semantica/export/parquet_exporter.py

ENTITY_SCHEMA = pa.schema([
    pa.field("id", pa.string(), nullable=False),
    pa.field("text", pa.string(), nullable=True),
    pa.field("metadata", pa.struct([
        pa.field("keys", pa.list_(pa.string())),
        pa.field("values", pa.list_(pa.string())),
    ]), nullable=True),
])

```

Relationships follow a similar `RELATIONSHIP_SCHEMA` structure. The `export_knowledge_graph()` method normalizes input dictionaries—mapping fields like `label` to `text`—before writing via `pa.Table.from_pylist(data, schema=schema)` and `pq.write_table()`.

### Usage

```python
from semantica.export import ParquetExporter

exporter = ParquetExporter(compression="snappy")
exporter.export_knowledge_graph(kg, "output/knowledge_graph")

```

This produces two files: `knowledge_graph_entities.parquet` and `knowledge_graph_relationships.parquet` (see `ParquetExporter.export_knowledge_graph` lines 61‑87).

## Serializing to RDF, OWL, and JSON-LD

The `RDFExporter` in [`semantica/export/rdf_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/rdf_exporter.py) handles semantic web serialization through the `NamespaceManager` and `RDFSerializer` classes.

### Namespace Management and Validation

The `NamespaceManager` (lines 41‑84) resolves prefix conflicts and maintains URI mappings for standard vocabularies including `rdf`, `xsd`, and `semantica`. The `RDFValidator` performs syntax and consistency checks before serialization.

### Format Dispatch

The `export_to_rdf()` method supports four output formats:

```python
if format == "turtle":
    result = self.serializer.serialize_to_turtle(...)
elif format == "rdfxml":
    result = self.serializer.serialize_to_rdfxml(...)
elif format == "jsonld":
    result = self.serializer.serialize_to_jsonld(...)
elif format == "ntriples":
    result = self.serializer.serialize_to_ntriples(...)

```

Passing `format="turtle"` with `include_temporal=True` emits OWL‑Time compatible triples (lines 95‑104), enabling OWL ontology support by including temporal bounds and standard OWL prefixes.

### RDF Export Examples

```python
from semantica.export import RDFExporter

rdf_exporter = RDFExporter()

# OWL-compatible Turtle

rdf_exporter.export(kg, "ontology.ttl", format="turtle", include_temporal=True)

# Linked Data format

rdf_exporter.export(kg, "graph.jsonld", format="jsonld")

```

## Generating Cypher Scripts for Neo4j and Memgraph

Cypher export uses the **LPG (Labeled Property Graph)** serializer accessible via the unified `export_knowledge_graph()` helper in [`semantica/export/methods.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/methods.py).

### Implementation Details

When invoked with `format="cypher"`, the dispatcher routes to the `LPGExporter` class, which generates `CREATE` statements for nodes and relationships. The conversion relies on literal serialization helpers in [`semantica/graph_store/age_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/age_store.py):

- `_value_to_cypher_literal()` – Converts Python scalars to Cypher syntax (lines 113‑138)
- `_props_to_cypher_literal()` – Maps property dictionaries to Cypher map literals

The resulting `.cypher` files contain statements compatible with `neo4j-admin import` and Memgraph loaders.

### Cypher Export Usage

```python
from semantica.export import export_knowledge_graph

# Generate Cypher script

export_knowledge_graph(kg, "output/graph.cypher", format="cypher")

```

Direct instantiation of the low-level exporter is also available:

```python
from semantica.export.methods import LPGExporter

lpg = LPGExporter()
lpg.export_knowledge_graph(kg, "output/graph.cypher")

```

## Unified Export Interface

The `export_knowledge_graph()` function in [`semantica/export/methods.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/methods.py) serves as a high-level dispatcher. It accepts a `format` parameter—`"parquet"`, `"rdf"`, `"cypher"`, `"jsonld"`, `"turtle"`, or `"ntriples"`—and delegates to the appropriate exporter class while handling progress tracking and optional provenance logging via [`semantica/export/export_provenance.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/export_provenance.py).

## Summary

- **Parquet** – Use `ParquetExporter` with explicit `ENTITY_SCHEMA` and `RELATIONSHIP_SCHEMA` for Snappy-compressed columnar storage.
- **RDF/OWL** – Use `RDFExporter.export()` with `format="turtle"` and `include_temporal=True` for OWL-compatible output; supports JSON-LD, RDF/XML, and N-Triples via the serializer dispatcher.
- **Cypher** – Use the `export_knowledge_graph()` helper with `format="cypher"` to generate Neo4j-compatible CREATE statements, leveraging literal conversion utilities from [`age_store.py`](https://github.com/semantica-agi/semantica/blob/main/age_store.py).
- **Validation** – All exporters validate input graphs before serialization, ensuring ID presence and type consistency.

## Frequently Asked Questions

### Which exporter supports OWL ontology serialization?

The `RDFExporter` class supports OWL through Turtle output (`format="turtle"`) combined with the `include_temporal=True` flag. This emits OWL‑Time namespace triples and standard OWL prefixes; you can further extend OWL compatibility by adding `owl:Class` or `owl:equivalentClass` assertions directly to your entity dictionaries before export.

### How do I optimize Parquet exports for large knowledge graphs?

Instantiate `ParquetExporter` with `compression="snappy"` or `"gzip"` to reduce file size. The explicit Arrow schemas (`ENTITY_SCHEMA` and `RELATIONSHIP_SCHEMA`) prevent costly type inference on large datasets, and the exporter writes to disk using `pq.write_table()` with zero-copy Arrow buffers (see [`semantica/export/parquet_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/parquet_exporter.py) lines 81‑87).

### Can I export the same graph to multiple formats in one operation?

While no single method writes multiple formats simultaneously, you can chain calls to `export_knowledge_graph()` with different format parameters or instantiate specific exporters (`ParquetExporter`, `RDFExporter`) sequentially. Each export runs independently with its own validation pass.

### Is the generated Cypher compatible with Neo4j 5.x and Memgraph?

Yes. The `LPGExporter` generates standard openCypher `CREATE` statements using literal escaping helpers (`_value_to_cypher_literal` in [`semantica/graph_store/age_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/age_store.py)). The output contains no deprecated syntax and loads directly into Neo4j 5.x, Memgraph, and Amazon Neptune’s Cypher endpoints.