How an Open‑Source “Palantir” Lets Every AI Decision Be Audited via a Single Graph

What Semantica Claims to Be

Semantica describes itself as an "open‑source Palantir" – a decision‑analysis system used by intelligence agencies and financial firms, reimplemented in an open‑source stack. Its goal is to ingest enterprise data, construct a relationship graph, perform reasoning on that graph, and record every AI decision with an immutable audit trail.

https://github.com/semantica-agi/semantica

Project Size and Installation

The repository is MIT‑licensed, has about 4.5k stars and 2,232 commits. Install it with pip install semantica; the current release is v0.6.0. The codebase contains roughly 347 Python files (~150 k lines) and 247 test files (~74 k lines).

Core Idea #1 – From "Lookup" to "Relationship Lookup"

Traditional RAG‑style vector stores act like a filing cabinet that returns similar documents but lacks explicit relationships. Semantica builds a Context Graph where each entity (company, person, contract, event) is a node and edges encode typed relationships (e.g., "signed", "performed work") with optional timestamps ( valid_from, valid_until). This enables true relationship queries: a person three hops away from a contract can be discovered via graph traversal, something vector similarity cannot achieve. The graph also supports "time travel" with state_at("2024-01-01") to view the graph at a past date.

Core Idea #2 – Decisions Become First‑Class Nodes

Every AI decision is recorded not as a log line but as a node of type "decision" in the graph. The function record_decision() (see context_graph.py:2445) creates this node and connects it to three categories of edges: involved entities, business category, and the actor who made the decision. Additional APIs include: add_causal_relationship(): builds a causal chain such as "loan application → approval → interest rate". trace_decision_chain(): walks backward from a final decision to its root cause. find_similar_decisions(): retrieves semantically similar historical decisions. check_decision_rules(): applies compliance rules and blocks non‑conforming decisions.

These three components together form a "Decision Intelligence" layer that turns opaque AI behavior into a queryable database problem.

Core Idea #3 – An Immutable Ledger via Hash Chains

Semantica guarantees that recorded facts cannot be tampered with by chaining hashes. Each new entry reads the previous checksum, appends its own, and stores the combined hash ( ProvenanceManager._save_entry() in semantica/provenance/manager.py:149‑187). Verification is performed by verify_chain(), which detects any altered page. Deletions are not physical removals; they are marked as "revoked" (see schemas.py:146‑152), preserving evidence of existence and later cancellation. Export uses the W3C PROV‑O standard.

Deterministic Reasoning Without Large Models

Semantica includes a pure‑Python Datalog reasoner ( semantica/reasoning/datalog_reasoner.py:39) that enables "family‑tree" style inference. For example, given parent(tom, bob) and parent(bob, ann), a rule defining "ancestor" derives that Tom is Ann's great‑grandfather. The engine uses a semi‑naïve evaluation ( derive_all() in datalog_reasoner.py:242) and ships with over 40 test cases. Because it does not call any LLM, the reasoning steps are fully explainable – a valuable property for regulated environments.

Additional Engineering Features

Conflict Detection : semantica/conflicts/conflict_detector.py:95 flags contradictory statements about the same entity from different sources, defaulting to a MANUAL_REVIEW strategy.

Deduplication : semantica/deduplication/duplicate_detector.py:322 uses a union‑find structure to merge variant spellings of the same person, avoiding O(n²) scans.

Polyglot Storage and Performance

The system abstracts over eight vector stores, four graph databases, and five RDF triple stores via layered design patterns (strategy, factory, adapter, lazy‑loading proxy). Storage back‑ends are defined in vector_store/vector_store.py:112 and dispatched by graph_store to engines such as Neo4j, FalkorDB, AGE, or Neptune. A benchmark on a 118 k‑node production graph (v0.5.0) shows node search time dropping from 24 ms to 0.004 ms – roughly a 6,000× speedup.

Gaps Between Marketing and Reality

The advertised Rete inference engine is only a skeleton; key methods ( AlphaNode._matches(), BetaNode._can_join()) always return true, so only the Datalog reasoner is functional. SemanticaWorker in worker.py loops on time.sleep(5) without a real task queue, and the code comments acknowledge it is "to be implemented".

The /build server endpoint merely returns "accepted" without executing any build logic.

Although the default entity extractor ( ner_method="llm") calls a large model, it can be switched to pattern‑based or spaCy‑based methods to achieve a truly LLM‑free pipeline.

Who Should (or Should Not) Use Semantica

Suitable for : regulated sectors such as finance, healthcare, law, and government; platform teams treating AI decisions as products; teams already using Databricks or Snowflake that want lineage graphs; engineers who want to plug in Claude Code, Cursor, or Codex via provided extensions.

Not suitable for : lightweight chatbot or simple vector‑search use cases; teams expecting an out‑of‑the‑box end‑to‑end solution, since components like Rete, worker, and some server endpoints remain incomplete in v0.6.0.

Final Takeaways

Semantica successfully translates the slogan "AI must be responsible" into four concrete engineering actions: graph construction, decision bookkeeping, immutable traceability, and deterministic reasoning. The hash‑chain ledger and Datalog reasoner are solid, while the unfinished Rete engine and worker serve as reminders that a polished README does not guarantee production‑ready modules. Prospective adopters should spend a few minutes reviewing the source code before committing.