NornicDB Feature Flags¶

# Disable if causing performance issues (not recommended)
export NORNICDB_EDGE_PROVENANCE_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

// Check status
if config.IsEdgeProvenanceEnabled() {
    // Provenance logging is active
}

// Toggle at runtime
config.EnableEdgeProvenance()
config.DisableEdgeProvenance()

// Scoped disable for testing
cleanup := config.WithEdgeProvenanceDisabled()
defer cleanup()
// ... test code without provenance ...

# Disable if edges aren't being created when expected
export NORNICDB_COOLDOWN_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

// Check status
if config.IsCooldownEnabled() {
    // Cooldown is active
}

// Toggle at runtime
config.EnableCooldown()
config.DisableCooldown()

// Scoped disable for testing
cleanup := config.WithCooldownDisabled()
defer cleanup()

# Disable if edges aren't appearing after expected activity
export NORNICDB_EVIDENCE_BUFFERING_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

// Check status
if config.IsEvidenceBufferingEnabled() {
    // Evidence buffering is active
}

// Toggle at runtime
config.EnableEvidenceBuffering()
config.DisableEvidenceBuffering()

// Scoped disable for testing
cleanup := config.WithEvidenceBufferingDisabled()
defer cleanup()

# Disable if per-node rules are causing unexpected behavior
export NORNICDB_PER_NODE_CONFIG_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

// Check status
if config.IsPerNodeConfigEnabled() {
    // Per-node config is active
}

// Toggle at runtime
config.EnablePerNodeConfig()
config.DisablePerNodeConfig()

// Scoped disable for testing
cleanup := config.WithPerNodeConfigDisabled()
defer cleanup()

# Disable for maximum performance (data loss risk on crash)
export NORNICDB_WAL_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

// Check status
if config.IsWALEnabled() {
    // WAL is active
}

// Toggle at runtime
config.EnableWAL()
config.DisableWAL()

// Scoped disable for testing
cleanup := config.WithWALDisabled()
defer cleanup()

# Disable (server will fail fast instead of rebuilding from WAL/snapshots)
export NORNICDB_AUTO_RECOVER_ON_CORRUPTION=false

# Force an attempt when Badger open fails (requires WAL/snapshots to exist)
export NORNICDB_AUTO_RECOVER_ON_CORRUPTION=true

# Disable automatic integration (manual use still works)
export NORNICDB_COOLDOWN_AUTO_INTEGRATION_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsCooldownAutoIntegrationEnabled() {
    // Cooldown automatically checked in ProcessSuggestion()
}

// Direct access to CooldownTable always works
engine.GetCooldownTable().CanMaterialize(src, dst, label)

# Disable automatic integration
export NORNICDB_EVIDENCE_AUTO_INTEGRATION_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsEvidenceAutoIntegrationEnabled() {
    // Evidence automatically tracked in ProcessSuggestion()
}

// Direct access to EvidenceBuffer always works
engine.GetEvidenceBuffer().AddEvidence(src, dst, label, score, signalType, sessionID)

# Disable automatic logging
export NORNICDB_EDGE_PROVENANCE_AUTO_INTEGRATION_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsEdgeProvenanceAutoIntegrationEnabled() {
    // Provenance automatically logged in ProcessSuggestion()
}

// Direct access to EdgeMetaStore always works
engine.GetEdgeMetaStore().Append(ctx, meta)

# Disable automatic checking
export NORNICDB_PER_NODE_CONFIG_AUTO_INTEGRATION_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsPerNodeConfigAutoIntegrationEnabled() {
    // Per-node rules automatically checked in ProcessSuggestion()
}

// Direct access to NodeConfigStore always works
engine.GetNodeConfigStore().IsEdgeAllowed(src, dst, label)

# Adjust cache size (default: 10000)
export NORNICDB_EMBEDDING_CACHE_SIZE=10000

# Disable caching entirely
export NORNICDB_EMBEDDING_CACHE_SIZE=0

# Increase for heavy workloads
export NORNICDB_EMBEDDING_CACHE_SIZE=50000

# Set cache size via CLI
nornicdb serve --embedding-cache 10000

# Disable caching
nornicdb serve --embedding-cache 0

# Disable for strong consistency (writes block until persisted)
export NORNICDB_ASYNC_WRITES_ENABLED=false

# Enable with default 50ms flush interval
export NORNICDB_ASYNC_WRITES_ENABLED=true

# Adjust flush interval (lower = more consistent, higher = better throughput)
export NORNICDB_ASYNC_FLUSH_INTERVAL=100ms

config := nornicdb.DefaultConfig()

