Semantica Module Documentation: Where to Find Complete API Reference and Guides

Semantica's module documentation is located in two main locations: the high-level docs/modules.md file for architectural overviews and docs/reference/*.md files for detailed API documentation of each of the 27 modules.

The semantica-agi/semantica repository organizes documentation into a dual-layer system: narrative documentation that explains how modules fit together, and reference documentation that documents every class and function. This structure lets you quickly navigate from architectural concepts to implementation details.

Primary Documentation Locations

Modules Overview Page

The central entry point is docs/modules.md, which catalogs all 27 modules and groups them into six logical layers. This file contains architectural diagrams, dependency maps, and links to every module's reference page.

According to the semantica source code, the six layers are:

Layer	Modules
Input	ingest, parse, split, normalize
Core Processing	semantic_extract, kg, ontology, reasoning
Storage	embeddings, vector_store, graph_store, triplet_store
Quality Assurance	deduplication, conflicts
Context & Memory	context, provenance, change_management
Output & Orchestration	export, visualization, pipeline, explorer, LLM providers, MCP server, seed, evals, core, utils

Module-Specific Reference Pages

Each module has a dedicated markdown file under docs/reference/. These files contain code snippets, class listings, parameter descriptions, and usage notes.

Key reference files include:

• docs/reference/ingest.md — file and web ingestion APIs
• docs/reference/parse.md — document parsing strategies
• docs/reference/semantic_extract.md — entity and relation extraction
• docs/reference/kg.md — knowledge-graph construction and temporal queries
• docs/reference/vector_store.md — vector database abstractions
• docs/reference/pipeline.md — pipeline DSL for orchestration

Programmatically Accessing Documentation Paths

You can generate documentation URLs dynamically using the consistent file naming convention:

def doc_url(module_name: str) -> str:
    """Return the GitHub documentation URL for a semantica module."""
    base = "https://github.com/semantica-agi/semantica/blob/main/docs/reference"
    return f"{base}/{module_name}.md"

# Generate URLs for any module

print(doc_url("ingest"))

# → https://github.com/semantica-agi/semantica/blob/main/docs/reference/ingest.md

print(doc_url("kg"))

# → https://github.com/semantica-agi/semantica/blob/main/docs/reference/kg.md

Mapping Documentation to Importable Code

The reference documentation directly corresponds to importable Python modules. Each documented module exposes its public API through __init__.py files that implement lazy-loading patterns.

Ingestion Layer Documentation

Found in docs/reference/ingest.md and implemented in semantica/ingest/__init__.py:

from semantica.ingest import FileIngestor, WebIngestor

# Ingest local files — see ingest.md for full parameter reference

files = FileIngestor().ingest_directory("data/")

# Ingest remote content — documented in the same reference page

page = WebIngestor().ingest_url("https://example.com")

Core Processing Documentation

The semantic_extract and kg modules represent the primary processing pipeline. Their documentation lives in docs/reference/semantic_extract.md and docs/reference/kg.md, with implementations in semantica/semantic_extract/__init__.py and semantica/kg/__init__.py.

The knowledge-graph module (kg) specifically documents temporal query classes and graph-building utilities that bridge semantic extraction to persistent storage.

Storage Layer Documentation

Vector and graph storage are documented separately despite tight integration:

• docs/reference/vector_store.md → semantica/vector_store/__init__.py
• docs/reference/graph_store.md → semantica/graph_store/__init__.py

The vector_store module implements a backend-agnostic abstraction supporting multiple vector databases, with configuration options documented in its reference page.

Pipeline Orchestration Documentation

The pipeline module's DSL for chaining operations is fully documented in docs/reference/pipeline.md and semantica/pipeline/__init__.py. This documentation explains how to compose the 27 modules into executable workflows.

Key Source Files for Documentation Authors

If you're extending semantica or writing integrations, these files define the public APIs that documentation covers:

File	Documentation Purpose
semantica/ingest/__init__.py	Export list and lazy-loading for ingestion classes
semantica/semantic_extract/__init__.py	Entry point for extraction pipelines
semantica/kg/__init__.py	Graph utilities and TemporalQuery classes
semantica/vector_store/__init__.py	Backend abstraction layer
semantica/pipeline/__init__.py	Pipeline builder DSL
semantica/visualization/__init__.py	KG and ontology rendering classes

Summary

• Entry point: docs/modules.md provides the architectural overview and links to all 27 modules
• Reference details: docs/reference/{module}.md contains complete API documentation for each module
• Code correlation: Every documented module maps directly to semantica/{module}/__init__.py with lazy-loaded exports
• Programmatic discovery: Documentation URLs follow the predictable pattern docs/reference/{module_name}.md
• Layer organization: Modules are grouped into Input, Core Processing, Storage, Quality Assurance, Context & Memory, and Output & Orchestration layers

Frequently Asked Questions

Where is the complete list of all 27 semantica modules?

The complete catalog is in docs/modules.md, which enumerates all modules across the six architectural layers. This file serves as the authoritative index and includes the full list: ingest, parse, split, normalize, semantic_extract, kg, ontology, reasoning, embeddings, vector_store, graph_store, triplet_store, deduplication, conflicts, context, provenance, change_management, export, visualization, pipeline, explorer, LLM providers, MCP server, seed, evals, core, and utils.

How do I find documentation for a specific module like vector_store?

Navigate to docs/reference/vector_store.md for the complete API reference. The module can be imported via from semantica.vector_store import VectorStore, with all public classes and functions documented in that file. The same pattern applies to any module—replace vector_store with your target module name.

Is there documentation for combining multiple modules into a pipeline?

Yes, the pipeline module documentation in docs/reference/pipeline.md covers the DSL for orchestrating modules. Additionally, docs/modules.md explains architectural relationships between layers, showing how Input modules feed into Core Processing, then Storage, with Quality Assurance and Context layers operating across the stack.

Do the markdown documentation files contain runnable code examples?

Every docs/reference/{module}.md file includes code snippets, class listings, and usage notes extracted from the actual implementation. These examples demonstrate import patterns, initialization parameters, and common workflows. For the most current examples, cross-reference with the corresponding semantica/{module}/__init__.py file which defines the lazy-loaded exports.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}