Kailash Nexus - Multi-Channel Platform Framework

Nexus is a zero-config multi-channel platform built on Kailash Core SDK that deploys workflows as API + CLI + MCP simultaneously.

Features

Nexus transforms workflows into a complete platform with:

• Zero Configuration: Deploy workflows instantly without boilerplate code
• Multi-Channel Access: API, CLI, and MCP from single deployment
• Unified Sessions: Consistent session management across all channels
• Enterprise Features: Health monitoring, plugins, event system, comprehensive logging
• DataFlow Integration: Automatic CRUD API generation from database models
• Production Ready: Deployment patterns, monitoring, troubleshooting guides
• FastAPI Alternative: Workflow-based platform without manual route definition
• Async-First: Uses AsyncLocalRuntime by default for optimal performance

Quick Start

from nexus import Nexus

# Define workflow
workflow = create_my_workflow()

# Deploy to all channels at once
nexus = Nexus([workflow])
nexus.run(port=8000)

# Now available via:
# - HTTP API: POST http://localhost:8000/api/workflow/{workflow_id}
# - CLI: nexus run {workflow_id} --input '{"key": "value"}'
# - MCP: Connect via MCP client (Claude Desktop, etc.)

Reference Documentation

Getting Started

• nexus-quickstart - Quick start guide
• nexus-installation - Installation and setup
• nexus-architecture - Architecture overview
• README - Framework overview
• nexus-comparison - Nexus vs FastAPI/Flask

Core Concepts

• nexus-workflow-registration - Registering workflows
• nexus-multi-channel - Multi-channel architecture
• nexus-sessions - Session management
• nexus-config-options - Configuration options

Channel-Specific Patterns

• nexus-api-patterns - HTTP API patterns
• nexus-api-input-mapping - API input handling
• nexus-cli-patterns - CLI usage patterns
• nexus-mcp-channel - MCP channel configuration

Integration

• nexus-dataflow-integration - DataFlow + Nexus patterns
• nexus-plugins - Plugin system
• nexus-event-system - Event-driven architecture

Production & Operations

• nexus-production-deployment - Production deployment
• nexus-health-monitoring - Health checks and monitoring
• nexus-enterprise-features - Enterprise capabilities
• nexus-troubleshooting - Common issues and solutions

Key Concepts

Zero-Config Platform

Nexus eliminates boilerplate:

• No FastAPI routes - Automatic API generation from workflows
• No CLI arg parsing - Automatic CLI creation
• No MCP server setup - Automatic MCP integration
• Unified deployment - One command for all channels

Multi-Channel Architecture

Single deployment, three access methods:

1. HTTP API: RESTful JSON endpoints
2. CLI: Command-line interface
3. MCP: Model Context Protocol server

Unified Sessions

Consistent session management:

• Cross-channel session tracking
• Session state persistence
• Session-scoped workflows
• Concurrent session support

Enterprise Features

Production-ready capabilities:

• Health monitoring endpoints
• Plugin system for extensibility
• Event system for integrations
• Comprehensive logging and metrics
• Correct channel initialization flow
• Proper workflow registration

When to Use This Skill

Use Nexus when you need to:

• Deploy workflows as production platforms
• Provide multiple access methods (API/CLI/MCP)
• Build enterprise platforms quickly
• Auto-generate CRUD APIs (with DataFlow)
• Replace FastAPI/Flask with workflow-based platform
• Create multi-channel applications
• Deploy AI agent platforms (with Kaizen)

Integration Patterns

With DataFlow (Auto CRUD API)

from nexus import Nexus
from dataflow import DataFlow

# Define models
db = DataFlow(...)
@db.model
class User:
    id: str
    name: str

# Auto-generates CRUD endpoints for all models
nexus = Nexus(db.get_workflows())
nexus.run()

# GET  /api/User/list
# POST /api/User/create
# GET  /api/User/read/{id}
# PUT  /api/User/update/{id}
# DELETE /api/User/delete/{id}

With Kaizen (Agent Platform)

from nexus import Nexus
from kaizen.base import BaseAgent

# Deploy agents via all channels
agent_workflow = create_agent_workflow()
nexus = Nexus([agent_workflow])
nexus.run()

# Agents accessible via API, CLI, and MCP

With Core SDK (Custom Workflows)

from nexus import Nexus
from kailash.workflow.builder import WorkflowBuilder

# Deploy custom workflows
workflows = [
    create_workflow_1(),
    create_workflow_2(),
    create_workflow_3(),
]

nexus = Nexus(workflows)
nexus.run(port=8000)

Standalone Platform

from nexus import Nexus

# Complete platform from workflows
nexus = Nexus(
    workflows=[...],
    plugins=[custom_plugin],
    health_checks=True,
    monitoring=True
)
nexus.run(
    host="0.0.0.0",
    port=8000,
    workers=4
)

Critical Rules

• ✅ Use Nexus instead of FastAPI for workflow platforms
• ✅ Register workflows, not individual routes
• ✅ Leverage unified sessions across channels
• ✅ Enable health monitoring in production
• ✅ Use plugins for custom behavior
• ✅ Nexus uses AsyncLocalRuntime by default (correct for Docker)
• ❌ NEVER mix FastAPI routes with Nexus
• ❌ NEVER implement manual API/CLI/MCP servers when Nexus can do it
• ❌ NEVER skip health checks in production

Deployment Patterns

Development

nexus = Nexus(workflows)
nexus.run(port=8000)  # Single process, hot reload

Production (Docker)

from kailash.runtime import AsyncLocalRuntime

nexus = Nexus(
    workflows,
    runtime_factory=lambda: AsyncLocalRuntime()
)
nexus.run(host="0.0.0.0", port=8000, workers=4)

With Load Balancer

# Deploy multiple Nexus instances behind nginx/traefik
docker-compose up --scale nexus=3

Channel Comparison

Related Skills

• 01-core-sdk - Core workflow patterns
• 02-dataflow - Auto CRUD API generation
• 04-kaizen - AI agent deployment
• 05-mcp - MCP channel details
• 17-gold-standards - Best practices

Support

For Nexus-specific questions, invoke:

• nexus-specialist - Nexus implementation and deployment
• deployment-specialist - Production deployment patterns
• framework-advisor - When to use Nexus vs other approaches