免费在 GitHub 公开中文介绍

flow-nexus-neural

通过Flow Nexus在E2B隔离环境中训练和部署神经网络，执行预测、监控分布式训练，并进行性能评估和模型共享。

原文查看原文说明

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

ruvnet/ruflo

AI 评分90分/ 100 查看安装方法

适用场景

训练图像分类模型
使用LSTM预测时间序列
部署情感分析模板
将数据保留在各节点进行训练
测量并共享已训练的模型

中文介绍

功能

使用Flow Nexus，在E2B沙箱这一隔离的执行环境中训练和部署神经网络。可以指定feedforward、lstm、gan、autoencoder或transformer架构，也可使用预训练模板。支持执行预测、查看训练进度、测量性能，以及将模型发布为模板以供共享。

适用场景

适合尝试图像分类、文本情感分析和时间序列预测。包含将计算任务分配到多个执行环境的分布式训练流程，也包含让数据保留在各节点进行训练的联邦学习流程。从小规模实验逐步转向多节点训练时，也可使用。

使用示例

“请用LSTM训练时间序列预测模型，并查看训练进度。”
“请部署情感分析模板，并对这段文本进行分类。”
“请测量已训练模型的预测速度和内存占用。”

注意事项

需要先添加Flow Nexus MCP服务器，并注册、登录Flow Nexus。分布式训练需要身份验证。模板分为免费和付费类别，训练提供适用于不同规模的资源设置。

本介绍由 AI（OpenAI Codex）根据公开的 SKILL.md 撰写。准确的规格请查看下方原文。

客观评估

AI 仅根据 SKILL.md 的内容，从 4 个方面进行了评估。星标数和热度不计入评估。

指令清晰度能否看出何时使用、做什么: A良好明确列出在E2B中训练、预测、部署模板和进行分布式训练的用途。
步骤具体性步骤、输入输出和示例是否具体: A良好提供训练配置、预测输入输出，以及从创建集群到监控的调用示例。
安全性发送数据、删除文件、执行命令等是否有说明: B部分不足涉及外部环境部署和付费模板，但未提供执行前的确认步骤。
安装难易度所需工具和 API 密钥是否少且有说明: A良好提供添加Flow Nexus MCP服务器、注册和登录的命令。

总分按每项 A=25 分、B=15 分、C=5 分相加。由 AI（OpenAI Codex）于 2026年10月21日评估。仅供参考，安装前请同时查看原文。

如果您认为评估有误，请申请复核

包含的文件（1）

SKILL.md15.7 KB

SKILL.md（原文）

安装前可以查看交给 AI 代理的指令内容。

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.

评价

还没有评价。欢迎分享你的使用感受。

无需登录即可发表。欢迎分享使用感受、提问，或说明在哪些环境下无法运行。

还没有评论。来写第一条吧。

同一仓库的技能

add-model-descriptions

免费有简介AI 评分 80分

对照HuggingFace router的模型列表与chat-ui配置，研究尚未收录的模型，编写简短英文说明，并同步添加到生产和开发配置。

添加路由中新上线的模型
用简短说明概括模型特点
同步更新生产和开发环境的模型信息

ruvnet/ruflo7.8万2026年10月22日更新

adr-create

免费有简介AI 评分 80分

为技术选型和设计决策创建ADR文档，沿用现有文件的连续编号，生成模板并登记到AgentDB，同时为找到的相关历史决策添加链接和依赖关系。

记录采用某项技术的理由
记录API或数据模型变更
将基础设施决策形成文档

ruvnet/ruflo7.8万2026年10月22日更新

adr-index

免费有简介AI 评分 90分

读取记录架构决策及其原因的ADR，创建并更新搜索索引和依赖关系图。支持两种文档格式，并汇总引用与状态的不一致情况。

导入其他项目的ADR后建立索引
同步文件与关系图
为现有代码库开始管理ADR

ruvnet/ruflo7.8万2026年10月22日更新

adr-reindex

免费有简介AI 评分 70分

删除ADR设计决策记录或关系信息后，清空并重建索引，移除残留的旧条目，再核对当前文件数与索引记录数是否一致；也可预览重建内容而不作更改。

删除ADR文件后重建索引
删除ADR关系后清理残留记录
定期核对并重建ADR索引

ruvnet/ruflo7.8万2026年10月22日更新

adr-review

免费有简介AI 评分 80分

将代码差异与记录已采纳设计决策的ADR进行核对，整理违反决策、引用过时记录及缺少相关记录的变更，并提出代码修正或决策调整建议。

合并PR前检查设计决策
核对重大变更与设计决策
查找对已被替代ADR的引用

ruvnet/ruflo7.8万2026年10月22日更新

adr-verify

免费有简介AI 评分 90分

检查已保存的架构决策记录（ADR），报告失效引用、替代关系中的循环和状态不一致问题，适合导入后的校验与发布前的数据检查。

检查ADR导入后的数据一致性
在持续集成中检测不一致问题
发布前检查已保存的ADR数据

ruvnet/ruflo7.8万2026年10月22日更新

查看 ruvnet 的全部技能

报告此技能的问题

安装

用命令安装

npx skills add https://github.com/ruvnet/ruflo --skill flow-nexus-neural

粘贴到终端中运行（需要 Node.js）。可以选择安装到 Claude Code、Codex 等代理。

让代理安装

请安装以下 Agent Skill。
https://github.com/ruvnet/ruflo/tree/main/.claude/skills/flow-nexus-neural

请先检查 SKILL.md 和附带文件的内容，确认没有可疑的处理（向外部发送数据、读取认证信息等）后，再放到 ~/.claude/skills/flow-nexus-neural/（Claude Code）或 ~/.agents/skills/flow-nexus-neural/（Codex）。

把这段文字直接发给 Claude Code 或 Codex，它会先检查内容再安装。

在 GitHub 查看源代码

仓库: ruvnet/ruflo
星标: 78,386
复刻: 9,213
分类: 数据与 AI
许可证: MIT
原文语言: 英语
最后更新: 2026年10月22日

技能是给 AI 代理的指令和脚本的集合。cccskills 不保证其内容的安全性，安装前请务必确认内容。