MIZ OKI 3.5/4.5 COMPLETE KNOWLEDGE GRAPH

Integrated Architecture & Implementation Map

Document Version: 2.0
Last Updated: January 1, 2026
Status: Production Implementation - v5.26.0

EXECUTIVE SUMMARY

MIZ OKI 3.5/4.5 is a sophisticated AI-native marketing intelligence and automation platform built on a 32-cell microservices architecture using the SRPVDAL framework (Sense-Reason-Decide-Act-Learn). The system combines:

• 32-Cell SRPVDAL Architecture: Orchestration (01-05) + Production (1-25) + Meta-Level (26-31) + Journey Viz (3-1)
• Boss Agent ADK.26.0: Multi-agent orchestration with 180+ MCP tools, Claude Opus 4.6 Extended Thinking
• Enhanced Self-Healing Knowledge Graph (E-SHKG): Powered by Firestore (the knowledge-graph backend) and Vertex AI. Neo4j and TigerGraph appear throughout this document as the original design substrate. Neo4j was retired by owner decision on 2026-08-09 — it is not being re-provisioned and the Aura host in the neo4j-uri secret is NXDOMAIN by choice; Cell 03 serves the KG from Firestore (src/cells/cell03/v2/repository_factory.py). Read every later Neo4j/TigerGraph reference here as design-vintage, not as a live backend.
• Real-Time Streaming: SSE and WebSocket-based live data pipelines with Supabase Auth
• Causal Inference: Advanced attribution with CATE estimation, uplift modeling, Wilson CI
• Multi-Channel Execution: Google Ads, Meta CAPI, Amazon, LinkedIn, Email, SMS, Programmatic
• Micro-Edge Metrics: Rolling window p95/mean tracking for auto-launch validation
• Nightly Validation: Predicted vs realized analysis with auto-tuning agent weights

I. SYSTEM ARCHITECTURE OVERVIEW

A. Four-Layer Architecture

┌──────────────────────────────────────────────────────────────────────────┐
│                    ORCHESTRATION LAYER (Cells 01-05)                     │
│   Boss Agent ADK.26.0 • MOE Router • MOA Aggregator • Planner • MCP       │
│   180+ Tools • Claude Opus 4.6 • Extended Thinking (64K tokens)          │
└──────────────────────────────┬───────────────────────────────────────────┘
                               │
┌──────────────────────────────▼───────────────────────────────────────────┐
│                 INTELLIGENCE LAYER (Cell 03 - KG Brain)                  │
│   Neo4j • TigerGraph • Firestore • Vertex AI • Causal GraphRAG          │
│   E-SHKG • Marketing KG • KG Projections • Journey Intelligence          │
└──────────────────────────────┬───────────────────────────────────────────┘
                               │
┌──────────────────────────────▼───────────────────────────────────────────┐
│                EXECUTION LAYER (Cells 1-25 Production)                   │
│   SENSE → REASON → DECIDE → ACT → LEARN                                 │
│   Streaming Online Learning • Thompson Sampling • Guardrails             │
└──────────────────────────────┬───────────────────────────────────────────┘
                               │
┌──────────────────────────────▼───────────────────────────────────────────┐
│                     VALIDATION LAYER (v5.25.0+)                          │
│   Micro-Edge Metrics • Launch Validation • Nightly Auto-Tuning          │
│   Wilson CI • Δp95 Detection • Guardrail Breach • SRPVDAL Feedback        │
└──────────────────────────────────────────────────────────────────────────┘

B. Complete Cell Manifest

ORCHESTRATION LAYER (Cells 01-05)

PRODUCTION LAYER (Cells 1-25)

SENSE Stage (Cells 1-5)

REASON Stage (Cells 6-12)

DECIDE Stage (Cells 13-18)

ACT Stage (Cells 19-22)

LEARN Stage (Cells 23-25)

META-LEVEL COORDINATION (Cells 26-31)

SPECIALIZED SERVICES

II. CORE TECHNOLOGY COMPONENTS

A. Knowledge Graph Architecture (Cell 03 v2)

Multi-Engine Hybrid Design:

┌─────────────────────────────────────────────────────────────────┐
│              Cell 03: Knowledge Graph Brain v2                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌────────────┐  ┌──────────────┐  ┌─────────┐  ┌───────────┐  │
│  │  Firestore │  │  TigerGraph  │  │ Vertex  │  │   Neo4j   │  │
│  │  (Primary) │  │   (OLAP)     │  │   AI    │  │  (Legacy) │  │
│  └──────┬─────┘  └──────┬───────┘  └────┬────┘  └─────┬─────┘  │
│         │               │               │             │         │
│         └───────────────┴───────────────┴─────────────┘         │
│                              │                                   │
│                   ┌──────────▼──────────┐                       │
│                   │   Unified KG API    │                       │
│                   │   - understand()    │                       │
│                   │   - route()         │                       │
│                   │   - causal()        │                       │
│                   │   - temporal()      │                       │
│                   │   - explain()       │                       │
│                   │   - learn()         │                       │
│                   │   - project()       │                       │
│                   └─────────────────────┘                       │
└─────────────────────────────────────────────────────────────────┘

