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 context, 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

Every AI decision stored as a first-class graph object, with causal lineage, precedent search, and a policy compliance gate.

View documentation

Context Graphs · Typed entities and edges with temporal validity windows

Decision Tracking · record_decision(), structured, searchable, permanent

Causal Chains · add_causal_relationship(): CAUSED, INFLUENCED, PRECEDENT_FOR

Precedent Search · find_similar_decisions(), semantic similarity over history

Influence Analysis · analyze_decision_impact(), downstream effect map

Policy Engine · check_decision_rules(), a compliance gate with configurable rules

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)

Knowledge Graph Engine

semantica.kg

Build a knowledge graph from any data source, with centrality, community detection, and link prediction built in.

View documentation

Entity Management · Typed nodes and edges with arbitrary metadata

Degree & Betweenness Centrality · Find the most-connected, bridge entities

Community Detection · Louvain method, natural cluster discovery

Link Prediction · Predict missing edges with LinkPredictor

Shortest Path · PathFinder traversal between any two nodes

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")

Polyglot Graph Storage

Swap between RDF triple stores and labeled property graphs behind one unified interface, without touching your code.

View documentation

RDF Triple Stores · Oxigraph, Blazegraph, Apache Jena, Eclipse RDF4J

Labeled Property Graphs · Neo4j, FalkorDB, Apache AGE, AWS Neptune

SPARQL & Cypher · Native query support across every backend

Bulk Loading · High-throughput ingestion for large graphs

Zero-Code Swaps · Change backend via configuration, not code

Reasoning Engines

semantica.reasoning

Deterministic, explainable inference. Every conclusion traces back to the rules and facts that produced it.

View documentation

Forward Chaining · IF/THEN rule execution over a growing fact base

Rete Network · High-throughput pattern matching for real-time compliance

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

SPARQL Reasoning · RDF graph queries with full triple store support

Explainable Paths · Full reasoning trace for every conclusion

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

Temporal Intelligence

semantica.kg (temporal)

Query the graph as it existed at any past moment, tracking valid time and recorded time independently.

View documentation

Point-in-Time Snapshots · graph.state_at("2024-01-01") replays history

Allen Interval Algebra · 13 temporal relations: before, during, overlaps, meets

Bi-Temporal Facts · Separate valid_time from recorded_at

TemporalNormalizer · Parses natural language dates like "last quarter"

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")

Provenance & Auditability

semantica.provenance

Every fact links to its source. Audit trails export as W3C PROV-O, in Turtle, JSON-LD, CSV, or JSON.

View documentation

Entity Provenance · track_entity(): source, page, confidence

Relationship Provenance · Source attribution on every edge in the graph

Lineage Tracing · trace_lineage(), the full ancestor chain for any entity

W3C PROV-O · Standard compliance, exportable for regulator submission

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")

Ontology & Schema Management

semantica.ontology

Auto-generate OWL ontologies from your data, validate shapes with SHACL, and manage SKOS vocabularies.

View documentation

OWL Generation · Auto-creates class hierarchies and property definitions

SHACL Shapes · Auto-generated validation that catches violations at ingest

SKOS Vocabulary · Concept management with broader, narrower, related relations

Schema Import · OWL, RDF, Turtle, JSON-LD, any existing vocabulary

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")

Enterprise Data Platforms

semantica.ingest

Pull tables straight from your lakehouse or warehouse, with lineage, instead of exporting to CSV first.

View documentation

Databricks · Unity Catalog + Delta Lake, PAT or OAuth M2M auth

Snowflake · Warehouse/database/schema, password, key-pair, or OAuth

Table & Query Ingestion · Pull whole tables or run scoped queries

Lineage Introspection · Catalog, schema, and table lineage from Unity Catalog

example.py

from semantica.ingest import DatabricksIngestor, SnowflakeIngestor

databricks = DatabricksIngestor(
    host="https://adb-xxx.azuredatabricks.net",
    token="dapi-xxxxxxxx",
    http_path="/sql/1.0/warehouses/xxxxxxxx",
    catalog="main",
)
customers = databricks.ingest_table("customers", limit=10_000)

snowflake = SnowflakeIngestor(
    account="myaccount", user="myuser", password="mypassword",
    warehouse="COMPUTE_WH", database="MYDB",
)
orders = snowflake.ingest_table("ORDERS", limit=10_000)

Every capability, fully documented

Context & Decision Intelligence

Knowledge Graph Engine

Polyglot Graph Storage

Reasoning Engines

Temporal Intelligence

Provenance & Auditability

Ontology & Schema Management

Enterprise Data Platforms