semantica

The semantica.normalize module provides tools to standardize raw data before extraction and graph construction. This prevents data fragmentation (e.g., multiple nodes for the same company or different formats for the same date) by collapsing variants into canonical forms.

Key capabilities include:

• Text cleaning: Unicode normalization (NFC/NFKC), whitespace collapsing, and smart-quote/dash normalization.
• Entity canonicalization: Resolving aliases and disambiguating entities using configurable maps.
• Date normalization: Converting various formats (including relative dates) to ISO 8601.
• Number conversion: Parsing strings like "$1.2B" into floats like 1200000000.0.
• Language and Encoding: Detecting languages and repairing inconsistent byte encodings.

semantica.context serves as the memory and decision layer for AI agents. It provides a unified interface for managing agentic state through several key capabilities:

• Memory & Retrieval: Stores facts with provenance and supports embedding-backed semantic search.
• Decision Tracking: Records decisions as first-class graph objects with full causal chains (tracing how decisions influence each other).
• Graph-Backed Intelligence: Uses a knowledge graph for complex queries via multi-hop GraphRAG traversal.
• Policy Enforcement: Manages versioned policies to ensure agent decisions comply with predefined rules.
• Consistency: Allows agents to search their own history to prevent contradictory choices across different runs.

Semantica supports a wide range of integrations across different categories:

Native Plugin Bundles

Provides specialized skills and agents for editors including:

• Claude Code
• Cursor
• Codex CLI
• Windsurf
• Cline
• Continue
• VS Code
• OpenClaw

Agentic Frameworks

• Native Integration: Agno (pip install semantica[agno])
• Via REST API & MCP: LangChain, LangGraph, CrewAI, LlamaIndex, AutoGen, OpenAI Agents SDK, and Google ADK.

LLM Providers

Supported via semantica.llms and LiteLLM, including OpenAI, Anthropic, Gemini, Mistral, Llama, Groq, Cohere, Azure, Bedrock, Ollama, DeepSeek, and HuggingFace.

The semantica.seed module allows you to provide a reliable, verified starting point for your knowledge graph by loading structured reference data such as taxonomies, product catalogs, or employee rosters. This process anchors entity extraction to known entities, reducing hallucinations and duplicate nodes.

Key capabilities include:

• Loading verified reference data (ISO codes, domain taxonomies, etc.).
• Using SeedDataManager to merge extracted data onto foundation nodes without creating duplicates.
• Supporting multiple formats: JSON, CSV, SQL (database), and API.
• Providing deterministic test graph generation.
• Implementing merge strategies (seed_first, extracted_first, merge) to handle conflicts between seed and extracted data.

The semantica.triplet_store module provides W3C-standard RDF storage with SPARQL 1.1 query support. It offers a unified interface (TripletStore) that allows you to swap between different backends like Blazegraph, Apache Jena, and RDF4J by changing a single parameter. Use this module when you need semantic web compatibility, OWL-style reasoning, or SPARQL-based queries.

from semantica.triplet_store import TripletStore
from semantica.semantic_extract.types import Triplet

store = TripletStore(
    backend="blazegraph",
    endpoint="http://localhost:9999/blazegraph/sparql"
)

t = Triplet(
    subject="http://example.org/apple_inc",
    predicate="http://example.org/founded_by",
    object="http://example.org/steve_jobs",
)
store.add_triplet(t)

The semantica.change_management module provides version control, SHA-256 checksums, diff analysis, and rollback capabilities for knowledge graphs and ontologies. It supports compliance frameworks like HIPAA, SOX, GDPR, and FDA 21 CFR Part 11.

Key Components

• TemporalVersionManager: Manages snapshots, diffs, rollbacks, and per-node mutation history for Knowledge Graphs (KGs).
• OntologyVersionManager: Manages schema versioning and structural diffs for OWL ontologies.
• VersionStorage: Pluggable backends including InMemoryVersionStorage (for testing) and SQLiteVersionStorage (for production persistence).
• Integrity Tools: compute_checksum() and verify_checksum() use SHA-256 to detect unauthorized modifications.

GraphRAG (Graph-Augmented Retrieval-Augmented Generation) enhances traditional RAG by combining vector similarity search with knowledge graph traversal. While traditional vector RAG finds documents similar to your query text, GraphRAG follows relationships between entities to find connected evidence across multiple documents, even if they don't mention your query terms directly.

Key Benefits:

• Multi-hop discovery: Finds facts that are several relationship steps away (e.g., Actor → Tool → Victim → Industry).
• Connected evidence: Retrieves coherent chains of related entities rather than isolated fragments.
• Explainability: Provides an audit trail showing exactly which entities and relationships led to the retrieved evidence.

Semantica is organized into 27 independent modules across six logical layers. Each module is independently importable, allowing you to use only the specific components required for your task. The architecture is structured as follows:

• Input Layer: Data ingestion and preparation (ingest, parse, split, normalize).
• Core Processing: Intelligence and understanding (semantic_extract, kg, ontology, reasoning).
• Storage: Persistent data storage (embeddings, vector_store, graph_store, triplet_store).
• Quality Assurance: Data quality and consistency (deduplication, conflicts).
• Context & Memory: Agent memory and decision tracking (context, provenance, change_management).
• Output & Orchestration: Export, visualization, and workflows (export, visualization, pipeline, explorer).