Meta

The Meta molecule provides sample abstract entity types for organizational modeling in SixDegree. These entities represent business concepts like Projects, Teams, Services, and Domains that aren't tied to a specific system of record.

Unlike other molecules that discover entities from external systems (GitHub, Kubernetes, etc.), the Meta molecule reads entity definitions from YAML files. This allows organizations to define their entities declaratively and link them to concrete implementations discovered by other molecules.

Kind	Description
`MetaProject`	Business initiatives that span multiple services and teams
`MetaTeam`	Teams responsible for services, components, or domains
`MetaService`	Logical services (may map to multiple deployments)
`MetaDomain`	Business domains / bounded contexts
`MetaComponent`	Libraries, modules, subsystems within services
`MetaAPI`	API contracts (REST, GraphQL, gRPC, events)
`MetaEnvironment`	Deployment environments (production, staging, dev)
`MetaResource`	Generic type for custom entities

discovery:
  enabled: true
  settings:
    paths:
      - /path/to/meta-files
      - /another/directory

The molecule recursively scans all configured paths for .yaml and .yml files.

Meta files use a Kubernetes-like format with apiVersion, kind, metadata, and spec:

apiVersion: meta.sixdegree.ai/v1
kind: Service
metadata:
  name: payment-gateway
  description: Core payment gateway service
  tags:
    - critical
    - pci
  links:
    - title: Runbook
      url: https://wiki.example.com/runbooks/payment-gateway
spec:
  owner: payments          # Team that owns this service
  domain: payments         # Business domain
  lifecycle: production    # Lifecycle stage
  tier: 1                  # Service tier (1 = critical)
  dependsOn:               # Service dependencies
    - payment-processor
    - fraud-detection
  providesApis:            # APIs this service exposes
    - payments-api
  consumesApis:            # APIs this service consumes
    - user-api
  environments:            # Environments where deployed
    - production
    - staging

Multiple documents can be in a single file, separated by ---.

These relations are created directly from YAML definitions:

Relation	Source	Target	Created From
`OWNS`	MetaTeam	Service/Component	`spec.owner`
`PART_OF`	Service	MetaDomain	`spec.domain`
`PART_OF`	Component	MetaService	`spec.partOf`
`DEPENDS_ON`	Service	Service	`spec.dependsOn[]`
`PROVIDES`	Service	MetaAPI	`spec.providesApis[]`
`CONSUMES`	Service	MetaAPI	`spec.consumesApis[]`
`DEPLOYED_TO`	Service	MetaEnvironment	`spec.environments[]`

The Meta molecule provides rules to automatically link abstract entities to concrete entities from other molecules:

Rule	Relation	Links To
`meta-service-to-github-repo`	`MANAGED_BY`	GitHubRepository
`meta-service-to-k8s-deployment`	`IMPLEMENTED_BY`	K8sDeployment
`meta-service-to-argo-app`	`IMPLEMENTED_BY`	ArgoApplication
`meta-service-to-docker-image`	`IMPLEMENTED_BY`	DockerImage
`meta-service-to-grafana-dashboard`	`MONITORED_BY`	GrafanaDashboard
`meta-service-to-pagerduty-service`	`ALERTED_BY`	PagerDutyService
`meta-service-to-sentry-project`	`ALERTED_BY`	SentryProject
`meta-service-to-slack-channel`	`NOTIFIES`	SlackChannel

Rule	Relation	Links To
`meta-team-to-slack-channel`	`COMMUNICATES_VIA`	SlackChannel
`meta-team-to-pagerduty-policy`	`ON_CALL_FOR`	PagerDutyEscalationPolicy

Rules use name matching to infer relationships. For example, a MetaService named payment-gateway will be linked to:

A GitHubRepository named payment-gateway or containing payment-gateway
A K8sDeployment named payment-gateway or payment-gateway-*
A SlackChannel containing payment-gateway in its name

meta/
├── domains/
│   ├── payments.yaml
│   └── platform.yaml
├── teams/
│   ├── payments-team.yaml
│   └── platform-team.yaml
├── services/
│   ├── payment-gateway.yaml
│   ├── payment-processor.yaml
│   └── fraud-detection.yaml
├── apis/
│   └── payments-api.yaml
└── environments/
    ├── production.yaml
    └── staging.yaml

Or consolidate into fewer files:

meta/
├── payments-domain.yaml    # All payments entities
├── platform-domain.yaml    # All platform entities
└── environments.yaml       # All environments

The Meta molecule format is designed to be compatible with Backstage catalog files. If you have existing Backstage catalog files, they can be adapted with minimal changes:

Change apiVersion from backstage.io/v1alpha1 to meta.sixdegree.ai/v1
Entity kinds are the same (Service, Component, API, etc.)
Most spec fields are preserved as-is
Use consistent naming: Service names should match repository names, deployment names, and Slack channel names for automatic linking to work
Define ownership: Always specify owner to establish team responsibility
Document dependencies: Use dependsOn to capture service relationships
Tag appropriately: Use tags for filtering and grouping (e.g., critical, pci, public)
Add links: Include runbooks, documentation, and dashboards in metadata.links