# How to Generate RDF Triplets from Text Using Semantica: A Complete Developer Guide

> Learn how to generate RDF triplets from text using Semantica. This guide details the TripletExtractor and RDFSerializer for efficient data conversion.

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

---

**Semantica converts raw text into RDF-compatible subject-predicate-object triplets through a pipeline orchestrated by the `TripletExtractor` class and serialized via the `RDFSerializer` or `RDFExporter` classes.**

Semantica is an open-source semantic extraction framework designed to bridge natural language processing and knowledge graph construction. This guide demonstrates how to generate RDF triplets from text using Semantica's architectural components, from pattern-based extraction to LLM-powered Relation Extraction (RE), based on the current implementation in the [semantica-agi/semantica](https://github.com/semantica-agi/semantica) repository.

## The RDF Triplet Generation Pipeline

Semantica implements a four-stage pipeline that transforms unstructured text into structured RDF data. The process moves through extraction orchestration, optional entity/relation preprocessing, triplet generation, and finally format-specific serialization.

### Step 1: Initialize the TripletExtractor

The [`TripletExtractor`](https://github.com/semantica-agi/semantica/blob/main/semantica/semantic_extract/triplet_extractor.py#L82-L98) class serves as the primary orchestrator. During initialization, it selects an extraction backend—**pattern-based**, **rule-based**, **HuggingFace models**, or **LLM providers**—and configures metadata enrichment options.

Key initialization parameters include:

- **`method`**: Selects the extraction engine (`"pattern"`, `"rule"`, `"huggingface"`, or `"llm"`)
- **`include_temporal`**: Enriches triplets with OWL-Time timestamps for temporal reasoning
- **`include_provenance`**: Attaches source-sentence metadata for traceability

The constructor also instantiates a built-in **`RDFSerializer`** for immediate in-memory serialization, accessible via the `rdf_serializer` attribute.

### Step 2: Extract Triplets from Text

Call the [`extract_triplets`](https://github.com/semantica-agi/semantica/blob/main/semantica/semantic_extract/triplet_extractor.py#L298-L314) method to process raw text or batch documents. This method returns a `List[Triplet]` where each `Triplet` dataclass (defined in [[`semantica/semantic_extract/types.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/semantic_extract/types.py)](https://github.com/semantica-agi/semantica/blob/main/semantica/semantic_extract/types.py)) contains structured **subject**, **predicate**, and **object** fields.

You can optionally pass pre-computed entities and relations to bypass internal NER models, or let the extractor handle the entire pipeline end-to-end.

### Step 3: Serialize to Standard RDF Formats

Semantica supports multiple W3C-standard serialization formats through two primary classes:

- **`RDFSerializer`**: Handles in-memory conversion to Turtle, N-Triples, JSON-LD, or RDF/XML strings. The core implementation resides in [[`semantica/export/rdf_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/rdf_exporter.py)](https://github.com/semantica-agi/semantica/blob/main/semantica/export/rdf_exporter.py#L315-L340).
- **`RDFExporter`**: Provides file-system persistence and optional RDF validation. The [`export`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/rdf_exporter.py#L22-L30) method writes directly to disk while leveraging utilities from [[`semantica/utils/helpers.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/utils/helpers.py)](https://github.com/semantica-agi/semantica/blob/main/semantica/utils/helpers.py) for stable IRI minting.

## Practical Code Examples

### Basic Pattern-Based Extraction

Use the default pattern-based method for fast, deterministic extraction without external API dependencies:

```python
from semantica.semantic_extract import TripletExtractor

# Initialize with pattern-based extraction

extractor = TripletExtractor(method="pattern")

# Raw text input

sample_text = """
Alice founded Acme Corp in 2020. Bob works at Acme Corp.
"""

# Generate triplets

triplets = extractor.extract_triplets(sample_text)

# Serialize to Turtle format

turtle_output = extractor.rdf_serializer.serialize_to_turtle(triplets)
print(turtle_output)

```

### LLM-Based Extraction with File Export

For complex relational extraction requiring semantic understanding, configure the LLM backend and export results directly to file:

```python
from semantica.semantic_extract import TripletExtractor
from semantica.export import RDFExporter

# Configure LLM extraction with provenance tracking

extractor = TripletExtractor(
    method="llm",
    provider="openai",
    llm_model="gpt-4",
    include_provenance=True,
)

text = "The treaty was signed on 12-Jan-2022 by the United Nations."
triplets = extractor.extract_triplets(text)

# Export to Turtle file with validation

exporter = RDFExporter()
exporter.export(triplets, "output.ttl", format="turtle")

```

### Batch Processing with Temporal Enrichment

Process multiple documents simultaneously while capturing temporal metadata using the OWL-Time ontology:

```python
from semantica.semantic_extract import TripletExtractor

# Enable temporal extraction

extractor = TripletExtractor(
    method="pattern",
    include_temporal=True,
)

documents = [
    "Event A happened yesterday.",
    "Event B will occur tomorrow."
]

# Batch extraction returns List[List[Triplet]]

batch_results = extractor.extract_triplets(documents)

# Serialize each document separately

for idx, triplet_list in enumerate(batch_results):
    turtle_data = extractor.rdf_serializer.serialize_to_turtle(triplet_list)
    print(f"Document {idx} RDF:\n{turtle_data}")

```

## Key Configuration Flags

Semantica provides granular control over triplet metadata through boolean flags passed to the [`TripletExtractor.__init__`](https://github.com/semantica-agi/semantica/blob/main/semantica/semantic_extract/triplet_extractor.py#L85-L107) method:

- **`include_temporal=True`**: Parses temporal expressions and attaches OWL-Time compliant timestamps to relevant triplets
- **`include_provenance=True`**: Records the source sentence and character offsets for each extracted triplet, enabling full audit trails

These flags propagate through the extraction pipeline and are respected by both the `RDFSerializer` and `RDFExporter` during output generation.

## Summary

- **TripletExtractor** acts as the central orchestrator, supporting four distinct extraction methods (pattern, rule, HuggingFace, LLM)
- The **extract_triplets** method converts text or document batches into structured `Triplet` objects defined in the core types module
- **RDFSerializer** provides in-memory serialization to Turtle, N-Triples, JSON-LD, and RDF/XML formats
- **RDFExporter** handles file persistence and optional RDF validation using helper utilities for IRI generation
- Configuration flags for **temporal** and **provenance** metadata enable semantic enrichment compatible with OWL-Time standards

## Frequently Asked Questions

### What RDF serialization formats does Semantica support?

Semantica supports W3C-standard formats including **Turtle**, **N-Triples**, **JSON-LD**, and **RDF/XML**. The `RDFSerializer` class provides dedicated methods such as `serialize_to_turtle()` and `serialize_to_json_ld()`, while the `RDFExporter` handles format detection via file extensions or explicit format parameters.

### Can I use custom LLM providers for relation extraction?

Yes. When initializing `TripletExtractor` with `method="llm"`, specify your provider through the `provider` parameter (e.g., `"openai"`). The architecture supports pluggable LLM backends, allowing integration with OpenAI, Anthropic, or local models via the unified interface defined in the extraction module.

### How does Semantica handle temporal information in triplets?

When `include_temporal=True` is set during extractor initialization, Semantica parses temporal expressions in the source text and generates additional triplets using the **OWL-Time** ontology. These triplets link events to specific timestamps or temporal intervals, enabling time-aware querying in downstream knowledge graph applications.

### What is the difference between RDFSerializer and RDFExporter?

**RDFSerializer** performs in-memory conversion of `Triplet` objects to RDF string representations suitable for immediate use in Python workflows. **RDFExporter** extends this functionality to the file system, handling directory creation (via [[`semantica/utils/helpers.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/utils/helpers.py)](https://github.com/semantica-agi/semantica/blob/main/semantica/utils/helpers.py)), file I/O operations, and optional RDF validation before persistence.