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
Start Small: Begin with nano or mini tiers for experimentation
Use Templates: Leverage marketplace templates for common tasks
Monitor Training: Check status regularly to catch issues early
Benchmark Models: Always benchmark before production deployment
Distributed Training: Use clusters for large models (>1B parameters)
Federated Learning: Use for privacy-sensitive data
Version Models: Publish successful models as templates for reuse
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
Flow Nexus Docs: https:/$flow-nexus.ruv.io$docs
Neural Network Guide: https:/$flow-nexus.ruv.io$docs$neural
Template Marketplace: https:/$flow-nexus.ruv.io$templates
API Reference: https:/$flow-nexus.ruv.io$api
Note: Distributed training requires authentication. Register at https:/$flow-nexus.ruv.io or use npx flow-nexus@latest register.don't have the plugin yet? install it then click "run inline in claude" again.