### Graph-Native Infrastructure for Context and Accountable AI Systems #### *Developer-first, knowledge infrastructure for AI, alternative to expensive enterprise platforms.* > 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. **Context Management · Knowledge Modeling · Deterministic Reasoning · Ontology Management · Decision Intelligence · End-to-End Traceability** **Open Source · Governed · Zero Vendor Lock-In** **Polyglot Graph Storage · RDF & LPG Support · W3C Standards · Interoperable** #### Built for High-Stakes, Regulated Domains [![GitHub Stars](https://img.shields.io/github/stars/semantica-agi/semantica?style=flat-square&color=FFD700&logo=github&logoColor=white&label=Stars)](https://github.com/semantica-agi/semantica) [![GitHub Forks](https://img.shields.io/github/forks/semantica-agi/semantica?style=flat-square&color=6E40C9&logo=github&logoColor=white&label=Forks)](https://github.com/semantica-agi/semantica/network/members) [![Contributors](https://img.shields.io/github/contributors/semantica-agi/semantica?style=flat-square&color=2EA043&logo=github&logoColor=white)](https://github.com/semantica-agi/semantica/graphs/contributors) [![PyPI](https://img.shields.io/pypi/v/semantica.svg?style=flat-square&color=0066CC&logo=pypi&logoColor=white)](https://pypi.org/project/semantica/) [![Total Downloads](https://static.pepy.tech/badge/semantica?style=flat-square)](https://pepy.tech/project/semantica) [![Python 3.8+](https://img.shields.io/badge/python-3.8+-3776AB?style=flat-square&logo=python&logoColor=white)](https://www.python.org/) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT) [![CI](https://img.shields.io/github/actions/workflow/status/semantica-agi/semantica/ci.yml?style=flat-square&label=CI)](https://github.com/semantica-agi/semantica/actions) [![Install Matrix](https://img.shields.io/github/actions/workflow/status/semantica-agi/semantica/install-matrix.yml?style=flat-square&label=pip%20install)](https://github.com/semantica-agi/semantica/actions/workflows/install-matrix.yml) [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/semantica-agi/semantica/badge?style=flat-square)](https://scorecard.dev/viewer/?uri=github.com/semantica-agi/semantica) [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/semantica-agi/semantica) ```bash pip install semantica ```

---

Semantica Knowledge Explorer: live graph, decisions, entity resolution, ontology hub

