# How to Export Knowledge Graphs from Semantica to RDF, OWL, Parquet, and Cypher Formats

> Export knowledge graphs from Semantica to RDF, OWL, Parquet, and Cypher formats using dedicated exporters. Learn how to serialize your data efficiently.

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

---

**Semantica provides dedicated exporters in `semantica/export/` that serialize knowledge graphs to Parquet via `ParquetExporter`, RDF/OWL via `RDFExporter`, and Cypher via `LPGExporter`, each with explicit schemas, namespace management, and validation hooks.**

The `semantica-agi/semantica` repository ships with a modular export layer capable of converting internal knowledge graph structures into four critical interchange formats. Mastering how to export knowledge graphs from Semantica to RDF, OWL, Parquet, and Cypher formats enables seamless integration with semantic web tools, columnar data warehouses, and graph databases like Neo4j.

## Exporting to Parquet with ParquetExporter

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 compressed Apache Arrow tables using explicit schemas.

### Arrow Schema Definitions

The exporter defines strict **Arrow schemas** (`ENTITY_SCHEMA` and `RELATIONSHIP_SCHEMA`) to ensure type safety without inference. These schemas map entity fields like `label` to `text`, handle nullable strings, and store metadata as structs.

```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),
])

```

### Writing Compressed Columnar Files

The `export_knowledge_graph()` method normalizes the input dictionary, validates IDs, and writes to `.parquet` files using `pa.Table.from_pylist()` followed by `pq.write_table()`. Compression options include **snappy**, **gzip**, and **zstd**.

```python
from semantica.export import ParquetExporter

# Initialize with optional compression

exporter = ParquetExporter(compression="snappy")

# Export produces: output/kg_entities.parquet and output/kg_relationships.parquet

exporter.export_knowledge_graph(kg, "output/kg")

```

## Serializing to RDF and OWL with RDFExporter

The **RDFExporter** class in [`semantica/export/rdf_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/rdf_exporter.py) handles semantic web serialization, including OWL-compatible Turtle output through namespace management.

### Namespace Management and Validation

The exporter uses **NamespaceManager** (lines 41-84) to handle prefix-to-URI mappings and resolve conflicts. **RDFValidator** runs syntax, namespace, and consistency checks before serialization begins.

### Format Dispatch

The `export_to_rdf()` method dispatches to format-specific serializers based on the `format` parameter:

- `turtle` → `serialize_to_turtle()`
- `rdfxml` → `serialize_to_rdfxml()`
- `jsonld` → `serialize_to_jsonld()`
- `ntriples` → `serialize_to_ntriples()`

```python

# From semantica/export/rdf_exporter.py

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(...)

```

### OWL Compatibility and Temporal Data

OWL ontologies are produced by utilizing the `owl` namespace within Turtle output. Setting `include_temporal=True` injects **OWL-Time** namespace triples (`time`) for temporal bounds, creating OWL-compatible RDF graphs without requiring a separate exporter.

```python
from semantica.export import RDFExporter

rdf_exporter = RDFExporter()
rdf_exporter.export(kg, "output/graph.ttl", format="turtle", include_temporal=True)

```

## Generating Cypher Scripts with LPGExporter

For graph database ingestion, the **LPGExporter** (exposed via [`semantica/export/methods.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/methods.py)) generates Cypher `CREATE` statements compatible with Neo4j and Memgraph.

### Literal Conversion and Statement Generation

The exporter relies on helper functions `_value_to_cypher_literal()` and `_props_to_cypher_literal()` from [`semantica/graph_store/age_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/age_store.py) (lines 113-138) to convert Python values into Cypher-safe syntax. It normalizes entities into nodes and relationships into edges, outputting executable `.cypher` files.

```python
from semantica.export import export_knowledge_graph

# Generates output/graph.cypher with CREATE statements

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

```

Example output structure:

```cypher
CREATE (n:Person {id: "p1", name: "Alice", confidence: 0.98});
CREATE (n:Organization {id: "o1", name: "Acme Corp"});
MATCH (a:Person {id: "p1"}), (b:Organization {id: "o1"})
CREATE (a)-[:EMPLOYED_BY {since: "2020-01-01"}]->(b);

```

## Unified Export Interface

The `export_knowledge_graph()` helper in [`semantica/export/methods.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/methods.py) serves as a unified dispatcher. It accepts a `format` parameter (`"parquet"`, `"rdf"`, `"cypher"`, etc.) and routes to the appropriate exporter class, handling **ProgressTracker** integration for long-running operations.

```python
from semantica.export import export_knowledge_graph

# Parquet via dispatcher

export_knowledge_graph(kg, "output/data", format="parquet")

# RDF JSON-LD via dispatcher

export_knowledge_graph(kg, "output/data.jsonld", format="rdf", rdf_format="jsonld")

```

## Summary

- **Parquet** exports use `ParquetExporter` with explicit **Apache Arrow** schemas (`ENTITY_SCHEMA`, `RELATIONSHIP_SCHEMA`) and configurable compression.
- **RDF/OWL** exports utilize `RDFExporter` with **NamespaceManager** for prefix handling and support Turtle, RDF/XML, JSON-LD, and N-Triples; OWL compatibility is achieved through the `owl` namespace and optional temporal triples.
- **Cypher** exports are handled by `LPGExporter` via the unified interface, generating executable Cypher scripts using literal conversion helpers from [`age_store.py`](https://github.com/semantica-agi/semantica/blob/main/age_store.py).
- All exporters validate input structures and integrate with Semantica's **ProgressTracker** for cancellation support.

## Frequently Asked Questions

### Which exporter should I use for Neo4j?

Use the **Cypher** exporter by calling `export_knowledge_graph(..., format="cypher")` or instantiating `LPGExporter` directly. This produces a `.cypher` file containing `CREATE` statements for nodes and relationships that can be executed directly in Neo4j or Memgraph using their standard import tools.

### Can I export temporal data to OWL format?

Yes. When using `RDFExporter.export()` with `format="turtle"` and `include_temporal=True`, the serializer automatically injects **OWL-Time** namespace triples and temporal bound assertions. This creates OWL-compatible output suitable for temporal reasoning in semantic web applications.

### What schema does the Parquet exporter use?

The `ParquetExporter` uses explicit **Arrow schemas** defined in [`semantica/export/parquet_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/parquet_exporter.py): `ENTITY_SCHEMA` requires a non-nullable `id` string and nullable `text` field, while `RELATIONSHIP_SCHEMA` enforces `source_id`, `target_id`, and `type` fields. Metadata is stored as a struct of key-value lists to preserve arbitrary properties.

### How do I handle validation errors during export?

Each exporter includes validation logic: `RDFExporter` uses `RDFValidator` for syntax and namespace checks, while `ParquetExporter` validates ID existence and type consistency. If validation fails, exporters raise exceptions before writing output. Wrap calls in try-except blocks to catch these errors, or pre-validate your knowledge graph using Semantica's validation utilities.