Agent skill

cloud-neural

Neural network training and deployment in Flow Nexus cloud. Use for distributed ML training, model inference, and neural network lifecycle management.

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/cloud-neural

SKILL.md

Cloud Neural Network

Train, deploy, and manage neural networks at scale using Flow Nexus cloud-powered distributed computing.

Quick Start

javascript
// Train a basic neural network
mcp__flow-nexus__neural_train({
  config: {
    architecture: {
      type: "feedforward",
      layers: [
        { type: "dense", units: 128, activation: "relu" },
        { type: "dropout", rate: 0.2 },
        { type: "dense", units: 10, activation: "softmax" }
      ]
    },
    training: { epochs: 100, batch_size: 32, learning_rate: 0.001 }
  },
  tier: "small"
})

// Run inference
mcp__flow-nexus__neural_predict({
  model_id: "trained_model_id",
  input: [[0.5, 0.3, 0.2]]
})

When to Use

  • Training neural networks for classification, regression, or generation tasks
  • Deploying distributed training across multiple cloud sandboxes
  • Running model inference on trained models
  • Managing model lifecycle from training to production deployment
  • Implementing federated learning or ensemble methods
  • Fine-tuning pre-trained models for specific domains

Prerequisites

  • Flow Nexus account with active session
  • MCP server flow-nexus configured
  • Sufficient rUv credits for training tier selected

Core Concepts

Neural Architectures

Type Use Case
Feedforward Classification, regression
LSTM/RNN Time series, NLP sequences
Transformer Advanced NLP, multimodal
CNN Computer vision, image processing
GAN Data generation, augmentation
Autoencoder Dimensionality reduction, anomaly detection

Training Tiers

Tier Resources Cost
nano Minimal, quick tests Low
mini Small models Low
small Standard training Medium
medium Large models High
large Production scale Highest

Distributed Consensus Protocols

  • proof-of-learning: Training contribution verification
  • byzantine: Fault-tolerant distributed consensus
  • raft: Leader-based coordination
  • gossip: Decentralized information propagation

MCP Tools Reference

Single-Node Training

javascript
mcp__flow-nexus__neural_train({
  config: {
    architecture: {
      type: "feedforward",  // lstm, gan, autoencoder, transformer
      layers: [
        { type: "dense", units: 128, activation: "relu" },
        { type: "dropout", rate: 0.2 },
        { type: "dense", units: 10, activation: "softmax" }
      ]
    },
    training: {
      epochs: 100,
      batch_size: 32,
      learning_rate: 0.001,
      optimizer: "adam"
    },
    divergent: {
      enabled: false,
      pattern: "lateral",  // quantum, chaotic, associative, evolutionary
      factor: 0.1
    }
  },
  tier: "small",            // nano, mini, small, medium, large
  user_id: "user_id"
})

Distributed Cluster Training

javascript
// Initialize distributed cluster
mcp__flow-nexus__neural_cluster_init({
  name: "training-cluster",
  architecture: "transformer",  // transformer, cnn, rnn, gnn, hybrid
  topology: "mesh",             // mesh, ring, star, hierarchical
  consensus: "proof-of-learning",
  daaEnabled: true,
  wasmOptimization: true
})

// Deploy worker nodes
mcp__flow-nexus__neural_node_deploy({
  cluster_id: "cluster_id",
  node_type: "worker",    // worker, parameter_server, aggregator, validator
  model: "base",          // base, large, xl, custom
  capabilities: ["training", "inference"],
  autonomy: 0.8
})

// Connect nodes based on topology
mcp__flow-nexus__neural_cluster_connect({
  cluster_id: "cluster_id",
  topology: "mesh"
})

// Start distributed training
mcp__flow-nexus__neural_train_distributed({
  cluster_id: "cluster_id",
  dataset: "dataset_id",
  epochs: 10,
  batch_size: 32,
  learning_rate: 0.001,
  optimizer: "adam",
  federated: false
})

