Skip to content

mrkingsleyobi/jobnaut / .claude/skills/flow-nexus-neural

flow-nexus-neural

Verified

Train and deploy neural networks in distributed E2B sandboxes with Flow Nexus

Flow Nexus Neural Networks

Deploy, train, and manage neural networks in distributed E2B sandbox environments. Train custom models with multiple architectures (feedforward, LSTM, GAN, transformer) or use pre-built templates from the marketplace.

Prerequisites

# Add Flow Nexus MCP server
claude mcp add flow-nexus npx flow-nexus@latest mcp start

# Register and login
npx flow-nexus@latest register
npx flow-nexus@latest login

Core Capabilities

1. Single-Node Neural Training

Train neural networks with custom architectures and configurations.

Available Architectures:

  • feedforward - Standard fully-connected networks
  • lstm - Long Short-Term Memory for sequences
  • gan - Generative Adversarial Networks
  • autoencoder - Dimensionality reduction
  • transformer - Attention-based models

Training Tiers:

  • nano - Minimal resources (fast, limited)
  • mini - Small models
  • small - Standard models
  • medium - Complex models
  • large - Large-scale training

Example: Train Custom Classifier

mcp__flow -
  nexus__neural_train({
    config: {
      architecture: {
        type: 'feedforward',
        layers: [
          { type: 'dense', units: 256, activation: 'relu' },
          { type: 'dropout', rate: 0.3 },
          { type: 'dense', units: 128, activation: 'relu' },
          { type: 'dropout', rate: 0.2 },
          { type: 'dense', units: 64, activation: 'relu' },
          { type: 'dense', units: 10, activation: 'softmax' },
        ],
      },
      training: {
        epochs: 100,
        batch_size: 32,
        learning_rate: 0.001,
        optimizer: 'adam',
      },
      divergent: {
        enabled: true,
        pattern: 'lateral', // quantum, chaotic, associative, evolutionary
        factor: 0.5,
      },
    },
    tier: 'small',
    user_id: 'your_user_id',
  });

Example: LSTM for Time Series

mcp__flow -
  nexus__neural_train({
    config: {
      architecture: {
        type: 'lstm',
        layers: [
          { type: 'lstm', units: 128, return_sequences: true },
          { type: 'dropout', rate: 0.2 },
          { type: 'lstm', units: 64 },
          { type: 'dense', units: 1, activation: 'linear' },
        ],
      },
      training: {
        epochs: 150,
        batch_size: 64,
        learning_rate: 0.01,
        optimizer: 'adam',
      },
    },
    tier: 'medium',
  });

Example: Transformer Architecture

mcp__flow -
  nexus__neural_train({
    config: {
      architecture: {
        type: 'transformer',
        layers: [
          { type: 'embedding', vocab_size: 10000, embedding_dim: 512 },
          { type: 'transformer_encoder', num_heads: 8, ff_dim: 2048 },
          { type: 'global_average_pooling' },
          { type: 'dense', units: 128, activation: 'relu' },
          { type: 'dense', units: 2, activation: 'softmax' },
        ],
      },
      training: {
        epochs: 50,
        batch_size: 16,
        learning_rate: 0.0001,
        optimizer: 'adam',
      },
    },
    tier: 'large',
  });

2. Model Inference

Run predictions on trained models.

mcp__flow -
  nexus__neural_predict({
    model_id: 'model_abc123',
    input: [
      [0.5, 0.3, 0.2, 0.1],
      [0.8, 0.1, 0.05, 0.05],
      [0.2, 0.6, 0.15, 0.05],
    ],
    user_id: 'your_user_id',
  });

Response:

{
  "predictions": [
    [0.12, 0.85, 0.03],
    [0.89, 0.08, 0.03],
    [0.05, 0.92, 0.03]
  ],
  "inference_time_ms": 45,
  "model_version": "1.0.0"
}

3. Template Marketplace

Browse and deploy pre-trained models from the marketplace.

List Available Templates

mcp__flow -
  nexus__neural_list_templates({
    category: 'classification', // timeseries, regression, nlp, vision, anomaly, generative
    tier: 'free', // or "paid"
    search: 'sentiment',
    limit: 20,
  });

Response:

