Semantica is an open-source Python framework for building context graphs and decision intelligence layers on top of AI agents and LLM applications. It provides structured memory, causal reasoning, and full decision provenance — making AI explainable and traceable.

Yes. The core library is 100% free and open source under the MIT license. No feature gating, no usage limits, no hidden tiers.

How is Semantica different from LangChain or LlamaIndex?

LangChain and LlamaIndex focus on orchestration and retrieval. Semantica adds a structured knowledge layer — context graphs, causal decision tracking, and W3C PROV-O provenance — that integrates on top of any framework.

Which AI frameworks does Semantica support?

Semantica integrates with LangGraph, CrewAI, LlamaIndex, Claude Code, AutoGen, and any Python-based agent framework, along with 100+ LLM models via LiteLLM.

What is a context graph?

A context graph is a structured, queryable knowledge graph that stores entities, relationships, and decisions made by your AI — with temporal validity and full provenance. Unlike a vector store, it understands causal relationships.

Does Semantica require a vector database?

No. Semantica works standalone. When you want hybrid graph + semantic retrieval it integrates natively with FAISS, Pinecone, Weaviate, Qdrant, Milvus, and pgvector.

What is decision provenance?

Decision provenance means every action your AI takes is stored as a first-class object with its inputs, reasoning chain, and outcome — compliant with W3C PROV-O. You can always audit why the AI did what it did.

How do I get started?

Run pip install semantica, then follow the quickstart in the docs at docs.getsemantica.ai. The core graph is up and running in under 10 lines of Python.

Capabilities — Semantica

Context & Decision Intelligence

semantica.context

Track decisions as first-class graph objects with full causal lineage, precedent search, and a built-in policy compliance gate. Every AI choice becomes permanent, queryable, and defensible.

Context Graphs

Temporal validity windows, typed entities and edges

Decision Tracking

record_decision() — structured, searchable, permanent

Causal Chains

add_causal_relationship() — trigger / enable / inhibit

Precedent Search

find_similar_decisions() — semantic similarity over history

Influence Analysis

analyze_decision_impact() — downstream effect map

Policy Engine

check_decision_rules() — compliance gate with configurable rule sets

Agent Memory

Short and long-term storage for multi-agent pipelines

Cross-System Context

Single shared intelligence layer across all agents

example.py

graph = ContextGraph(advanced_analytics=True)
decision_id = graph.record_decision(
    category="vendor_selection",
    outcome="selected_aws",
    confidence=0.93,
)
chain = graph.trace_decision_chain(decision_id)

8 features · independently importable

View documentation

Knowledge Graph Engine

semantica.kg

Build a production knowledge graph from any data source with full graph algorithm coverage — centrality, community detection, link prediction, and incremental updates.

Entity Management

Typed nodes and edges with arbitrary metadata

PageRank

Importance scoring across the full graph

Betweenness Centrality

Bridge detection — find the nodes that connect communities

Louvain Detection

Natural cluster discovery via community algorithms

Node2Vec Embeddings

Graph-native embeddings via NodeEmbedder

Similarity Calculator

Cosine similarity between any two node pairs

Link Prediction

Predict missing edges with LinkPredictor

Delta Processing

Incremental updates without full graph rebuilds

example.py

kg = GraphBuilder(merge_entities=True, enable_temporal=True).build(docs)
centrality  = CentralityCalculator().calculate_degree_centrality(kg)
communities = CommunityDetector().detect_communities(kg, method="louvain")
path        = PathFinder().find_shortest_path(kg, "alice", "contract_001")

8 features · independently importable

View documentation

Reasoning Engines

semantica.reasoning

Five deterministic reasoning engines with fully explainable inference paths. No black boxes — every conclusion traces back to the rules and facts that produced it.

Forward Chaining

IF/THEN rule execution over a growing fact base

Rete Network

High-throughput pattern matching for real-time compliance

Deductive Reasoning

Classical inference — modus ponens, modus tollens

Abductive Reasoning

Hypothesis generation from incomplete observations

SPARQL Reasoning

RDF graph queries with full triple store support

Datalog

