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 .