{
  "templates": [
    {
      "id": "sentiment-analysis-v2",
      "name": "Sentiment Analysis Classifier",
      "description": "Pre-trained BERT model for sentiment analysis",
      "category": "nlp",
      "accuracy": 0.94,
      "downloads": 1523,
      "tier": "free"
    },
    {
      "id": "image-classifier-resnet",
      "name": "ResNet Image Classifier",
      "description": "ResNet-50 for image classification",
      "category": "vision",
      "accuracy": 0.96,
      "downloads": 2341,
      "tier": "paid"
    }
  ]
}

Deploy Template

mcp__flow -
  nexus__neural_deploy_template({
    template_id: 'sentiment-analysis-v2',
    custom_config: {
      training: {
        epochs: 50,
        learning_rate: 0.0001,
      },
    },
    user_id: 'your_user_id',
  });

4. Distributed Training Clusters

Train large models across multiple E2B sandboxes with distributed computing.

Initialize Cluster

mcp__flow -
  nexus__neural_cluster_init({
    name: 'large-model-cluster',
    architecture: 'transformer', // transformer, cnn, rnn, gnn, hybrid
    topology: 'mesh', // mesh, ring, star, hierarchical
    consensus: 'proof-of-learning', // byzantine, raft, gossip
    daaEnabled: true, // Decentralized Autonomous Agents
    wasmOptimization: true,
  });

Response:

{
  "cluster_id": "cluster_xyz789",
  "name": "large-model-cluster",
  "status": "initializing",
  "topology": "mesh",
  "max_nodes": 100,
  "created_at": "2025-10-19T10:30:00Z"
}

Deploy Worker Nodes

// Deploy parameter server
mcp__flow -
  nexus__neural_node_deploy({
    cluster_id: 'cluster_xyz789',
    node_type: 'parameter_server',
    model: 'large',
    template: 'nodejs',
    capabilities: ['parameter_management', 'gradient_aggregation'],
    autonomy: 0.8,
  });

// Deploy worker nodes
mcp__flow -
  nexus__neural_node_deploy({
    cluster_id: 'cluster_xyz789',
    node_type: 'worker',
    model: 'xl',
    role: 'worker',
    capabilities: ['training', 'inference'],
    layers: [
      { type: 'transformer_encoder', num_heads: 16 },
      { type: 'feed_forward', units: 4096 },
    ],
    autonomy: 0.9,
  });

// Deploy aggregator
mcp__flow -
  nexus__neural_node_deploy({
    cluster_id: 'cluster_xyz789',
    node_type: 'aggregator',
    model: 'large',
    capabilities: ['gradient_aggregation', 'model_synchronization'],
  });

Connect Cluster Topology

mcp__flow -
  nexus__neural_cluster_connect({
    cluster_id: 'cluster_xyz789',
    topology: 'mesh', // Override default if needed
  });

Start Distributed Training

mcp__flow -
  nexus__neural_train_distributed({
    cluster_id: 'cluster_xyz789',
    dataset: 'imagenet', // or custom dataset identifier
    epochs: 100,
    batch_size: 128,
    learning_rate: 0.001,
    optimizer: 'adam', // sgd, rmsprop, adagrad
    federated: true, // Enable federated learning
  });

Federated Learning Example:

mcp__flow -
  nexus__neural_train_distributed({
    cluster_id: 'cluster_xyz789',
    dataset: 'medical_images_distributed',
    epochs: 200,
    batch_size: 64,
    learning_rate: 0.0001,
    optimizer: 'adam',
    federated: true, // Data stays on local nodes
    aggregation_rounds: 50,
    min_nodes_per_round: 5,
  });

Monitor Cluster Status

mcp__flow -
  nexus__neural_cluster_status({
    cluster_id: 'cluster_xyz789',
  });

Response:

{
  "cluster_id": "cluster_xyz789",
  "status": "training",
  "nodes": [
    {
      "node_id": "node_001",
      "type": "parameter_server",
      "status": "active",
      "cpu_usage": 0.75,
      "memory_usage": 0.82
    },
    {
      "node_id": "node_002",
      "type": "worker",
      "status": "active",
      "training_progress": 0.45
    }
  ],
  "training_metrics": {
    "current_epoch": 45,
    "total_epochs": 100,
    "loss": 0.234,
    "accuracy": 0.891
  }
}

Run Distributed Inference

mcp__flow -
  nexus__neural_predict_distributed({
    cluster_id: 'cluster_xyz789',
    input_data: JSON.stringify([
      [0.1, 0.2, 0.3],
      [0.4, 0.5, 0.6],
    ]),
    aggregation: 'ensemble', // mean, majority, weighted, ensemble
  });

Terminate Cluster