Recursive declarative queries — ancestor(X, Z) :- ...

Explainable Paths

Full reasoning trace for every conclusion

Custom Pipelines

Compose multiple engines into a single inference chain

example.py

rete = ReteEngine()
rete.build_network([Rule(
    rule_id="aml_flag",
    conditions=[{"field": "amount", "operator": ">", "value": 10_000}],
    conclusion="flag_for_compliance_review",
    rule_type=RuleType.IMPLICATION,
)])
flagged = rete.match_patterns()

8 features · independently importable

View documentation

Temporal Intelligence

semantica.kg (temporal)

Query the graph as it existed at any past moment. Track valid time vs. recorded time independently with bi-temporal facts, and use Allen interval algebra to express any temporal relationship.

Temporal GraphRAG

Time-aware retrieval that respects validity windows

Allen Interval Algebra

13 temporal relations — before, during, overlaps, meets…

Point-in-Time Queries

graph.state_at("2024-01-01") — replay history

TemporalNormalizer

Parse natural language dates — "last quarter", "3 weeks ago"

Bi-Temporal Facts

Separate valid_time from recorded_at

Validity Windows

Decisions bounded by valid_from / valid_until

Named Checkpoints

Version snapshots for reproducible history

TemporalGraphQuery

Range queries across any time dimension

example.py

graph.add_node("alice_chen", "Person", role="VP Engineering")
snapshot_2023 = graph.state_at("2023-06-01")
snapshot_2024 = graph.state_at("2024-01-01")
tq = TemporalGraphQuery(graph)
facts = tq.query_time_range("2024-01-01", "2024-12-31")

8 features · independently importable

View documentation

Provenance & Auditability

semantica.provenance

Every fact links to its source. W3C PROV-O compliant audit trails exportable as Turtle, JSON-LD, CSV, or JSON — the format regulators, auditors, and compliance frameworks require.

Entity Provenance

ProvenanceTracker.track_entity() — source, page, confidence

Algorithm Provenance

Track which extractor, model, and version produced each fact

Relationship Provenance

Source attribution on every edge in the graph

W3C PROV-O

Standard compliance — exportable for regulator submission

Change Management

Checksums and diffs across graph versions

Audit Trails

Full compliance logging for every mutation

Lineage Tracing

trace_lineage() — full ancestor chain for any entity

Export Formats

Turtle, JSON-LD, N-Triples, JSON, CSV, Parquet

example.py

prov = ProvenanceManager(storage_path="./audit.db")
prov.track_entity("acme_corp", source="contract.pdf",
    metadata={"page": 1, "confidence": 0.97})
lineage = prov.get_lineage("acme_corp")
RDFExporter().export(kg, "audit_trail.ttl", format="turtle")

8 features · independently importable

View documentation

Ontology & Schema Management

semantica.ontology

Auto-generate OWL ontologies from your data, validate entity shapes with SHACL, manage SKOS vocabularies, and import from any existing RDF/OWL schema in seconds.

OWL Generation

Auto-create class hierarchies and property definitions from data

Schema Import

OWL, RDF, Turtle, JSON-LD — any existing vocabulary

HermiT / Pellet

Consistency checking via description logic reasoners

SHACL Shapes

Auto-generated validation — catches constraint violations at ingest

SKOS Vocabulary

Concept management with broader/narrower/related relations

Strictness Tiers

Basic / standard / strict — tune validation aggressiveness

Inheritance

Property propagation through the class hierarchy

Multi-Format Export

Turtle, JSON-LD, N-Triples, OWL/XML

example.py

gen      = OntologyGenerator()
ontology = gen.generate_ontology({"entities": entities, "relationships": []})
classes  = gen.infer_classes({"entities": entities, "relationships": []})
report   = OntologyValidator().validate(ontology)
if report.conforms:
    RDFExporter().export(ontology, "schema.ttl", format="turtle")

8 features · independently importable

View documentation

Every Capability, Fully Documented

Context & Decision Intelligence

Knowledge Graph Engine

Reasoning Engines

Temporal Intelligence

Provenance & Auditability

Ontology & Schema Management

Performance at Scale

Questions?

Start building