How oriondesign2015/setuporion works
1. What this repository is
This is not a single product application. It is a self-hosting installer and asset repository for OrionDesign’s stack of automation, marketing, CRM, AI, and observability tools. The README shows the intended entrypoint: a remote bootstrap script that provisions a selected set of services on a VPS.
2. Control-plane vs workload separation
The architecture is split between:
- the installer/orchestrator that prepares the server and deploys chosen tools
- the service bundles under Extras/ that provide configs, templates, migrations, and deployment assets for each tool
This is important for a diagram: the repo mostly supplies provisioning artifacts, not one centralized runtime.
3. Shared hosting layer
The README lists common platform services such as Traefik and Portainer, which act as the shared edge and container-management layer for the installed tools. In practice, the stack is designed for containerized deployment on a clean Ubuntu VPS with shared routing and isolated per-app runtime containers.
4. Supabase bundle
Extras/Supabase/docker/volumes/ contains a full self-hosted Supabase layout:
- api/kong.yml for the API gateway
- db/ SQL initialization and role/schema setup
- functions/ TypeScript edge functions
- logs/vector.yml for log shipping
- pooler/pooler.exs for connection pooling
This indicates Supabase is deployed as a multi-component platform with Postgres at the center, plus gateway, functions, logs, and pooling.
5. Monitoring bundle
Extras/Grafana/monitor-orion/ contains Grafana + Prometheus provisioning:
- Grafana dashboards and datasource provisioning
- Prometheus config
- prebuilt dashboard JSON
This is a classic observability sidecar stack meant to monitor the other deployed services rather than power business logic.
6. Zep bundle: a full embedded service
Extras/Zep/ is a complete Go codebase for Zep, a memory/LLM context service. Its internal structure is substantial:
- cmd/ application entry
- pkg/server/ HTTP routes, middleware, handlers
- pkg/store/postgres/ persistence and migrations
- pkg/tasks/ async processing and embeddings/summarization
- pkg/llms/ OpenAI, Anthropic, and local embedding providers
- web/ server-rendered admin UI
Zep is architected as a web/API service backed by Postgres, with background task processing and LLM integrations.
7. Zep data flow
Zep’s flow is: API requests enter the server, authenticate via JWT, hit domain handlers, persist or query via Postgres-backed stores, and trigger tasks for embedding, summarization, intent analysis, and NER. The web/ layer is an admin/ops UI on top of those same backend stores.
8. Integration and automation assets
Several Extras/Meets/ JSON files are automation workflow exports for N8N and Typebot. Extras/Chatwoot/emails/ contains email templates for account lifecycle actions. These are not standalone services; they are integration artifacts used to seed or configure flows around the installed stack.
9. Other bundled app-specific configs
Files like Extras/Krayin/app.php and the video/pdf materials under Extras/Arquivos de Videos/ are supporting assets and examples. They suggest the repo also acts as a knowledge and configuration pack for specific third-party tools, not just an installer.
10. Persistence and boundaries
Most workloads are designed to keep their own state in service-specific volumes or databases:
- Supabase owns its DB, functions, logs, and pooler configs
- Zep owns Postgres tables/migrations and app state
- Grafana/Prometheus keep monitoring state separately
The main architectural boundary is between the installer and the per-tool isolated runtime stacks.
11. What an architecture diagram should emphasize
A good diagram should show:
- a bootstrap installer entering through the Orion script
- a selection layer that deploys one or more tools
- a shared container/network edge for routing and management
- separate service stacks for Supabase, Grafana/Prometheus, Zep, Chatwoot, and other optional apps
- attached data stores, volumes, and config artifacts per stack
In short: this repo is a deployment platform and asset catalog for a multi-tool self-hosted environment.
Main entry points: SetupOrion SetupOrion · Supabase Supabase · server API server · grafana Grafana
Components 22
Installer
Bootstrap and orchestration entrypoints for provisioning the stack.
- SetupOrion · Remote entrypoint that starts provisioning on a VPS.
SetupOrion - Setup · Supporting installer material and provisioning helpers.
Setup
Shared platform
Common edge and management layer used by the deployed services.
- Shared edge · Common container edge for ingress and cross-service access.
- Portainer · Container administration layer for deployed workloads.
Service bundles
Self-hosted application stacks and their internal runtime components.
- Supabase · Self-hosted backend platform deployed as multiple coordinated containers.
Extras/Supabase - Gateway · Kong-based API edge for the Supabase stack.
Extras/Supabase/docker/volumes/api/kong.yml - Database · SQL initialization, roles, schemas, realtime, pooler, and webhook setup.
Extras/Supabase/docker/volumes/db - Functions · TypeScript serverless functions bundled with the Supabase deployment.
Extras/Supabase/docker/volumes/functions - Logs · Log shipping configuration for the Supabase stack.
Extras/Supabase/docker/volumes/logs/vector.yml - Pooler · Database pooler configuration for Supabase connectivity.
Extras/Supabase/docker/volumes/pooler/pooler.exs - Zep · Full Go service for memory, documents, sessions, and admin UI.
Extras/Zep - API server · JWT-protected routes, middleware, and handlers for Zep APIs.
Extras/Zep/pkg/server - Postgres store · Database-backed stores, schema, and migrations for Zep state.
Extras/Zep/pkg/store/postgres - Task pipeline · Embedding, summarization, NER, intent analysis, and queue handling.
Extras/Zep/pkg/tasks - LLM providers · OpenAI, Anthropic, and local embedding integrations.
Extras/Zep/pkg/llms - Admin UI · Rendered web interface for collections, sessions, users, and settings.
Extras/Zep/web - Grafana · Provisioned dashboard and datasource layer for observability.
Extras/Grafana/monitor-orion/grafana - Prometheus · Metrics collection configuration for monitoring the deployed stack.
Extras/Grafana/monitor-orion/prometheus
Supporting assets
Templates, workflows, docs, and example materials used to seed or configure services.
- Chatwoot emails · Email templates for account and lifecycle events.
Extras/Chatwoot/emails - Meets flows · N8N and Typebot automation exports for onboarding and bot transfer flows.
Extras/Meets - Krayin config · Application-specific configuration artifact for Krayin.
Extras/Krayin/app.php - Video assets · Supporting media and example materials for Supabase and related workflows.
Extras/Arquivos de Videos
Connections 25
- SetupOrion → Setup: boots · Installer entrypoint uses local setup assets and helpers.
- SetupOrion → Shared edge: provisions · Remote bootstrap prepares the shared routing layer.
- SetupOrion → Portainer: installs · Provisioning includes container management for the VPS.
- SetupOrion → Supabase: deploys · Installer can deploy the Supabase bundle.
- SetupOrion → Grafana: deploys · Installer can deploy observability components.
- SetupOrion → Zep: deploys · Installer can deploy the Zep service stack.
- Shared edge → Supabase: routes · Shared ingress exposes the app bundle.
- Shared edge → Zep: routes · Shared ingress exposes the Zep service.
- Shared edge → Grafana: routes · Shared ingress exposes dashboards and metrics UI.
- Supabase → Gateway: contains · Supabase API edge component.
- Supabase → Database: centers · Postgres initialization and service state are anchored here.
- Supabase → Functions: extends · Edge functions augment the platform API.
- Supabase → Logs: ships · Logs are handled through vector config.
- Supabase → Pooler: pools · Connection pooling is part of the bundle.
- Zep → API server: serves · HTTP backend handles API and route layers.
- API server → Postgres store: persists · Handlers read and write through Postgres stores.
- API server → Task pipeline: enqueues · Requests trigger async processing for embeddings and analysis.
- Task pipeline → LLM providers: calls · Task workers use LLM and embedding providers.
- API server → Admin UI: renders · Admin UI sits on top of the same backend services.
- Grafana → Prometheus: reads · Dashboards rely on metrics from Prometheus.
- Grafana → SetupOrion: observes · Monitoring bundle is intended to watch the provisioned stack.
- Chatwoot emails → SetupOrion: seeds · Email templates are consumed during setup or configuration.
- Meets flows → SetupOrion: automates · Workflow exports support adjacent automation around the installer.
- Krayin config → SetupOrion: configures · Application-specific config is bundled for installation support.
- Video assets → Supabase: documents · Training materials explain selected bundle usage.