// Check cluster status
mcp__flow-nexus__neural_cluster_status({ cluster_id: "cluster_id" })

// Terminate when done
mcp__flow-nexus__neural_cluster_terminate({ cluster_id: "cluster_id" })

Inference

javascript
// Single-node inference
mcp__flow-nexus__neural_predict({
  model_id: "model_id",
  input: [[0.5, 0.3, 0.2]],
  user_id: "user_id"
})

// Distributed inference
mcp__flow-nexus__neural_predict_distributed({
  cluster_id: "cluster_id",
  input_data: "[0.5, 0.3, 0.2]",
  aggregation: "mean"  // mean, majority, weighted, ensemble
})

Template Management

javascript
// List templates
mcp__flow-nexus__neural_list_templates({
  category: "classification",  // timeseries, regression, nlp, vision, anomaly, generative, reinforcement, custom
  tier: "free",               // free, paid
  search: "sentiment",
  limit: 20
})

// Deploy template
mcp__flow-nexus__neural_deploy_template({
  template_id: "template_id",
  custom_config: { epochs: 50 },
  user_id: "user_id"
})

// Publish your model as template
mcp__flow-nexus__neural_publish_template({
  model_id: "model_id",
  name: "Sentiment Analyzer",
  description: "LSTM-based sentiment analysis model",
  category: "nlp",
  price: 0,
  user_id: "user_id"
})

// Rate a template
mcp__flow-nexus__neural_rate_template({
  template_id: "template_id",
  rating: 5,
  review: "Excellent model, fast and accurate",
  user_id: "user_id"
})

Model Management

javascript
// List user models
mcp__flow-nexus__neural_list_models({
  user_id: "user_id",
  include_public: false
})

// Check training status
mcp__flow-nexus__neural_training_status({ job_id: "job_id" })

// Create validation workflow
mcp__flow-nexus__neural_validation_workflow({
  model_id: "model_id",
  validation_type: "comprehensive",  // performance, accuracy, robustness, comprehensive
  user_id: "user_id"
})

// Run performance benchmarks
mcp__flow-nexus__neural_performance_benchmark({
  model_id: "model_id",
  benchmark_type: "comprehensive"  // inference, throughput, memory, comprehensive
})

Usage Examples

Example 1: Classification Model Training

javascript
// Train a feedforward classifier
const trainingJob = await mcp__flow-nexus__neural_train({
  config: {
    architecture: {
      type: "feedforward",
      layers: [
        { type: "dense", units: 256, activation: "relu" },
        { type: "batch_norm" },
        { type: "dropout", rate: 0.3 },
        { type: "dense", units: 128, activation: "relu" },
        { type: "dropout", rate: 0.2 },
        { type: "dense", units: 10, activation: "softmax" }
      ]
    },
    training: {
      epochs: 100,
      batch_size: 64,
      learning_rate: 0.001,
      optimizer: "adam"
    }
  },
  tier: "small"
});

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

console.log(`Epoch: ${status.current_epoch}, Loss: ${status.loss}`);

// Run inference on trained model
const prediction = await mcp__flow-nexus__neural_predict({
  model_id: trainingJob.model_id,
  input: [[0.1, 0.2, 0.3, 0.4, 0.5]]
});

Example 2: Distributed Transformer Training

javascript
// Initialize distributed cluster
const cluster = await mcp__flow-nexus__neural_cluster_init({
  name: "transformer-cluster",
  architecture: "transformer",
  topology: "mesh",
  consensus: "proof-of-learning",
  daaEnabled: true,
  wasmOptimization: true
});

// Deploy 4 worker nodes
for (let i = 0; i < 4; i++) {
  await mcp__flow-nexus__neural_node_deploy({
    cluster_id: cluster.cluster_id,
    node_type: "worker",
    model: "large",
    capabilities: ["training", "inference"]
  });
}

