待翻譯：An open-source knowledge graph for traceable AI decisions

AI 服務暫時不可用，以下為來源正文，待恢復後補全翻譯。

Uh oh! There was an error while loading. Please reload this page. Uh oh! There was an error while loading. Please reload this page. Notifications You must be signed in to change notification settings Fork 717 Star 6.8k BranchesTags Open more actions menu Folders and files NameName Last commit message Last commit date Latest commit History 2,315 Commits 2,315 Commits .claude .claude .github .github cookbook cookbook deploy deploy docs docs examples examples explorer explorer integrations integrations mcp mcp plugins plugins semantica semantica tests tests .checkov.yaml .checkov.yaml .dockerignore .dockerignore .gitattributes .gitattributes .gitignore .gitignore .pre-commit-config.yaml .pre-commit-config.yaml ARCHITECTURE.md ARCHITECTURE.md CHANGELOG.md CHANGELOG.md CODE_OF_CONDUCT.md CODE_OF_CONDUCT.md CONTRIBUTING.md CONTRIBUTING.md CONTRIBUTORS.md CONTRIBUTORS.md Dockerfile Dockerfile LICENSE LICENSE MANIFEST.in MANIFEST.in README.md README.md RELEASE_NOTES.md RELEASE_NOTES.md SECURITY.md SECURITY.md SUPPORT.md SUPPORT.md Semantica Logo.png Semantica Logo.png docker-compose.dev.yml docker-compose.dev.yml docker-compose.yml docker-compose.yml docs_check.py docs_check.py poc_runner.py poc_runner.py pyproject.toml pyproject.toml Repository files navigation The Open Source Palantir for AI Agents Ingest your enterprise data, extract what matters, build a Context Graph and knowledge graph (KG), and run graph analytics and causal reasoning over all of it, with full decision provenance baked in. Explainable, traceable, and trustworthy by design. Decision Intelligence · Context Management · Deterministic Reasoning · Ontology Management · Knowledge Modeling · End-to-End Traceability Open Source · Self-Hostable · Auditable · Governed · Zero Vendor Lock-In Polyglot Graph Storage · RDF & LPG Support · W3C Standards · Interoperable Built for High-Stakes, Regulated Domains pip install semantica Knowledge Explorer · Context Graphs · Reasoning Engine · Decision Intelligence · Ontology Hub ▶ Watch the full platform walkthrough Most AI agents act without a trail. They store embeddings, not meaning: context that can't be explained, decisions that can't be audited. In lending, that gap is a compliance exposure, not an inconvenience: an underwriting agent's approval has to survive a regulator's "why" months later. Semantica sits underneath your LLM, vector store, and agent framework as a deterministic infrastructure layer: no LLM required for graph construction, reasoning, or provenance. Who it's for: AI/ML platform teams shipping agents that make consequential decisions and need structured, queryable context built from fragmented raw data, not just a vector index Data platform teams on Databricks or Snowflake who need to turn tables already sitting in Unity Catalog or a Snowflake warehouse into a governed, lineage-tracked knowledge graph, without exporting that data to a third-party SaaS first Compliance, risk, and audit teams who need a straight answer to "why did the AI do that?" in a format a regulator will actually accept Regulated enterprises (finance, healthcare, legal, government, defense) that can't ship a black box, and can't send their data to someone else's SaaS to get one Platform and infra engineers who want the KG, reasoning, and provenance stack self-hosted and swappable, not locked to one vendor's backend Data and knowledge engineers building a KG from messy, multi-source data: entities and relationships get extracted, conflicting or contradictory facts are flagged instead of silently overwritten, and duplicates are merged before they turn into noise Quick Start · Architecture · What You Get · Why Semantica · Decision Intelligence · Context Graphs · Recipe: Audit Trail · Module Reference · Integrations · CLI · Performance · Install What Semantica Gives You Context Graphs: A structured, queryable graph of everything your agent knows, decides, and reasons about Decision Intelligence: Every decision is a first-class object: traceable, searchable by precedent, and causally linked AI Governance & Ontology: SHACL constraints, conflict detection, compliance rules, OWL generation, and SKOS vocabulary management with a visual editor Full Auditability: W3C PROV-O provenance on every fact, with audit trails exportable to JSON, CSV, or RDF Deterministic Reasoning: Forward chaining, Rete network, Datalog, and SPARQL with fully explainable paths, not black boxes Knowledge Pipeline: Multi-source ingestion, entity-aware chunking, NER/relation/event extraction, and knowledge graph construction, with semantic deduplication and provenance-preserving merges throughout Enterprise Data Platforms: Native connectors for Databricks (Unity Catalog + Delta Lake, PAT/OAuth M2M auth, catalog/schema/table/lineage introspection) and Snowflake (warehouse/database/schema, key-pair and OAuth auth), so tables already living in your lakehouse or warehouse become graph nodes with provenance, not another export/import hop Graph Analytics: Centrality, community detection, link prediction, and shortest-path queries over the graph you just built Polyglot Graph Storage: Native RDF (embedded Oxigraph, Blazegraph, Apache Jena, Eclipse RDF4J via SPARQL) and Labeled Property Graphs (Neo4j, FalkorDB, Apache AGE, AWS Neptune via Cypher), plus vector stores, all swappable without touching your code Visualization: Explore any graph, ontology, or timeline in an interactive browser workbench Drop-in Integrations: Native Agno support, a full-featured MCP server, a comprehensive CLI, a REST API, and plugins across major editors Why Semantica Vector DB + RAG Plain LLM Memory Semantica Recall method Embedding similarity Token window Graph traversal + semantic search Decision history Not stored Not stored First-class queryable objects Provenance None None W3C PROV-O, source-linked Reasoning None Black box Forward chain, Rete, Datalog, SPARQL Conflict detection Silent overwrite Silent overwrite Detected, flagged, resolved Time travel No No Point-in-time graph snapshots Compliance export None None PROV-O, SHACL, OWL, RDF Policy enforcement None None Built-in rule engine + SHACL Entity resolution No No Blocking + semantic deduplication Multi-agent context Separate per agent Separate per agent Single shared intelligence layer Semantica complements your existing stack rather than replacing it. Keep your LLM, vector store, and agent framework exactly as they are; Semantica adds the decision records, causal reasoning, provenance, ontology governance, conflict detection, and audit trails on top. The reasoning engines, KG construction, and provenance layer are fully deterministic; no LLM is required to use them. Quick Start pip install semantica from semantica.context import ContextGraph graph = ContextGraph(advanced_analytics=True) # Every agent decision becomes a queryable, auditable knowledge node decision_id = graph.record_decision( category="vendor_selection", scenario="Choose cloud provider for HIPAA workload", reasoning="AWS offers BAA, mature HIPAA tooling, and existing team expertise", outcome="selected_aws", confidence=0.93, ) # Ask "why did this happen?" and get a real, structured answer chain = graph.trace_decision_chain(decision_id) # full causal ancestry similar = graph.find_similar_decisions("cloud vendor", max_results=5) # precedents impact = graph.analyze_decision_impact(decision_id) # downstream influence map compliant = graph.check_decision_rules({"category": "vendor_selection"}) # policy gate Verify your install in 5 seconds: semantica doctor # Python 3.11.9 pass # semantica 0.6.5 pass # faiss vector store pass # Config file pass ~/.semantica/config.yaml If Semantica solves a real problem for you, a star helps others find it. ⭐ Star on GitHub · Join Discord Architecture Semantica is a real end-to-end pipeline, not a single library with a marketing name. Every stage below is a shipping module, independently importable: Sources → Ingest → Parse → Normalize → Split → Extract → Conflict Detection → Deduplication → Knowledge Graph → [ Ontology · Reasoning · Provenance · Decisions ] → Enriched KG → Vector Store + Polyglot Graph Store (RDF & LPG) → Export / Visualize / REST · MCP · CLI Ingest: files, web, databases, enterprise data platforms (Databricks, Snowflake), cloud (Google Drive, Elasticsearch), streams (Kafka, Kinesis), Git, email, MCP Parse → Normalize → Split: document parsing, text/entity/date normalization, GraphRAG-native entity-aware chunking Extract → Conflict Detection → Deduplication: NER, relations, events, triplets; conflicting facts flagged and resolved before they merge Knowledge Graph: GraphBuilder constructs the graph; bi-temporal facts and full graph analytics (centrality, communities, link prediction) run on top of it Ontology · Reasoning · Provenance · Decisions: the intelligence layer sitting on the KG, with SHACL/OWL governance, Rete/Datalog/SPARQL inference, W3C PROV-O lineage, and first-class decision records Storage: polyglot by design, with RDF triple stores (embedded Oxigraph, Blazegraph, Apache Jena, Eclipse RDF4J), Labeled Property Graphs (Neo4j, FalkorDB, Apache AGE, AWS Neptune), and vector stores, all swappable without touching your code Outputs: export (RDF, OWL, Parquet, Cypher, JSON-LD), interactive visualization, and access via REST API, MCP server, or CLI → Full Mermaid diagrams for the pipeline and the decision intelligence lifecycle Decision Intelligence Decision Intelligence turns every AI choice from an ephemeral inference into a permanent, auditable, queryable record. It answers "what did your AI decide, why, and what happened next?": the question regulators and enterprise risk teams ask with increasing urgency. In Semantica, a decision is not a log line. It is a first-class graph node with a full lifecycle. In regulated domains, every AI decision must be traceable to a source and defensible to an auditor: record_decision() creates a permanent, structured record exportable as W3C PROV-O, the format most compliance frameworks accept for regulator submission. record_decision() → stored as a graph node with full structured context add_causal_relationship() → linked to upstream causes and downstream effects find_similar_decisions() → semantic precedent search across all past decisions trace_decision_chain() → full causal ancestry back to root causes analyze_decision_impact() → downstream influence map - everything this decision affected check_decision_rules() → policy compliance gate against configurable rule sets export / audit trail → W3C PROV-O, CSV, or JSON for regulator submission from semantica.context import ContextGraph graph = ContextGraph(advanced_analytics=True) # Record decisions with full structured context app_id = graph.record_decision( category="credit_application", scenario="Personal loan, $85k income, 31% DTI, 3yr employment", reasoning="Income meets threshold; employment stable; no adverse credit events", outcome="proceed_to_underwriting", confidence=0.88, metadata={"applicant_id": "A-7291"}, ) uw_id = graph.record_decision( category="loan_underwriting", scenario="Underwriting review for A-7291", reasoning="DTI within policy; clean 36-month credit history", outcome="approved", confidence=0.94, ) rate_id = graph.record_decision( category="interest_rate", scenario="Rate assignment for approved loan A-7291", outcome="rate_set_8.9pct", reasoning="Prime + 2.4% based on risk tier B2", confidence=0.99, ) # Build the auditable causal chain - relationship_type must be one of # CAUSED, INFLUENCED, or PRECEDENT_FOR graph.add_caus [truncated for AI cost control]