RISE Enhanced Architecture: Indigenous AI DSL Server

Desired Outcome

A dual-protocol semantic framework server (LSP + MCP) that makes the IAIP research framework a first-class participant in both IDE environments and multi-agent workflows, grounded in medicine-wheel ontology types and governed by Indigenous data sovereignty (OCAP).

Current Reality

The original January 2026 scaffolding defined a Python LSP server with 5 components (Concept Registry, LSP Operations, Relational Graph, Indigenous Knowledge Mapper, Plugin Lifecycle). Since then, the ecosystem has evolved: medicine-wheel npm packages provide typed ontology primitives, agent orchestration patterns have been analyzed, MCP has become the agent integration standard, and ceremony protocol workflows have been formalized.

Structural Tension

The gap between a standalone LSP concept server and a fully integrated ontology-aware, agent-participatory, ceremony-governed semantic framework that serves as the knowledge backbone for the entire IAIP ecosystem.

Enhanced Architecture

``` ┌─────────────────────────────────────────────────────────┐ │ IAIP DSL Server │ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌────────────────┐ │ │ │ LSP Layer │ │ MCP Layer │ │ Ceremony Gate │ │ │ │ (pygls) │ │ (mcp-sdk) │ │ (OCAP+4Dir) │ │ │ └──────┬───────┘ └──────┬───────┘ └───────┬────────┘ │ │ │ │ │ │ │ ┌──────▼─────────────────▼──────────────────▼────────┐ │ │ │ Unified Query Engine │ │ │ │ ┌──────────┐ ┌──────────┐ ┌────────────────────┐ │ │ │ │ │ Concept │ │Relational│ │ Indigenous Knowledge│ │ │ │ │ │ Registry │ │ Graph │ │ Mapper │ │ │ │ │ │ │ │ Engine │ │ │ │ │ │ │ └────┬─────┘ └────┬─────┘ └─────────┬──────────┘ │ │ │ │ │ │ │ │ │ │ │ ┌────▼─────────────▼────────────────▼──────────┐ │ │ │ │ │ Ontology Bridge Layer │ │ │ │ │ │ (medicine-wheel-ontology-core alignment) │ │ │ │ │ │ RelationalNode · Relation · OcapFlags │ │ │ │ │ │ CeremonyLog · NarrativeBeat · Direction │ │ │ │ │ └──────────────────┬───────────────────────────┘ │ │ │ └─────────────────────┼───────────────────────────────┘ │ │ │ │ │ ┌─────────────────────▼───────────────────────────────┐ │ │ │ Storage & Persistence │ │ │ │ YAML Registry · JSON Index · Wisdom Ledger (SQLite) │ │ │ │ OCAP Audit Log · Ceremony Change Journal │ │ │ └──────────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────┘ │ │ │ IDE Clients AI Agents Orchestrators (Claude Code, (mia-code, (LangGraph, VS Code) miadi-code, A2A, NATS) Heyva, Anikwag) ```

Component Inventory

Tier 1: Core (Original + Refined)

Tier 2: Ontology Bridge (New)

Tier 3: Agent Integration (New)

Technology Stack

``` Language: Python 3.10+ LSP Library: pygls >= 1.0 MCP Library: mcp (official Python SDK) Graph Library: networkx (in-memory relational graph) Storage: YAML (source) + JSON (index) + SQLite (wisdom ledger) Validation: pydantic (type alignment with medicine-wheel types) Export: rdflib (OWL/SHACL generation, optional) Testing: pytest + pytest-asyncio Packaging: pyproject.toml with optional dependency groups ```

Data Flow

Concept Query Flow (LSP)

``` User hovers over "structural tension" in .md file → LSP Client sends textDocument/hover → Server tokenizes position, matches concept ID → Concept Registry returns full entry → Indigenous Knowledge Mapper enriches with 4 lenses → OCAP layer checks access flags → Formatted Markdown response returned to client → Response includes: definition, relationships, Indigenous context, directional alignment → Latency: <50ms ```

Concept Query Flow (MCP)

``` Agent calls iaip_concept_lookup tool with {"concept": "creative-orientation"} → MCP handler receives tool call → Same Unified Query Engine processes request → Returns structured JSON with concept, relationships, Indigenous context → Agent integrates into its reasoning context → Latency: <100ms ```

Concept Change Flow (Ceremony Protocol)

``` Human edits concept-registry.yaml → File watcher detects change → Ceremony Gate activates: 1. Diff analysis: what changed? 2. OCAP check: does editor have authority? 3. Directional check: which direction does this change serve? 4. If significant change → ceremony-required flag set 5. Change journaled in Ceremony Change Log → Registry reloaded → Wisdom Ledger updated with change event → Connected agents notified via MCP ```

File Structure (Generated)

``` indigenous_ai_dsl_server/ ├── init.py ├── main.py # Entry point ├── server.py # Dual-protocol server setup (LSP + MCP) ├── config.py # Configuration and paths │ ├── registry/ │ ├── init.py │ ├── loader.py # YAML → JSON → in-memory index │ ├── concept.py # Concept data model (pydantic) │ ├── index.py # Fast lookup index │ └── watcher.py # File change detection │ ├── graph/ │ ├── init.py │ ├── engine.py # networkx-based relational graph │ ├── relationships.py # Typed relationship definitions │ └── traversal.py # Path finding, context expansion │ ├── knowledge/ │ ├── init.py │ ├── mapper.py # Indigenous Knowledge Mapper │ ├── directions.py # Four Directions enrichment │ └── ocap.py # OCAP governance enforcement │ ├── lsp/ │ ├── init.py │ ├── handler.py # LSP operation handlers │ ├── diagnostics.py # Terminology validation │ └── formatters.py # Response formatting (Markdown) │ ├── mcp/ │ ├── init.py │ ├── tools.py # MCP tool definitions │ ├── resources.py # MCP resource exposure │ └── prompts.py # MCP prompt templates │ ├── ontology/ │ ├── init.py │ ├── bridge.py # medicine-wheel type alignment │ ├── export.py # OWL/SHACL/JSON-LD generation │ └── types.py # Pydantic models aligned to MW types │ ├── wisdom/ │ ├── init.py │ ├── ledger.py # SQLite-based usage tracking │ └── ceremony.py # Change ceremony protocol │ ├── data/ │ ├── concept-registry.yaml # Source of truth │ ├── concept-registry.json # Generated index │ └── wisdom.db # Wisdom Ledger SQLite │ ├── tests/ │ ├── test_registry.py │ ├── test_graph.py │ ├── test_lsp.py │ ├── test_mcp.py │ ├── test_ocap.py │ └── test_ceremony.py │ ├── plugin.json # Claude Code plugin manifest ├── .lsp.json # LSP routing configuration ├── pyproject.toml # Package definition └── README.md # Installation and usage ```

Advancing Patterns

1. Concept → Ontology → Agent Intelligence: Each concept lookup enriches the requesting agent's understanding, creating a flywheel where agents become more framework-literate with each interaction
2. YAML edit → Ceremony → Community consensus: Concept evolution is never unilateral; the ceremony protocol ensures changes are witnessed and consented
3. Usage tracking → Wisdom Ledger → Emergent patterns: Over time, the Wisdom Ledger reveals which concepts are most queried, which relationships are most traversed, and which directional alignments emerge naturally
4. LSP + MCP → Universal access: Whether a human is writing in their IDE or an agent is reasoning in a multi-agent workflow, the same semantic knowledge is accessible through the appropriate protocol