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