Firestore Collections (v5.11.0+):

Key Capabilities:

1. Real-Time OLTP (Firestore): Live relationship queries, entity resolution
2. Analytical OLAP (TigerGraph): Pattern mining, community detection, graph algorithms
3. ML Integration (Vertex AI): Embeddings, predictions, recommendations
4. Causal GraphRAG: Causal path discovery, counterfactual analysis
5. Self-Healing: Automatic schema evolution, data quality maintenance
6. KG Projections: Time-decayed scoring with 72-hour half-life

B. Boss Agent Orchestration System (v5.26.0)

Architecture:

class BossAgentV526:
    """
    Complete SRPVDAL orchestration with E-SHKG + Micro-Edge Metrics
    """
    VERSION = "5.26.0"

    def __init__(self):
        self.kg_client = Cell03Client()           # KG Brain connection
        self.mcp_registry = MCPToolRegistry()     # 180+ tools
        self.a2a_gateway = WebSocketGateway()     # Real-time messaging
        self.srpvdal_pipeline = SRPVDALPipeline()     # Cell coordination
        self.micro_edge = MicroEdgeMetrics()      # Launch validation
        self.nightly_validator = NightlyValidator()  # Auto-tuning

    async def process_request(self, user_query: str):
        # SENSE: Understand via KG
        context = await self.kg_client.understand(user_query)

        # REASON: Get routing intelligence + causal paths
        routing = await self.kg_client.route(context)
        causal = await self.kg_client.causal(routing)

        # DECIDE: Build execution plan with REWOO
        plan = await self.cell04_plan_builder.create_plan(routing, causal)

        # ACT: Execute via specialized cells
        results = await self.execute_plan(plan)

        # LEARN: Update knowledge graph + validate predictions
        await self.kg_client.learn(results)
        await self.nightly_validator.record_outcome(results)

        # SYNTHESIZE: Merge results
        return await self.cell05_synthesize(results)

MCP Tool Categories (180+ Tools):

C. Micro-Edge Metrics & Launch Validation (v5.25.0)

Architecture:

┌─────────────────────────┐     ┌─────────────────────────┐
│   Boss Agent ADK        │────▶│   MCP Server (TS)       │
│   (Python)              │     │   /mcp/src/server.ts    │
└─────────────────────────┘     └───────────┬─────────────┘
         │                                  │
         ▼                                  ▼
┌─────────────────────────┐     ┌─────────────────────────┐
│ unified_registry.py     │     │  service_registry.yaml  │
│ (Service Discovery)     │     │  (MCP Tool Definitions) │
└─────────────────────────┘     └───────────┬─────────────┘
                                            │
                                            ▼
                                ┌─────────────────────────┐
                                │  Micro-Edge Metrics     │
                                │  Service (TypeScript)   │
                                │  /services/micro-edge-  │
                                │  metrics/               │
                                └───────────┬─────────────┘
                                            │
                                            ▼
                                ┌─────────────────────────┐
                                │  Firestore              │
                                │  edge_events collection │
                                └─────────────────────────┘

Edge Event Types:

Statistical Functions:

def wilson(p: float, n: int, z: float = 1.96) -> dict:
    """Wilson score interval for binomial proportion."""
    denominator = 1 + z**2 / n
    centre = p + z**2 / (2 * n)
    adj = z * sqrt((p * (1 - p) + z**2 / (4 * n)) / n)
    return {
        "low": (centre - adj) / denominator,
        "high": (centre + adj) / denominator
    }

def pQuantile(sorted_vals: list, q: float) -> float:
    """Calculate p-th quantile (e.g., p95)."""
    if not sorted_vals:
        return None
    idx = int(len(sorted_vals) * q)
    return sorted_vals[min(idx, len(sorted_vals) - 1)]

Validation Recommendations:

D. Nightly Validation & Auto-Tuning (v5.26.0)

Auto-Tuning Formula:

$$w_{new} = w(1-\alpha) + \alpha \cdot f(score)$$

Where: - $w$ = current agent weight - $\alpha$ = learning rate (default 0.1) - $score$ = inverse of RMSE or Brier score

Metrics Tracked:

E. Frontend Architecture

Technology Stack:

• Framework: Next.js 14 with React 18
• Language: TypeScript
• UI Components: Ant Design + Custom Design System + Lucide Icons
• State Management: Zustand + TanStack Query
• Visualization: D3.js, Cytoscape.js, Recharts
• Real-time: ProductionA2AClient (WebSocket), SSE
• Collaboration: Liveblocks for multiplayer features
• Auth: Supabase Authentication

Key Pages & Features:

III. GOOGLE CLOUD PLATFORM INFRASTRUCTURE