// Deploy parameter server
await mcp__flow-nexus__neural_node_deploy({
  cluster_id: cluster.cluster_id,
  node_type: "parameter_server",
  model: "base"
});

// Connect nodes
await mcp__flow-nexus__neural_cluster_connect({
  cluster_id: cluster.cluster_id
});

// Start distributed training
await mcp__flow-nexus__neural_train_distributed({
  cluster_id: cluster.cluster_id,
  dataset: "large_nlp_dataset",
  epochs: 50,
  batch_size: 128,
  learning_rate: 0.0001,
  optimizer: "adam"
});

// Monitor and validate
const clusterStatus = await mcp__flow-nexus__neural_cluster_status({
  cluster_id: cluster.cluster_id
});

// Cleanup
await mcp__flow-nexus__neural_cluster_terminate({
  cluster_id: cluster.cluster_id
});

Example 3: Using Pre-built Templates

javascript
// Find NLP templates
const templates = await mcp__flow-nexus__neural_list_templates({
  category: "nlp",
  tier: "free",
  search: "sentiment"
});

// Deploy the best-rated template
const deployment = await mcp__flow-nexus__neural_deploy_template({
  template_id: templates.templates[0].id,
  custom_config: {
    epochs: 25,
    learning_rate: 0.0005
  }
});

// Validate model performance
await mcp__flow-nexus__neural_validation_workflow({
  model_id: deployment.model_id,
  validation_type: "comprehensive"
});

// Benchmark performance
const benchmark = await mcp__flow-nexus__neural_performance_benchmark({
  model_id: deployment.model_id,
  benchmark_type: "comprehensive"
});

console.log(`Inference latency: ${benchmark.inference_latency_ms}ms`);

Execution Checklist

  • Design neural architecture for task requirements
  • Select appropriate training tier based on model size
  • Configure training hyperparameters
  • Initialize training (single or distributed)
  • Monitor training progress and metrics
  • Validate model performance
  • Run benchmarks for production readiness
  • Deploy for inference or publish as template
  • Cleanup cluster resources when complete

Best Practices

  1. Start Small: Begin with nano or mini tier for testing, scale up for production
  2. Proper Validation: Always run validation workflow before production deployment
  3. Hyperparameter Tuning: Use grid search or Bayesian optimization for best results
  4. Distributed Training: Use for large models; single-node for smaller experiments
  5. Checkpoint Frequently: Enable checkpointing for long training runs
  6. Monitor Drift: Implement drift detection for production models

Error Handling

Error Cause Solution
training_failed Invalid architecture config Verify layer compatibility and types
cluster_init_failed Invalid topology or architecture Check supported combinations
insufficient_credits Training tier exceeds balance Reduce tier or add credits
model_not_found Invalid model_id Use neural_list_models to verify
node_deploy_failed Cluster capacity reached Terminate unused nodes

Metrics & Success Criteria

  • Training Convergence: Loss decreasing over epochs
  • Validation Accuracy: Target >90% for classification
  • Inference Latency: <100ms for production
  • Memory Efficiency: <80% resource utilization
  • Model Size: Appropriate for deployment target

Integration Points

With Swarms

javascript
// Deploy neural agent in swarm
await mcp__flow-nexus__agent_spawn({
  type: "analyst",
  name: "ML Analyst",
  capabilities: ["neural_training", "model_evaluation"]
});

With Workflows

javascript
// ML pipeline workflow
await mcp__flow-nexus__workflow_create({
  name: "ML Training Pipeline",
  steps: [
    { id: "preprocess", action: "data_prep" },
    { id: "train", action: "neural_train", depends: ["preprocess"] },
    { id: "validate", action: "neural_validate", depends: ["train"] },
    { id: "deploy", action: "neural_deploy", depends: ["validate"] }
  ]
});

Related Skills

References

Version History

  • 1.0.0 (2026-01-02): Initial release - converted from flow-nexus-neural agent

Didn't find tool you were looking for?

Be as detailed as possible for better results