mcp__flow -
  nexus__neural_cluster_terminate({
    cluster_id: 'cluster_xyz789',
  });

5. Model Management

List Your Models

mcp__flow -
  nexus__neural_list_models({
    user_id: 'your_user_id',
    include_public: true,
  });

Response:

{
  "models": [
    {
      "model_id": "model_abc123",
      "name": "Custom Classifier v1",
      "architecture": "feedforward",
      "accuracy": 0.92,
      "created_at": "2025-10-15T14:20:00Z",
      "status": "trained"
    },
    {
      "model_id": "model_def456",
      "name": "LSTM Forecaster",
      "architecture": "lstm",
      "mse": 0.0045,
      "created_at": "2025-10-18T09:15:00Z",
      "status": "training"
    }
  ]
}

Check Training Status

mcp__flow -
  nexus__neural_training_status({
    job_id: 'job_training_xyz',
  });

Response:

{
  "job_id": "job_training_xyz",
  "status": "training",
  "progress": 0.67,
  "current_epoch": 67,
  "total_epochs": 100,
  "current_loss": 0.234,
  "estimated_completion": "2025-10-19T12:45:00Z"
}

Performance Benchmarking

mcp__flow -
  nexus__neural_performance_benchmark({
    model_id: 'model_abc123',
    benchmark_type: 'comprehensive', // inference, throughput, memory, comprehensive
  });

Response:

{
  "model_id": "model_abc123",
  "benchmarks": {
    "inference_latency_ms": 12.5,
    "throughput_qps": 8000,
    "memory_usage_mb": 245,
    "gpu_utilization": 0.78,
    "accuracy": 0.92,
    "f1_score": 0.89
  },
  "timestamp": "2025-10-19T11:00:00Z"
}

Create Validation Workflow

mcp__flow -
  nexus__neural_validation_workflow({
    model_id: 'model_abc123',
    user_id: 'your_user_id',
    validation_type: 'comprehensive', // performance, accuracy, robustness, comprehensive
  });

6. Publishing and Marketplace

Publish Model as Template

mcp__flow -
  nexus__neural_publish_template({
    model_id: 'model_abc123',
    name: 'High-Accuracy Sentiment Classifier',
    description: 'Fine-tuned BERT model for sentiment analysis with 94% accuracy',
    category: 'nlp',
    price: 0, // 0 for free, or credits amount
    user_id: 'your_user_id',
  });

Rate a Template

mcp__flow -
  nexus__neural_rate_template({
    template_id: 'sentiment-analysis-v2',
    rating: 5,
    review: 'Excellent model! Achieved 95% accuracy on my dataset.',
    user_id: 'your_user_id',
  });

Common Use Cases

Image Classification with CNN

// Initialize cluster for large-scale image training
const cluster =
  (await mcp__flow) -
  nexus__neural_cluster_init({
    name: 'image-classification-cluster',
    architecture: 'cnn',
    topology: 'hierarchical',
    wasmOptimization: true,
  });

// Deploy worker nodes
(await mcp__flow) -
  nexus__neural_node_deploy({
    cluster_id: cluster.cluster_id,
    node_type: 'worker',
    model: 'large',
    capabilities: ['training', 'data_augmentation'],
  });

// Start training
(await mcp__flow) -
  nexus__neural_train_distributed({
    cluster_id: cluster.cluster_id,
    dataset: 'custom_images',
    epochs: 100,
    batch_size: 64,
    learning_rate: 0.001,
    optimizer: 'adam',
  });

NLP Sentiment Analysis

// Use pre-built template
const deployment =
  (await mcp__flow) -
  nexus__neural_deploy_template({
    template_id: 'sentiment-analysis-v2',
    custom_config: {
      training: {
        epochs: 30,
        batch_size: 16,
      },
    },
  });

// Run inference
const result =
  (await mcp__flow) -
  nexus__neural_predict({
    model_id: deployment.model_id,
    input: ['This product is amazing!', 'Terrible experience.'],
  });

Time Series Forecasting

// Train LSTM model
const training =
  (await mcp__flow) -
  nexus__neural_train({
    config: {
      architecture: {
        type: 'lstm',
        layers: [
          { type: 'lstm', units: 128, return_sequences: true },
          { type: 'dropout', rate: 0.2 },
          { type: 'lstm', units: 64 },
          { type: 'dense', units: 1 },
        ],
      },
      training: {
        epochs: 150,
        batch_size: 64,
        learning_rate: 0.01,
        optimizer: 'adam',
      },
    },
    tier: 'medium',
  });