// Disable async writes for strong consistency
config.AsyncWritesEnabled = false

// Or enable with custom flush interval
config.AsyncWritesEnabled = true
config.AsyncFlushInterval = 50 * time.Millisecond

db, err := nornicdb.Open("./data", config)

# Enable Kalman filtering
export NORNICDB_KALMAN_ENABLED=true

import "github.com/orneryd/nornicdb/pkg/config"

// Check status
if config.IsKalmanEnabled() {
    // Kalman filtering is active
}

// Enable all Kalman features
config.EnableKalmanFiltering()

// Enable specific sub-features
config.EnableFeature(config.FeatureKalmanDecay)
config.EnableFeature(config.FeatureKalmanCoAccess)
config.EnableFeature(config.FeatureKalmanLatency)
config.EnableFeature(config.FeatureKalmanSimilarity)
config.EnableFeature(config.FeatureKalmanTemporal)

// Scoped enable for testing
cleanup := config.WithKalmanEnabled()
defer cleanup()

# Enable automatic relationship inference
export NORNICDB_AUTO_TLP_ENABLED=true

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsAutoTLPEnabled() {
    // Auto-TLP is active, relationships are inferred and materialized
}

// Direct access to TLP engine
engine.GetTLP().InferRelationship(src, dst, label, confidence)

# Enable Heimdall review of TLP suggestions
export NORNICDB_AUTO_TLP_ENABLED=true
export NORNICDB_AUTO_TLP_LLM_QC_ENABLED=true

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsAutoTLPLLMQCEnabled() {
    // Heimdall will review TLP suggestions before edge creation
}

// Toggle at runtime
config.EnableAutoTLPLLMQC()
config.DisableAutoTLPLLMQC()

// Scoped enable for testing
cleanup := config.WithAutoTLPLLMQCEnabled()
defer cleanup()

{
  "approved": [0, 2],
  "rejected": [1],
  "type_overrides": {"0": "SIMILAR_TO"},
  "reasoning": "First is semantically related, second is unrelated task"
}

# Full hybrid mode: TLP + Heimdall review + augmentation
export NORNICDB_AUTO_TLP_ENABLED=true
export NORNICDB_AUTO_TLP_LLM_QC_ENABLED=true
export NORNICDB_AUTO_TLP_LLM_AUGMENT_ENABLED=true

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsAutoTLPLLMAugmentEnabled() {
    // Heimdall can suggest NEW edges beyond TLP's candidates
}

// Toggle at runtime
config.EnableAutoTLPLLMAugment()
config.DisableAutoTLPLLMAugment()

{
  "additional": [
    {"target_id": "node-999", "type": "INSPIRED_BY", "conf": 0.8, "reason": "Both discuss backpropagation"}
  ]
}

# Enable GPU-accelerated clustering
export NORNICDB_KMEANS_CLUSTERING_ENABLED=true

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsGPUClusteringEnabled() {
    // GPU clustering is active
}

// Direct access to clustering engine
engine.GetClusteringEngine().Cluster(embeddings)

# Disable edge decay
export NORNICDB_EDGE_DECAY_ENABLED=false

import "github.com/orneryd/nornicdb/pkg/config"

if config.IsEdgeDecayEnabled() {
    // Edge decay is active
}

// Direct access to decay engine
engine.GetDecayEngine().ApplyDecay(graph)

# Enable LLM quality control for Auto-TLP
export NORNICDB_AUTO_TLP_LLM_QC_ENABLED=true

import (
    "github.com/orneryd/nornicdb/pkg/config"
    "github.com/orneryd/nornicdb/pkg/inference"
)

if config.IsAutoTLPLLMQCEnabled() {
    // Heimdall QC is validating edge suggestions
}

// Setup Heimdall QC
qc := inference.NewHeimdallQC(func(ctx context.Context, prompt string) (string, error) {
    return ollamaClient.Complete(ctx, prompt)
}, nil)

engine.SetHeimdallQC(qc)

// Now OnStore/OnAccess suggestions are validated by Heimdall
suggestions, _ := engine.OnStore(ctx, nodeID, embedding)
// Only approved suggestions are returned

{
  "approved": true,
  "confidence": 0.85,
  "relation_type": "SIMILAR_TO",
  "reasoning": "Both nodes discuss machine learning topics"
}