*Knowledge Explorer · Context Graphs · Reasoning Engine · Decision Intelligence · Ontology Hub* **[▶ Watch the full platform walkthrough](https://www.youtube.com/watch?v=QfnNZg4-dZA)**

--- Most AI agents run on embeddings, not meaning: similarity scores with no structure, no relationships, and no way to explain why a result came back. Semantica is the semantic/context layer underneath your LLM, vector store, and agent framework: a deterministic infrastructure layer (no LLM required for graph construction, reasoning, or provenance) that turns fragmented enterprise data into a structured, queryable Context Graph and knowledge graph, governed by ontologies and controlled vocabularies (OWL, SHACL, SKOS) so the meaning of your data is explicit, not just its embedding. Decision provenance and audit trails fall out of that structure as a property, not the product itself; in domains a regulator can question, that same structure just happens to double as a straight answer to "why." > ⚠️ **System-level explainability, not foundation-model explainability.** Semantica does not expose or reconstruct what happens *inside* the LLM — its internal reasoning or chain-of-thought stays opaque, as it does for any external system. Semantica explains what's *outside* the model: the context and data fed in, the decision produced, its provenance, relevant relationships, applied policies, and the full execution trail. **Who it's for:** - **AI/ML platform teams** shipping agents that make consequential decisions and need structured, queryable context, not just a vector index - **Data platform teams on Databricks or Snowflake** turning tables already in Unity Catalog or a warehouse into a governed, lineage-tracked knowledge graph, without exporting to a third-party SaaS - **Compliance, risk, and audit teams** who need a straight answer to "why did the AI do that?" in a format a regulator accepts - **Regulated enterprises** (finance, healthcare, legal, government, defense) that can't ship a black box or 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, where conflicting facts get flagged and duplicates get merged, not silently overwritten **[Quick Start](#quick-start)** · **[Architecture](#architecture)** · **[What You Get](#what-semantica-gives-you)** · **[Why Semantica](#why-semantica)** · **[Decision Intelligence](#decision-intelligence)** · **[Context Graphs](#context-graphs)** · **[Recipe: Audit Trail](#recipe-audit-trail-for-a-regulated-decision)** · **[Module Reference](#module-reference)** · **[Integrations](#integrations)** · **[CLI](#cli)** · **[Performance](#performance)** · **[Install](#installation)** --- ## 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), Snowflake (warehouse/database/schema, key-pair and OAuth auth), and SAP OData (Business Partners, Sales Orders, OAuth2/Basic auth), so data already living in your lakehouse or warehouse becomes 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, CrewAI, and LangChain 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 ```bash pip install semantica ``` ```python 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:** ```bash semantica doctor ``` **Running in a script or CI?** Progress bars are written only when stdout is an interactive terminal (or a Jupyter notebook), so piping and redirecting stay clean by default. Override with `SEMANTICA_DISABLE_PROGRESS=1` to silence progress everywhere, or `SEMANTICA_FORCE_PROGRESS=1` to keep it when stdout is redirected. `SEMANTICA_DISABLE_PROGRESS` takes precedence.

If Semantica solves a real problem for you, a star helps others find it. **[⭐ Star on GitHub](https://github.com/semantica-agi/semantica)** · **[Join Discord](https://discord.gg/sV34vps5hH)**

--- ## 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, SAP), 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](ARCHITECTURE.md)** --- ## 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 ``` ```python 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_causal_relationship(app_id, uw_id, relationship_type="CAUSED") graph.add_causal_relationship(uw_id, rate_id, relationship_type="INFLUENCED") # Query the intelligence chain = graph.trace_decision_chain(rate_id) similar = graph.find_similar_decisions("personal loan approval, 31% DTI", max_results=5) impact = graph.analyze_decision_impact(uw_id) compliant = graph.check_decision_rules({"category": "loan_underwriting", "confidence": 0.94}) insights = graph.get_decision_insights() ``` --- ## Context Graphs A Context Graph is the structured memory layer that traditional RAG is missing. Instead of flat embeddings that answer *"what is similar?"*, a Context Graph answers *"what is connected, why, and how?"* Every entity, relationship, decision, and fact is a first-class node, queryable by graph traversal. Entities link to source documents, decisions link to evidence and consequences, facts carry full provenance, and conflicts are detected, not silently overwritten. ```python from semantica.context import ContextGraph, AgentContext from semantica.vector_store import VectorStore graph = ContextGraph(advanced_analytics=True) # Add nodes with typed properties graph.add_node("acme_corp", "Organization", name="Acme Corp", industry="SaaS") graph.add_node("alice_chen", "Person", name="Alice Chen", role="CTO") graph.add_node("contract_001", "Contract", value=2_400_000, currency="USD") # Add typed, weighted edges (extra kwargs become edge metadata) graph.add_edge("alice_chen", "acme_corp", edge_type="works_for", since="2019-03-01") graph.add_edge("acme_corp", "contract_001", edge_type="party_to", signed="2024-01-15") # BFS traversal - hop through the graph from any node neighbors = graph.get_neighbors("acme_corp", hops=2) # Point-in-time snapshot - the graph as it existed on any past date snapshot = graph.state_at("2024-01-01") # AgentContext - high-level API for agent memory workflows vs = VectorStore(backend="faiss") ctx = AgentContext(vector_store=vs, knowledge_graph=graph) ctx.store("Alice approved the Acme renewal in Q1 2024", conversation_id="conv_001") retrieved = ctx.retrieve("who approved the Acme contract?") ``` **Why graph over embeddings:** traversal finds connections embeddings miss (a person 3 hops from a contract); every node carries provenance so you can always ask *"where did this come from?"*; conflicts are flagged before they corrupt your knowledge base; point-in-time snapshots let you replay history without reprocessing. --- ## Recipe: Audit Trail for a Regulated Decision One pattern built on the same Context Graph: record a causally-linked decision chain, attach provenance to every entity, and export a regulator-ready audit trail. ```python from semantica.context import ContextGraph from semantica.provenance import ProvenanceManager from semantica.export import RDFExporter graph = ContextGraph(advanced_analytics=True) prov = ProvenanceManager(storage_path="./audit.db") # Record the decision chain d1 = graph.record_decision( category="drug_interaction_check", scenario="Patient P-4821: warfarin + amiodarone co-prescribed", reasoning="Amiodarone potentiates warfarin's anticoagulant effect", outcome="flag_for_review", confidence=0.91, ) d2 = graph.record_decision( category="dosage_adjustment", scenario="INR monitoring plan for P-4821", reasoning="Reduce warfarin dose per interaction severity; recheck INR in 5 days", outcome="dose_reduced_30pct", confidence=0.87, ) # relationship_type must be one of CAUSED, INFLUENCED, or PRECEDENT_FOR graph.add_causal_relationship(d1, d2, relationship_type="CAUSED") # Track provenance for every entity prov.track_entity("patient_P4821", source="ehr/medication_orders_2024.json", metadata={"extractor": "NamedEntityRecognizer"}) # Export W3C PROV-O for regulator submission - to_kg_dict() is the official # adapter that emits the {"entities": [...], "relationships": [...]} / # source_id shape RDFExporter expects, so no manual field mapping is needed kg = graph.to_kg_dict() RDFExporter().export(kg, "audit_trail.ttl", format="turtle") ``` More recipes (GraphRAG pipelines, an AML rules engine, ontology-to-KG in one pass) are in **[More Recipes](#more-recipes)** below. --- ## Explore the Platform Every module below is independently importable, with working code samples verified against the current source tree; use one or all of them. | Module | What it does | | --- | --- | | [`semantica.ingest`](#semanticaingest-multi-source-ingestion) | Files, web, databases, APIs, streams, email, Git, Parquet, Databricks, Snowflake, SAP, MCP | | [`semantica.semantic_extract`](#semanticasemantic_extract-ner-relations-events-triplets) | NER, relation extraction, event detection, triplet generation | | [`semantica.kg`](#semanticakg-knowledge-graph-construction--analysis) | Graph construction, centrality, communities, link prediction | | [`semantica.reasoning`](#semanticareasoning-forward-chaining-rete-datalog-sparql) | Forward chaining, Rete, Datalog, SPARQL, fully explainable | | [`semantica.vector_store`](#semanticavector_store-hybrid--filtered-semantic-search) | FAISS, Qdrant, Weaviate, Milvus, Pinecone, PgVector, hybrid search | | [`semantica.split`](#semanticasplit-graphrag-native-document-chunking) | Entity-aware, relation-aware, ontology-aware chunking for GraphRAG | | [`semantica.provenance`](#semanticaprovenance-w3c-prov-o-lineage) | W3C PROV-O lineage on every fact | | [`semantica.ontology`](#semanticaontology-owl-generation-shacl-validation) | OWL generation, SHACL validation, SKOS vocabularies | | [`semantica.conflicts`](#semanticaconflicts-conflict-detection--resolution) | Detect and resolve conflicting facts across sources | | [`semantica.deduplication`](#semanticadeduplication-entity-resolution-at-scale) | Entity resolution at scale | | [`semantica.normalize`](#semanticanormalize-data-normalization--cleaning) | Text, entity, date, and number normalization; dataset cleaning | | [`semantica.pipeline`](#semanticapipeline-pipeline-dsl) | Declarative, parallel pipeline DSL for ingest → extract → build → export | | [`semantica.export`](#semanticaexport-rdf-owl-parquet-cypher-json-ld) | RDF, OWL, Parquet, Cypher, JSON-LD | | [`semantica.visualization`](#semanticavisualization-interactive-graph-workbench) | Force-directed graphs, ontology hierarchies, temporal dashboards | | [Temporal Intelligence](#temporal-intelligence-bi-temporal-graphs--time-travel) | Bi-temporal facts, Allen interval algebra, time travel | | [Multi-Agent (Agno)](#multi-agent-shared-context-with-agno) | One shared context graph across every agent on a team | **↓ Expand [Module Reference](#module-reference) below** for every module's working example, or jump to [More Recipes](#more-recipes), the full [Integrations](#integrations) matrix, [MCP tool list](#mcp-server), and [REST endpoints](#rest-api). --- ## Module Reference Expand any module below for its runnable example.

semantica.ingest: Multi-Source Ingestion

Ingest from files, web, databases, APIs, streams, email, Git repos, Parquet, Databricks, Snowflake, SAP, or MCP servers, all through a unified interface. ```python from semantica.ingest import FileIngestor, WebIngestor, ParquetIngestor, DBIngestor # Ingest an entire directory of contracts (PDF, DOCX, HTML, TXT) docs = FileIngestor().ingest_directory("./contracts/", recursive=True) # Ingest live web content with robots.txt compliance pages = WebIngestor().ingest_url("https://example.com/reports/annual-2024.html") # Ingest structured data from Parquet with Snappy compression records = ParquetIngestor().ingest("./data/transactions.parquet") # Ingest from a SQL database - specify which tables to pull rows = DBIngestor().ingest_database( connection_string="postgresql://user:pass@localhost/mydb", include_tables=["customer_events"], max_rows_per_table=50_000, ) ``` ```python # Enterprise data platforms - pull tables straight out of your lakehouse # or warehouse, with lineage, instead of exporting to CSV first from semantica.ingest import DatabricksIngestor, SnowflakeIngestor # pip install "semantica[db-databricks]" databricks = DatabricksIngestor( host="https://adb-xxx.azuredatabricks.net", token="dapi-xxxxxxxx", # or client_id/client_secret for OAuth M2M http_path="/sql/1.0/warehouses/xxxxxxxx", catalog="main", ) customers = databricks.ingest_table("customers", limit=10_000) sales = databricks.ingest_query("SELECT * FROM sales WHERE region = 'EMEA'") table_lineage = databricks.get_table_lineage("customers", catalog="main", schema="default") # Unity Catalog lineage # pip install semantica[db-snowflake] snowflake = SnowflakeIngestor( account="myaccount", user="myuser", password="mypassword", # or private_key=... for key-pair; use authenticator="oauth", token=... for OAuth warehouse="COMPUTE_WH", database="MYDB", ) orders = snowflake.ingest_table("ORDERS", limit=10_000) ``` > **Security Note:** Never hardcode credentials (`token`, `password`, `private_key`) in production code; pass them via environment variables (e.g., `DATABRICKS_TOKEN`, `SNOWFLAKE_PASSWORD`) or a secrets manager. **Supported sources:** Local files (PDF, DOCX, PPTX, HTML, TXT, CSV, JSON, YAML, Excel, XML) · Web pages · RSS/Atom feeds · REST APIs · Databases (PostgreSQL, MySQL, SQLite, Oracle, SQL Server) · Parquet datasets · Databricks (Unity Catalog + Delta Lake) · Snowflake · SAP (OData v2/v4) · Git repositories · Email (IMAP/POP3) · Message streams (Kafka, RabbitMQ, Kinesis, Pulsar) · MCP resources · Apache Arrow/Feather/IPC (`ArrowIngestor`) DuckDB, Elasticsearch, Google Drive, HuggingFace, MongoDB, and Pandas ingestion also ship (`DuckDBIngestor`, `ElasticIngestor`, `GDriveIngestor`, `HuggingFaceIngestor`, `MongoIngestor`, `PandasIngestor`) but aren't re-exported from the top-level `semantica.ingest` namespace yet — import them directly: `from semantica.ingest.duckdb_ingestor import DuckDBIngestor`.

semantica.semantic_extract: NER, Relations, Events, Triplets

Extract structured knowledge from raw text in one pass. ```python from semantica.semantic_extract import ( NamedEntityRecognizer, RelationExtractor, EventDetector, TripletExtractor, ) text = """ Anthropic CEO Dario Amodei announced a $7.3B Series E funding round in partnership with Google and Spark Capital, valuing the company at $61.5B as of Q4 2024. """ # Named entity recognition with confidence thresholding ner = NamedEntityRecognizer(confidence_threshold=0.7) entities = ner.extract_entities(text) # → [Entity(name="Dario Amodei", type="PERSON"), Entity(name="Anthropic", type="ORG"), # Entity(name="Google", type="ORG"), Entity(name="$7.3B", type="MONEY"), ...] # Relationship extraction - bidirectional support rel_extractor = RelationExtractor(confidence_threshold=0.6, bidirectional=True) relations = rel_extractor.extract_relations(text, entities=entities) # → [Relation(subject="Dario Amodei", predicate="ceo_of", object="Anthropic"), # Relation(subject="Anthropic", predicate="raised", object="$7.3B Series E"), ...] # Event detection with temporal processing events = EventDetector(extract_participants=True, extract_time=True).detect_events(text) # → [Event(type="FUNDING", participants=["Anthropic","Google","Spark Capital"], # amount="$7.3B", date="Q4 2024")] # RDF triplets with optional provenance metadata triplets = TripletExtractor(include_temporal=True, include_provenance=True).extract_triplets(text) # → [("Anthropic", "valuation", "$61.5B"), ("Dario Amodei", "is_ceo_of", "Anthropic"), ...] ``` Batch processing across many documents uses `ner.process_batch([...])`, not a per-call `extract_entities_batch` on the facade class.

semantica.kg: Knowledge Graph Construction & Analysis

Build a production knowledge graph from documents and run graph algorithms over it. ```python from semantica.ingest import FileIngestor from semantica.kg import ( GraphBuilder, GraphAnalyzer, CentralityCalculator, CommunityDetector, PathFinder, LinkPredictor, BiTemporalFact, ) from datetime import datetime # Build KG - merge duplicate entities, track temporal edges sources = FileIngestor().ingest_directory("./contracts/", recursive=True) kg = GraphBuilder(merge_entities=True, enable_temporal=True).build(sources) # Graph analytics analyzer = GraphAnalyzer() analysis = analyzer.analyze_graph(kg) # full graph metrics centrality = CentralityCalculator() degree = centrality.calculate_degree_centrality(kg) # most-connected entities betweenness = centrality.calculate_betweenness_centrality(kg) communities = CommunityDetector().detect_communities(kg, method="louvain") # natural clusters path = PathFinder().find_shortest_path(kg, "alice_chen", "contract_001") predictions = LinkPredictor().predict_links(kg, top_k=10) # relationship predictions # Bi-temporal facts - track valid time vs. recorded time independently fact = BiTemporalFact( valid_from=datetime(2024, 3, 1), valid_until=datetime(2025, 1, 1), recorded_at=datetime(2024, 3, 5), ) ```

semantica.reasoning: Forward Chaining, Rete, Datalog, SPARQL

Run explainable rule-based inference, not a black box. ```python from semantica.reasoning import ReteEngine, Rule, Fact, RuleType rete = ReteEngine() rete.build_network([ Rule( rule_id="aml_flag", name="Flag high-risk transactions", conditions=[ {"field": "amount", "operator": ">", "value": 10_000}, {"field": "country", "operator": "in", "value": ["IR", "KP", "SY"]}, ], conclusion="flag_for_compliance_review", rule_type=RuleType.IMPLICATION, ), Rule( rule_id="velocity_check", name="Flag rapid sequential transfers", conditions=[ {"field": "transfers_in_1h", "operator": ">", "value": 5}, {"field": "total_amount", "operator": ">", "value": 50_000}, ], conclusion="flag_velocity_breach", rule_type=RuleType.IMPLICATION, ), ]) rete.add_fact(Fact("tx_001", "transaction", [{"amount": 15_000, "country": "IR"}])) flagged = rete.match_patterns() # → [{"rule": "aml_flag", "matched_facts": ["tx_001"], "conclusion": "flag_for_compliance_review"}] ``` > **Current limitation:** `ReteEngine`'s alpha-node condition matcher is intentionally simple in this release — validate `match_patterns()` output against your actual rule set before wiring it into a production compliance gate; more selective condition evaluation is on the roadmap. ```python # Recursive Datalog - natural language for graph queries from semantica.reasoning import DatalogReasoner engine = DatalogReasoner() engine.add_fact("parent(tom, bob)") engine.add_fact("parent(bob, ann)") engine.add_fact("parent(ann, pat)") engine.add_rule("ancestor(X, Y) :- parent(X, Y).") engine.add_rule("ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z).") ancestors = engine.query("ancestor(tom, ?X)") # → [{"X": "bob"}, {"X": "ann"}, {"X": "pat"}] ``` ```python # Explainable reasoning - trace the path, not just the answer from semantica.reasoning import ExplanationGenerator, Reasoner reasoner = Reasoner() reasoner.add_fact("parent(tom, bob)") reasoner.add_rule("ancestor(X, Y) :- parent(X, Y)") result = reasoner.forward_chain() explainer = ExplanationGenerator() explanation = explainer.generate_explanation(result) # → Explanation(conclusion="...", steps=[ReasoningStep(...)], justification=Justification(...)) ```

semantica.vector_store: Hybrid & Filtered Semantic Search

Drop-in vector store with multiple backends, hybrid search, and decision-aware retrieval. ```python from semantica.vector_store import VectorStore, HybridSearch # In-memory backend shown here: HybridSearch and explain_decision() work out of the box. # Swap backend="qdrant" / "weaviate" / "milvus" / "pinecone" / "pgvector" / "faiss" once you # scale past a single process — search() and store_decision() work identically on all of them. vs = VectorStore(backend="inmemory", dimension=1536) # Store a decision with scenario description and outcome vs.store_decision( scenario="Personal loan A-7291, $85k income, 31% DTI, 3yr employment", outcome="approved", confidence=0.94, category="loan_underwriting", ) # Semantic similarity search results = vs.search( query="personal loan approval with low DTI", limit=10, ) # Hybrid search - dense + sparse retrieval in one pass with RRF fusion hs = HybridSearch(vector_store=vs) hits = hs.search("high-risk transactions 2024") # Explain why a decision was retrieved explanation = vs.explain_decision(results[0]["id"]) ``` **Backends:** `faiss` · `qdrant` · `weaviate` · `milvus` · `pinecone` · `pgvector` · `sqlite` · `inmemory`

semantica.split: GraphRAG-Native Document Chunking

KG-aware splitting that preserves entity boundaries, relation triplets, and ontology concepts, essential for GraphRAG pipelines. ```python from semantica.split import TextSplitter, EntityAwareChunker, RelationAwareChunker text = open("contracts/master_agreement.txt").read() # Standard recursive chunking chunks = TextSplitter(method="recursive", chunk_size=1000, chunk_overlap=200).split(text) # Entity-aware chunking - never splits a named entity across chunks (GraphRAG) chunks = TextSplitter(method="entity_aware", ner_method="llm", chunk_size=1000).split(text) # Relation-aware chunking - preserves (subject, predicate, object) triplets intact chunks = RelationAwareChunker(chunk_size=1000, preserve_triplets=True).chunk(text) # Graph-based chunking - uses centrality to find natural community boundaries chunks = TextSplitter(method="graph_based", chunk_size=1000).split(text) # Hierarchical chunking - multi-level (section → paragraph → sentence) chunks = TextSplitter(method="hierarchical", levels=["section", "paragraph"]).split(text) ``` **Supported methods:** `recursive` · `token` · `sentence` · `paragraph` · `semantic_transformer` · `entity_aware` · `relation_aware` · `graph_based` · `ontology_aware` · `hierarchical` · `community_detection` · `centrality_based` · `llm`

semantica.provenance: W3C PROV-O Lineage

Every fact is linked to its source. No black boxes, no mystery outputs. ```python from semantica.provenance import ProvenanceManager prov = ProvenanceManager(storage_path="./provenance.db") # Track where every entity came from prov.track_entity( entity_id="acme_corp", source="contracts/acme_master_agreement_2024.pdf", metadata={"page": 1, "confidence": 0.97, "extractor": "NamedEntityRecognizer"}, ) # Track a relationship's provenance - entity linkage travels in metadata prov.track_relationship( relationship_id="alice_works_for_acme", source="hr_records/employees_q1_2024.csv", metadata={"source_entity_id": "alice_chen", "target_entity_id": "acme_corp"}, ) # Answer "where did this come from?" lineage = prov.get_lineage("acme_corp") trail = prov.trace_lineage("alice_chen") # full ancestor chain entry = prov.get_provenance("acme_corp") ```

semantica.ontology: OWL Generation, SHACL Validation

Generate ontologies from data, validate shapes, and manage your vocabulary. ```python from semantica.ontology import OntologyGenerator, OntologyValidator data = { "entities": [ {"id": "acme_corp", "type": "Organization", "industry": "SaaS", "founded": 2012}, {"id": "alice_chen", "type": "Person", "role": "CTO", "since": 2019}, ], "relationships": [ {"source": "alice_chen", "target": "acme_corp", "type": "works_for"}, ], } gen = OntologyGenerator(base_uri="https://semantica.dev/ontology/") ontology = gen.generate_ontology(data) classes = gen.infer_classes(data) props = gen.infer_properties(data, classes) optimized = gen.optimize_ontology(ontology) # Validate against SHACL shapes validator = OntologyValidator() report = validator.validate(ontology) # → ValidationResult(valid=True, consistent=True, satisfiable=True, errors=[], warnings=[]) ```

semantica.conflicts: Conflict Detection & Resolution

Detect and resolve conflicting facts from multiple sources before they corrupt your knowledge base. ```python from semantica.conflicts import ConflictDetector, ConflictResolver, SourceTracker entities_from_source_a = [ {"id": "alice_chen", "role": "CTO", "salary": 250_000, "start_date": "2019-03-01"}, ] entities_from_source_b = [ {"id": "alice_chen", "role": "VP Eng", "salary": 275_000, "start_date": "2019-03-01"}, ] # Detect all conflict types: value, type, relationship, temporal, logical detector = ConflictDetector() conflicts = detector.detect_conflicts(entities_from_source_a + entities_from_source_b) # → [Conflict(entity="alice_chen", field="role", values=["CTO","VP Eng"], severity="HIGH"), # Conflict(entity="alice_chen", field="salary", values=[250000,275000], severity="MEDIUM")] # Resolve using multiple strategies resolver = ConflictResolver() resolved = resolver.resolve_conflicts(conflicts, strategy="credibility_weighted") # weighted by source trust resolved = resolver.resolve_conflicts(conflicts, strategy="most_recent") # prefer most recent resolved = resolver.resolve_conflicts(conflicts, strategy="voting") # majority wins # Track source credibility over time tracker = SourceTracker() tracker.register_source("source_a", source_type="document", credibility_score=0.85) tracker.register_source("source_b", source_type="document", credibility_score=0.72) ```

semantica.deduplication: Entity Resolution at Scale

Block, cluster, and merge duplicates with semantic similarity. ```python from semantica.deduplication import DuplicateDetector, EntityMerger entities = [ {"id": "e1", "name": "Acme Corporation", "domain": "acme.com"}, {"id": "e2", "name": "Acme Corp.", "domain": "acme.com"}, {"id": "e3", "name": "ACME Corp", "domain": "acme.co"}, {"id": "e4", "name": "Globex Industries", "domain": "globex.com"}, ] detector = DuplicateDetector(similarity_threshold=0.75, use_clustering=True) candidates = detector.detect_duplicates(entities) groups = detector.detect_duplicate_groups(entities) # → DuplicateGroup(entities=["e1","e2","e3"], confidence=0.91, strategy="semantic+blocking") merger = EntityMerger(preserve_provenance=True) ops = merger.merge_duplicates(entities, strategy="keep_most_complete") history = merger.get_merge_history() ```

semantica.normalize: Data Normalization & Cleaning

Standardize text, entities, dates, numbers, and encodings before building your knowledge graph. ```python from semantica.normalize import ( TextNormalizer, EntityNormalizer, DateNormalizer, NumberNormalizer, DataCleaner, ) # Unicode, whitespace, casing, HTML tags, smart quotes text = TextNormalizer().normalize(" Acme Corp.'s Q4 report... ") # → "Acme Corp.'s Q4 report..." # Alias resolution + entity disambiguation with confidence scores canonical = EntityNormalizer().normalize_entity("ACME Corp.") # → NormalizedEntity(canonical="Acme Corporation", type="Organization", confidence=0.91) # Natural language date parsing with timezone conversion dt = DateNormalizer().normalize_date("3 weeks ago") # → datetime(2026, 7, 1, tzinfo=UTC) # Unit conversion and currency normalization price = NumberNormalizer().normalize_number("$1.25M USD") # → NormalizedNumber(value=1_250_000, currency="USD") # Deduplicate, validate, and impute missing values across a dataset clean = DataCleaner().clean_data(records, remove_duplicates=True, handle_missing=True) ```

semantica.pipeline: Pipeline DSL

Compose ingestion, extraction, and graph-building into a declarative, parallel pipeline. ```python from semantica.pipeline import PipelineBuilder, ExecutionEngine builder = PipelineBuilder() # add_step() returns the created PipelineStep, not the builder, so these don't chain builder.add_step("ingest", step_type="ingest", source="./contracts/", recursive=True) builder.add_step("extract", step_type="ner_extract") builder.add_step("relations", step_type="relation_extract") builder.add_step("build_kg", step_type="kg_build", merge_entities=True) builder.add_step("deduplicate", step_type="deduplicate", threshold=0.75) builder.add_step("export", step_type="export", format="turtle", output="kg.ttl") # connect_steps() and set_parallelism() return the builder, so these do chain pipeline = ( builder .connect_steps("ingest", "extract") .connect_steps("extract", "relations") .connect_steps("relations", "build_kg") .connect_steps("build_kg", "deduplicate") .connect_steps("deduplicate", "export") .set_parallelism(4) .build(name="contracts_pipeline") ) engine = ExecutionEngine() result = engine.execute_pipeline(pipeline) status = engine.get_pipeline_status(pipeline.name) progress = engine.get_progress(pipeline.name) ```

Temporal Intelligence: Bi-Temporal Graphs & Time Travel

Track when facts were true *in the world* vs. when they were *recorded*, and query either axis. ```python from semantica.context import ContextGraph from semantica.kg import ( BiTemporalFact, TemporalGraphQuery, TemporalNormalizer, ) from datetime import datetime graph = ContextGraph(advanced_analytics=True) graph.add_node("alice_chen", "Person", role="VP Engineering") graph.add_node("acme_corp", "Organization", valuation=1_200_000_000) # A temporally-bounded edge - valid_from/valid_until define when it held true graph.add_edge( "alice_chen", "acme_corp", edge_type="works_for", valid_from="2024-03-01T00:00:00", valid_until="2025-01-01T00:00:00", ) # Point-in-time snapshots - replay history without reprocessing snapshot_2023 = graph.state_at("2023-06-01") snapshot_2024 = graph.state_at("2024-01-01") # Bi-temporal facts - valid_time is when true in the world; # recorded_at is when you learned about it fact = BiTemporalFact( valid_from=datetime(2024, 3, 1), valid_until=datetime(2025, 1, 1), recorded_at=datetime(2024, 3, 5), ) # Query facts valid within a time window - to_kg_dict() is the official # adapter that emits {"entities", "relationships"} with source_id/target_id # keys, the shape query_time_range() expects (no manual mapping required) kg = graph.to_kg_dict() tq = TemporalGraphQuery() facts_in_window = tq.query_time_range( kg, query="valid_facts", start_time="2024-01-01", end_time="2024-12-31" ) # Normalize natural language temporal expressions - returns a (start, end) range norm = TemporalNormalizer() start, end = norm.normalize("last quarter") ```

semantica.export: RDF, OWL, Parquet, Cypher, JSON-LD

Export to any format required by regulators, graph databases, or downstream systems. ```python from semantica.export import ( RDFExporter, JSONExporter, ParquetExporter, LPGExporter, ReportGenerator, ) kg = {"entities": [...], "relationships": [...]} rdf = RDFExporter() turtle_str = rdf.export_to_rdf(kg, format="turtle") # returns string jsonld_str = rdf.export_to_rdf(kg, format="json-ld") rdf.export(kg, "kg_audit.ttl", format="turtle") rdf.export(kg, "kg_audit.jsonld", format="json-ld") rdf.export(kg, "kg_audit.nt", format="n-triples") # Columnar analytics - Snappy-compressed Parquet (writes kg_snapshot_entities.parquet # and kg_snapshot_relationships.parquet) ParquetExporter(compression="snappy").export_knowledge_graph(kg, "kg_snapshot") # JSON knowledge graph JSONExporter().export_knowledge_graph(kg, "kg.json") # Neo4j / Memgraph Cypher statements for graph database import LPGExporter().export(kg, "kg_import.cypher") # Human-readable HTML report ReportGenerator().generate_report( {"title": "KG Audit Report", "summary": "Weekly ingestion summary", "metrics": {"entities": len(kg["entities"])}}, file_path="audit_report.html", format="html", ) ```

semantica.visualization: Interactive Graph Workbench

Render force-directed graphs, community maps, ontology hierarchies, and temporal dashboards. ```python from semantica.visualization import ( KGVisualizer, OntologyVisualizer, EmbeddingVisualizer, TemporalVisualizer, ) import numpy as np kg = {"entities": [...], "relationships": [...]} # Interactive force-directed graph (opens in browser) viz = KGVisualizer(layout="force", color_scheme="default") viz.visualize_network(kg, output="interactive", file_path="kg.html") viz.visualize_communities(kg, communities, output="interactive") viz.visualize_centrality(kg, centrality, centrality_type="degree") viz.visualize_entity_types(kg, output="html", file_path="entity_types.html") # Ontology class hierarchy OntologyVisualizer().visualize_hierarchy(ontology, output="interactive") # 2D embedding projection (UMAP / t-SNE / PCA) EmbeddingVisualizer().visualize_2d_projection( embeddings=np.array([...]), labels=["entity_a", "entity_b"], method="umap", ) # Timeline scrubber - watch the graph evolve TemporalVisualizer().visualize_timeline(kg, output="interactive") ```

Multi-Agent Shared Context with Agno

One shared intelligence layer. All agents read and write to the same context graph. ```python # pip install semantica[agno] from agno.agent import Agent from agno.team import Team from agno.models.anthropic import Claude from semantica.context import ContextGraph from semantica.vector_store import VectorStore from integrations.agno import AgnoSharedContext, AgnoDecisionKit, AgnoKGToolkit shared = AgnoSharedContext( vector_store=VectorStore(backend="faiss"), knowledge_graph=ContextGraph(advanced_analytics=True), decision_tracking=True, ) researcher = Agent( name="Researcher", model=Claude(id="claude-sonnet-4-5"), memory=shared.bind_agent("researcher"), tools=[AgnoKGToolkit(context=shared)], ) analyst = Agent( name="Analyst", model=Claude(id="claude-sonnet-4-5"), memory=shared.bind_agent("analyst"), tools=[AgnoDecisionKit(context=shared)], ) team = Team(agents=[researcher, analyst], mode="coordinate") # Researcher's findings are instantly available to the Analyst - no copy, no sync ``` → [runnable notebooks in the cookbook](https://github.com/semantica-agi/semantica/tree/main/cookbook), each self-contained and runnable in under 5 minutes

--- ## More Recipes The audit-trail recipe is [above](#recipe-audit-trail-for-a-regulated-decision). Here are three more common patterns.

End-to-End GraphRAG Pipeline

```python from semantica.ingest import FileIngestor from semantica.split import TextSplitter from semantica.semantic_extract import NamedEntityRecognizer, RelationExtractor from semantica.kg import GraphBuilder from semantica.vector_store import VectorStore, HybridSearch from semantica.context import AgentContext # 1. Ingest docs = FileIngestor().ingest_directory("./docs/", recursive=True) # 2. Entity-aware chunking - never splits an entity across a chunk boundary splitter = TextSplitter(method="entity_aware", chunk_size=1000) chunks = [splitter.split(doc["text"]) for doc in docs] # 3. Extract entities and relations ner = NamedEntityRecognizer(confidence_threshold=0.7) rel_ext = RelationExtractor(confidence_threshold=0.6) entities = [ner.extract_entities(chunk) for chunk_group in chunks for chunk in chunk_group] # 4. Build KG kg = GraphBuilder(merge_entities=True, enable_temporal=True).build(docs) # 5. Hybrid retrieval vs = VectorStore(backend="inmemory") ctx = AgentContext(vector_store=vs, knowledge_graph=kg) ctx.store("Alice approved the Acme renewal in Q1 2024", conversation_id="c1") results = HybridSearch(vector_store=vs).search("who approved the renewal?") ```

AML Rules Engine

```python from semantica.reasoning import ReteEngine, Rule, Fact, RuleType rete = ReteEngine() rete.build_network([ Rule( rule_id="sanctions_check", name="Flag sanctioned-country transactions", conditions=[ {"field": "amount", "operator": ">", "value": 10_000}, {"field": "country", "operator": "in", "value": ["IR", "KP", "SY", "CU"]}, ], conclusion="flag_for_compliance_review", rule_type=RuleType.IMPLICATION, ), ]) # Run the rule across a batch of incoming transactions, not just one for tx in [ Fact("tx_101", "transaction", [{"amount": 25_000, "country": "IR"}]), Fact("tx_102", "transaction", [{"amount": 4_500, "country": "DE"}]), Fact("tx_103", "transaction", [{"amount": 60_000, "country": "KP"}]), ]: rete.add_fact(tx) flagged = rete.match_patterns() ``` Same condition-matcher caveat as [above](#semanticareasoning-forward-chaining-rete-datalog-sparql) applies — validate against your rule set before production use.

Ontology-to-Knowledge-Graph in One Pass

```python from semantica.ingest import FileIngestor from semantica.semantic_extract import NamedEntityRecognizer, RelationExtractor from semantica.kg import GraphBuilder from semantica.ontology import OntologyGenerator, OntologyValidator from semantica.export import RDFExporter sources = FileIngestor().ingest_directory("./contracts/") ner = NamedEntityRecognizer(confidence_threshold=0.7) entities = ner.process_batch([s["text"] for s in sources]) kg = GraphBuilder(merge_entities=True).build(sources) gen = OntologyGenerator(base_uri="https://myco.dev/ontology/") ont = gen.generate_ontology({"entities": entities[0], "relationships": []}) report = OntologyValidator().validate(ont) if report.valid: RDFExporter().export({"entities": entities[0]}, "ontology.ttl", format="turtle") ```

--- ## Features at a Glance | Capability | Highlights | | --- | --- | | **Context Graphs** | Queryable graph of entities, decisions, relationships; causal links; cross-graph navigation | | **Decision Intelligence** | `record_decision` · `trace_decision_chain` · `find_similar_decisions` · `analyze_decision_impact` · `check_decision_rules` | | **Temporal Intelligence** | Point-in-time snapshots · Allen interval algebra (13 relations) · `TemporalNormalizer` · bi-temporal provenance | | **Distance Intelligence** | N×N semantic distance matrices · ego-mode visualization · distance bands · embedding cache | | **Semantic Extraction** | NER · relation extraction · event detection · triplet generation · coreference | | **Reasoning Engines** | Forward chaining · Rete · deductive · abductive · SPARQL · Datalog with explainable output | | **GraphRAG Chunking** | Entity-aware · relation-aware · graph-based · ontology-aware · community-detection chunking | | **Conflict Detection** | Value / type / relationship / temporal / logical conflicts · multiple resolution strategies | | **Provenance** | W3C PROV-O · every fact traced to source · audit log export JSON/CSV/RDF | | **Ontology Hub** | SHACL Studio · visual editor · cross-ontology alignments · health dashboard | | **Vector Store** | FAISS · Pinecone · Weaviate · Qdrant · Milvus · PgVector · hybrid + filtered search | | **Graph Databases (LPG)** | Neo4j · FalkorDB · Apache AGE · AWS Neptune | | **Triple Stores (RDF)** | Oxigraph (embedded) · Blazegraph · Apache Jena · Eclipse RDF4J · unified `TripletStore` interface · SPARQL query & bulk load | | **Enterprise Data Platforms** | Databricks (`DatabricksIngestor`: Unity Catalog + Delta Lake, PAT/OAuth M2M, table/query ingestion, catalog/schema/table/lineage introspection) · Snowflake (`SnowflakeIngestor`: warehouse/database/schema, password/key-pair/OAuth auth) · SAP (`SAPIngestor`: OData v2/v4, OAuth2/Basic auth, Business Partners/Sales Orders) | | **LLM Providers** | **All already supported today:** OpenAI (GPT-4o, o1, o3) · Anthropic (Claude) · Google Gemini · Mistral · Meta Llama · Groq · Cohere · Azure OpenAI · AWS Bedrock · Ollama · DeepSeek · Perplexity · Together AI · Fireworks AI · Replicate · HuggingFace · via `semantica.llms` and LiteLLM | --- ## Performance Benchmarks from v0.5.0 on a 118,000-node production graph: | Operation | Before | After | Improvement | | --- | --- | --- | --- | | Node search (118k nodes) | 24 ms | 0.004 ms | **6,000×** faster | | Embedding cache hit | cold load | revision-based cache | **10×** throughput | | Semantic deduplication | baseline | optimized candidate gen | **6.98×** faster | | Candidate generation | baseline | blocking strategy | **63.6%** faster | *Measured on a 118,000-node production graph (AMD EPYC, 64 GB RAM); the deduplication/candidate-generation figures are historical measurements recorded in [CHANGELOG.md](CHANGELOG.md) rather than an automated `tests/` assertion. Results vary by hardware, dataset topology, and backend selection — run `pytest tests/vector_store/test_performance_benchmarks.py -s` to measure your own data.* --- ## CLI Every capability is available from the terminal. The CLI ships with the package, no separate install required. ```bash pip install semantica semantica # startup dashboard semantica doctor # health check semantica --help # full grouped command reference ``` Start with `semantica`, verify with `doctor`, build a graph, and explore the command groups from one terminal. **Command groups:** `ingest` · `parse` · `extract` · `kg` · `reason` · `decision` · `temporal` · `provenance` · `ontology` · `embed` · `deduplicate` · `validate` · `export` · `visualize` · `pipeline` · `server` · `explorer` · `mcp` · `doctor` · `shell` · `init` · `watch` → [Full CLI reference](https://docs.getsemantica.ai/) --- ## Integrations Native plugin bundles for Claude Code, Cursor, Codex, Windsurf, Cline, Continue, VS Code, and OpenClaw; a full-featured MCP server for any MCP-compatible client; a comprehensive REST API; and first-class Agno, CrewAI, and LangChain support for agentic frameworks. Every major LLM provider is already supported via `semantica.llms` and LiteLLM: OpenAI, Anthropic, Gemini, Mistral, Llama, Groq, Cohere, Azure, Bedrock, Ollama, DeepSeek, HuggingFace, and more. MCP setup takes 30 seconds — see [MCP Server](#mcp-server) below.

Full integrations matrix (editors, MCP clients, REST clients, agentic frameworks)

Native Plugin Bundle			MCP Server + Plugin
Claude Code _{Skills · agents · hooks}	Cursor _{Skills · agents}	Codex CLI _{Skills · agents}	Windsurf _plugin	Cline _plugin	Continue _plugin	VS Code _plugin	OpenClaw _{MCP + plugin}
MCP Server	REST API
Claude Desktop _{MCP server}	GitHub Copilot _{REST API}	Roo Code _{REST API}	Goose _{REST API}	Kilo Code _{REST API}	Aider _{REST API}	Amazon Q _{REST API}	Zed _{REST API}

### Agentic Fra > 内容过长，已截断。完整文档请查看仓库原文。