A. Cloud Run Deployment

Service Architecture:

Services:
  # Orchestration Layer
  - boss-agent-adk                    # Boss Agent ADK.26.0
  - miz-oki-moa-controller           # MOA Controller
  - cell03-kg-brain                  # KG Brain v2
  - boss-rewoo-orchestrator          # REWOO Planner

  # Production Cells (1-25)
  - miz-oki-cell01 through miz-oki-cell25

  # Meta-Level Coordination (26-31)
  - miz-oki-cell26 through miz-oki-cell31

  # Specialized Services
  - micro-edge-metrics               # Launch validation
  - mcp-server                       # MCP tool registry
  - coding-moa                       # Code generation
  - eshkg-path-metrics-api           # E-SHKG metrics

  # Frontend & Gateway
  - miz-oki-command-center-ui        # Frontend (mizoki3.com)
  - websocket-gateway                # Real-time messaging

Configuration:
  Region: us-central1
  CPU: 2-4 vCPU per service
  Memory: 4-8 GiB per service
  Concurrency: 1000 requests
  Timeout: 3600 seconds
  Auto-scaling: 0-100 instances
  CPU Boost: Enabled

B. Data Storage

Firestore (Primary KG):

BigQuery:

• Event Data: Raw and processed event streams
• Performance Metrics: Historical campaign data
• Attribution Models: Causal inference results
• Customer Journey: Touchpoint sequences

Cloud Storage:

• Model Artifacts: ML models and weights
• Configuration: Feature flags, deployment configs
• Backups: Database snapshots, audit logs

C. Service URLs

IV. CAUSAL INFERENCE & ATTRIBUTION

A. Causal Methods

B. Attribution Models

Multi-Touch Attribution:

V. INTEGRATION POINTS & APIs

A. External Integrations

Advertising Platforms:

Data Sources:

B. MCP Server Configuration

Invocation Kinds:

VI. VERSION HISTORY

Recent Versions

VII. SUCCESS METRICS & KPIs

A. Technical Performance

B. Business Impact

C. AI/ML Quality

VIII. APPENDICES

A. Technology Stack Summary

Frontend: - Next.js 14, React 18, TypeScript - Ant Design, Zustand, TanStack Query - D3.js, Cytoscape.js, Recharts, Lucide Icons - Liveblocks, OpenTelemetry, Supabase Auth

Backend: - Python 3.12, FastAPI, Uvicorn - TypeScript, Express, Node.js - LangChain, Anthropic SDK (Claude Opus 4.6) - Firestore, Neo4j, TigerGraph, Redis - Google Cloud libraries

Infrastructure: - Google Cloud Run, BigQuery - Pub/Sub, Secret Manager, Cloud Storage - Docker, GitHub Actions CI/CD

AI/ML: - Vertex AI, Claude Opus 4.6 Extended Thinking - Custom ML models (DLRM, DRLearner) - Causal inference libraries (DoWhy, EconML) - Embedding models

B. Glossary

C. Key File Locations

MIZOKICloudRun/
├── miz-oki-adk-agents/boss/           # Boss Agent ADK.26.0
│   ├── boss_agent_adk_production.py    # Main orchestrator
│   ├── micro_edge_metrics_integration.py
│   ├── launch_validation_integration.py
│   ├── nightly_validation_job.py
│   ├── unified_registry.py
│   └── *_integration.py               # 20+ integration modules
├── miz-oki-command-center-ui/         # Frontend (Next.js)
│   ├── app/                           # Pages
│   ├── components/                    # React components
│   └── lib/api/                       # API clients
├── mcp/                               # MCP Server
│   ├── src/server.ts
│   ├── src/registry.ts
│   └── service_registry.yaml
├── services/                          # Specialized services
│   ├── micro-edge-metrics/            # TypeScript service
│   ├── coding-moa/
│   └── boss-rewoo-orchestrator/
├── src/cells/                         # 32-cell microservices
├── CLAUDE.md                          # Development logs
├── README.md                          # Quick reference
└── MIZ_OKI_COMPLETE_KNOWLEDGE_GRAPH.md  # This document

CONCLUSION

MIZ OKI 3.5/4.5 v5.26.0 represents a complete, production-ready AI-native marketing intelligence platform. The 32-cell SRPVDAL architecture provides unprecedented modularity and scalability, while the Boss Agent orchestration system enables sophisticated multi-agent coordination with 180+ MCP tools.

Key differentiators: - Micro-Edge Metrics: Real-time validation of deployments with Wilson CI - Nightly Auto-Tuning: Continuous improvement of agent weights - Claude Opus 4.6: 64K extended thinking tokens for complex reasoning - Causal GraphRAG: True attribution beyond correlation - 180+ MCP Tools: Comprehensive automation capabilities

The platform delivers 20-25% improvements in marketing efficiency through advanced causal analytics, real-time optimization, and autonomous decision-making.

Document End