# docker-compose.yml
services:
  nornicdb:
    image: nornicdb:latest
    environment:
      # Tier 1 - All enabled by default, uncomment to disable
      # NORNICDB_EDGE_PROVENANCE_ENABLED: "false"
      # NORNICDB_COOLDOWN_ENABLED: "false"
      # NORNICDB_EVIDENCE_BUFFERING_ENABLED: "false"
      # NORNICDB_PER_NODE_CONFIG_ENABLED: "false"
      # NORNICDB_WAL_ENABLED: "false"

      # Performance - Embedding cache (default: 10000, 0 to disable)
      NORNICDB_EMBEDDING_CACHE_SIZE: "10000"

      # Auto-Integration - All enabled by default, uncomment to disable
      # NORNICDB_COOLDOWN_AUTO_INTEGRATION_ENABLED: "false"
      # NORNICDB_EVIDENCE_AUTO_INTEGRATION_ENABLED: "false"
      # NORNICDB_EDGE_PROVENANCE_AUTO_INTEGRATION_ENABLED: "false"
      # NORNICDB_PER_NODE_CONFIG_AUTO_INTEGRATION_ENABLED: "false"

      # Experimental - Disabled by default, uncomment to enable
      # NORNICDB_KALMAN_ENABLED: "true"
      # NORNICDB_AUTO_TLP_ENABLED: "true"
      # NORNICDB_KMEANS_CLUSTERING_ENABLED: "true"
      # NORNICDB_EDGE_DECAY_ENABLED: "false"

package main

import (
    "github.com/orneryd/nornicdb/pkg/config"
    "github.com/orneryd/nornicdb/pkg/inference"
    "github.com/orneryd/nornicdb/pkg/storage"
)

func main() {
    // Check current state
    status := config.GetFeatureStatus()

    // Tier 1 features (enabled by default)
    println("Edge Provenance:", status.EdgeProvenanceEnabled)    // true
    println("Cooldown:", status.CooldownEnabled)                  // true
    println("Evidence Buffering:", status.EvidenceBufferingEnabled) // true
    println("Per-Node Config:", status.PerNodeConfigEnabled)      // true
    println("WAL:", status.WALEnabled)                            // true

    // Experimental features (disabled by default)
    println("Kalman:", status.KalmanEnabled)                      // false
    println("Auto-TLP:", status.AutoTLPEnabled)                  // false
    println("GPU Clustering:", status.GPUClusteringEnabled)      // false
    println("Edge Decay:", status.EdgeDecayEnabled)              // true

    // Runtime configuration
    config.EnableKalmanFiltering()
    config.EnableAutoTLP()
    config.EnableGPUClustering()
    config.DisableEdgeDecay()

    // Disable specific feature if issues occur
    config.DisableCooldown()

    // Check specific feature
    if config.IsWALEnabled() {
        // Set up WAL-backed storage
        wal, _ := storage.NewWAL("/data/wal", nil)
        engine := storage.NewWALEngine(storage.NewMemoryEngine(), wal)
        _ = engine
    }

    // Use inference engine with auto-integration
    inferEngine := inference.New(nil)

    // All Tier 1 features automatically integrate:
    // - Cooldown checked before materialization
    // - Evidence accumulated before materialization
    // - Provenance logged for audit trails
    // - Per-node rules enforced

    result := inferEngine.ProcessSuggestion(inference.EdgeSuggestion{
        SourceID:   "node-A",
        TargetID:   "node-B",
        Type:       "RELATES_TO",
        Confidence: 0.85,
    }, "session-123")

    println("Should Materialize:", result.ShouldMaterialize)
    println("Cooldown Blocked:", result.CooldownBlocked)
    println("Evidence Pending:", result.EvidencePending)
    println("Node Config Blocked:", result.NodeConfigBlocked)
}

// Get complete feature status
status := config.GetFeatureStatus()

// FeatureStatus struct
type FeatureStatus struct {
    GlobalEnabled                bool // Kalman master switch
    AutoTLPEnabled               bool
    GPUClusteringEnabled         bool
    EdgeDecayEnabled             bool
    EdgeProvenanceEnabled        bool
    CooldownEnabled              bool
    EvidenceBufferingEnabled     bool
    PerNodeConfigEnabled         bool
    WALEnabled                   bool
    KalmanEnabled                bool
    Features                     map[string]bool // All sub-features
}

// List enabled features
features := config.GetEnabledFeatures()
for _, f := range features {
    println("Enabled:", f)
}

func TestWithKalman(t *testing.T) {
    // Temporarily enable
    cleanup := config.WithKalmanEnabled()
    defer cleanup()

    // Test code with Kalman enabled
}

func TestWithoutWAL(t *testing.T) {
    // Temporarily disable
    cleanup := config.WithWALDisabled()
    defer cleanup()

    // Test code without WAL
}

func TestResetAll(t *testing.T) {
    // Reset all flags to defaults
    config.ResetFeatureFlags()
}