Vivified Platform

Enterprise application kernel with plugin architecture

Vivified is a modular platform for building secure, scalable applications. Deploy anything from ERP systems to security operations centers, messaging hubs to compliance platforms.

Platform Overview

Vivified provides a secure foundation for enterprise applications through its three-lane communication model and trait-based access control (TBAC).

Architecture

```mermaid graph TB subgraph "Applications" APP1[ERP System] APP2[Security Platform] APP3[Messaging Hub] APP4[Custom Application] end

subgraph "Core Platform"
    GW[Gateway]
    AUTH[Identity & TBAC]
    POL[Policy Engine]
    STOR[Storage Service]
    MSG[Message Bus]
    AUDIT[Audit Service]
end

subgraph "Plugins"
    P1[Splunk Integration]
    P2[Slack/Teams]
    P3[Database Connectors]
    P4[Custom Plugins]
end

APP1 --> GW
APP2 --> GW
APP3 --> GW
APP4 --> GW

GW --> AUTH
AUTH --> POL
GW --> MSG
MSG --> P1
MSG --> P2
MSG --> P3
MSG --> P4

```

Use Cases

Core Features

Quick links

• Architecture → Three-Lane Model
• Architecture → Diagrams
• AI & Agents → Overview

Defaults

• Database: Postgres (postgresql+asyncpg://…) for non‑test runs; tests default to in‑memory SQLite unless TEST_DB_URL overrides
• RAG (AI): Redis (redis://localhost:6379/0) by default with graceful fallback to in‑memory

Quick start

docker-compose up -d
curl http://localhost:8080/health

Development

Plugin Example

from vivified import Plugin, canonical, operator

class IntegrationPlugin(Plugin):
    """Example integration plugin"""

    @canonical.subscribe("document.received")
    async def handle_document(self, event):
        # Route based on traits
        recipients = await self.identity.find_by_traits(
            ["department:finance", "notify:documents"]
        )

        for recipient in recipients:
            await self.send_notification(recipient, event.data)

    @operator.expose("send_notification")
    async def send_notification(self, recipient, data):
        # Send via configured channel
        channel = recipient.traits.get("preferred_channel", "email")
        return await self.channels[channel].send(recipient, data)

import { Plugin, canonical, operator } from '@vivified/sdk';

class IntegrationPlugin extends Plugin {
  @canonical.subscribe('document.received')
  async handleDocument(event) {
    // Route based on traits
    const recipients = await this.identity.findByTraits([
      'department:finance',
      'notify:documents'
    ]);

    for (const recipient of recipients) {
      await this.sendNotification(recipient, event.data);
    }
  }

  @operator.expose('sendNotification')
  async sendNotification(recipient, data) {
    // Send via configured channel
    const channel = recipient.traits.preferredChannel || 'email';
    return await this.channels[channel].send(recipient, data);
  }
}

# plugin.yaml
name: integration-plugin
version: 1.0.0
traits:
  - can_send_notifications
  - can_access_user_directory
channels:
  email:
    provider: smtp
    host: mail.example.com
  slack:
    webhook_url: ${SLACK_WEBHOOK}
  pushover:
    app_token: ${PUSHOVER_TOKEN}

Communication Patterns

Quick Start

Local Development

# Clone repository
git clone https://github.com/DMontgomery40/vivified.git
cd vivified

# Start services
docker-compose up -d

# Verify health
curl http://localhost:8080/health

# View logs
docker-compose logs -f

Configuration

Production Deployment

# vivified-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vivified-core
spec:
  replicas: 3
  selector:
    matchLabels:
      app: vivified
  template:
    metadata:
      labels:
        app: vivified
    spec:
      containers:
      - name: vivified
        image: vivified/core:latest
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: vivified-secrets
              key: database-url

# docker-stack.yml
version: '3.8'
services:
  vivified:
    image: vivified/core:latest
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        delay: 10s
    environment:
      DATABASE_URL: ${DATABASE_URL}

{
  "family": "vivified",
  "taskDefinition": {
    "containerDefinitions": [{
      "name": "vivified-core",
      "image": "vivified/core:latest",
      "memory": 2048,
      "cpu": 1024,
      "essential": true
    }]
  }
}

Documentation

• Core Services - Gateway, Identity, Policy, Storage
• Plugin Development - SDK reference and examples
• Admin Console - Web-based management interface
• API Reference - REST, WebSocket, and RPC APIs
• Deployment Guide - Production deployment
• Troubleshooting - Common issues and solutions

Community

• GitHub Issues - Bug reports and feature requests
• Discussions - Questions and community support
• Contributing - Contribution guidelines

MIT License | GitHub