// Monitor progress
const status =
  (await mcp__flow) -
  nexus__neural_training_status({
    job_id: training.job_id,
  });

Federated Learning for Privacy

// Initialize federated cluster
const cluster =
  (await mcp__flow) -
  nexus__neural_cluster_init({
    name: 'federated-medical-cluster',
    architecture: 'transformer',
    topology: 'mesh',
    consensus: 'proof-of-learning',
    daaEnabled: true,
  });

// Deploy nodes across different locations
for (let i = 0; i < 5; i++) {
  (await mcp__flow) -
    nexus__neural_node_deploy({
      cluster_id: cluster.cluster_id,
      node_type: 'worker',
      model: 'large',
      autonomy: 0.9,
    });
}

// Train with federated learning (data never leaves nodes)
(await mcp__flow) -
  nexus__neural_train_distributed({
    cluster_id: cluster.cluster_id,
    dataset: 'medical_records_distributed',
    epochs: 200,
    federated: true,
    aggregation_rounds: 100,
  });

Architecture Patterns

Feedforward Networks

Best for: Classification, regression, simple pattern recognition

{
  type: "feedforward",
  layers: [
    { type: "dense", units: 256, activation: "relu" },
    { type: "dropout", rate: 0.3 },
    { type: "dense", units: 128, activation: "relu" },
    { type: "dense", units: 10, activation: "softmax" }
  ]
}

LSTM Networks

Best for: Time series, sequences, forecasting

{
  type: "lstm",
  layers: [
    { type: "lstm", units: 128, return_sequences: true },
    { type: "lstm", units: 64 },
    { type: "dense", units: 1 }
  ]
}

Transformers

Best for: NLP, attention mechanisms, large-scale text

{
  type: "transformer",
  layers: [
    { type: "embedding", vocab_size: 10000, embedding_dim: 512 },
    { type: "transformer_encoder", num_heads: 8, ff_dim: 2048 },
    { type: "global_average_pooling" },
    { type: "dense", units: 2, activation: "softmax" }
  ]
}

GANs

Best for: Generative tasks, image synthesis

{
  type: "gan",
  generator_layers: [...],
  discriminator_layers: [...]
}

Autoencoders

Best for: Dimensionality reduction, anomaly detection

{
  type: "autoencoder",
  encoder_layers: [
    { type: "dense", units: 128, activation: "relu" },
    { type: "dense", units: 64, activation: "relu" }
  ],
  decoder_layers: [
    { type: "dense", units: 128, activation: "relu" },
    { type: "dense", units: input_dim, activation: "sigmoid" }
  ]
}

Best Practices

  1. Start Small: Begin with nano or mini tiers for experimentation
  2. Use Templates: Leverage marketplace templates for common tasks
  3. Monitor Training: Check status regularly to catch issues early
  4. Benchmark Models: Always benchmark before production deployment
  5. Distributed Training: Use clusters for large models (>1B parameters)
  6. Federated Learning: Use for privacy-sensitive data
  7. Version Models: Publish successful models as templates for reuse
  8. Validate Thoroughly: Use validation workflows before deployment

Troubleshooting

Training Stalled

// Check cluster status
const status =
  (await mcp__flow) -
  nexus__neural_cluster_status({
    cluster_id: 'cluster_id',
  });

// Terminate and restart if needed
(await mcp__flow) -
  nexus__neural_cluster_terminate({
    cluster_id: 'cluster_id',
  });

Low Accuracy

  • Increase epochs
  • Adjust learning rate
  • Add regularization (dropout)
  • Try different optimizer
  • Use data augmentation

Out of Memory

  • Reduce batch size
  • Use smaller model tier
  • Enable gradient accumulation
  • Use distributed training

Related Skills

  • flow-nexus-sandbox - E2B sandbox management
  • flow-nexus-swarm - AI swarm orchestration
  • flow-nexus-workflow - Workflow automation

Resources


Note: Distributed training requires authentication. Register at https://flow-nexus.ruv.io or use npx flow-nexus@latest register.

writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deploymentStars: 322kUpdated Claude CodeCodexVerifiedInstall
xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved.Stars: 198kUpdated Claude CodeCodexVerifiedInstall
shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.Stars: 119kUpdated Claude CodeCodexVerifiedInstall
childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release.Stars: 118kUpdated Claude CodeCodexVerifiedInstall