flow-nexus-platform

$2b

Register New Account

mcp__flow-nexus__user_register({

  email: "user@example.com",

  password: "secure_password",

  full_name: "Your Name",

  username: "unique_username" // optional

})

Login

mcp__flow-nexus__user_login({

  email: "user@example.com",

  password: "your_password"

})

Check Authentication Status

mcp__flow-nexus__auth_status({ detailed: true })

Logout

mcp__flow-nexus__user_logout()

Password Management

Request Password Reset

mcp__flow-nexus__user_reset_password({

  email: "user@example.com"

})

Update Password with Token

mcp__flow-nexus__user_update_password({

  token: "reset_token_from_email",

  new_password: "new_secure_password"

})

Verify Email

mcp__flow-nexus__user_verify_email({

  token: "verification_token_from_email"

})

Profile Management

Get User Profile

mcp__flow-nexus__user_profile({

  user_id: "your_user_id"

})

Update Profile

mcp__flow-nexus__user_update_profile({

  user_id: "your_user_id",

  updates: {

    full_name: "Updated Name",

    bio: "AI Developer and researcher",

    github_username: "yourusername",

    twitter_handle: "@yourhandle"

  }

})

Get User Statistics

mcp__flow-nexus__user_stats({

  user_id: "your_user_id"

})

Upgrade User Tier

mcp__flow-nexus__user_upgrade({

  user_id: "your_user_id",

  tier: "pro" // pro, enterprise

})

Sandbox Management

Create & Configure Sandboxes

Create Sandbox

mcp__flow-nexus__sandbox_create({

  template: "node", // node, python, react, nextjs, vanilla, base, claude-code

  name: "my-sandbox",

  env_vars: {

    API_KEY: "your_api_key",

    NODE_ENV: "development",

    DATABASE_URL: "postgres://..."

  },

  install_packages: ["express", "cors", "dotenv"],

  startup_script: "npm run dev",

  timeout: 3600, // seconds

  metadata: {

    project: "my-project",

    environment: "staging"

  }

})

Configure Existing Sandbox

mcp__flow-nexus__sandbox_configure({

  sandbox_id: "sandbox_id",

  env_vars: {

    NEW_VAR: "value"

  },

  install_packages: ["axios", "lodash"],

  run_commands: ["npm run migrate", "npm run seed"],

  anthropic_key: "sk-ant-..." // For Claude Code integration

})

Execute Code

Run Code in Sandbox

mcp__flow-nexus__sandbox_execute({

  sandbox_id: "sandbox_id",

  code: `

    console.log('Hello from sandbox!');

    const result = await fetch('https:/$api.example.com$data');

    const data = await result.json();

    return data;

  `,

  language: "javascript",

  capture_output: true,

  timeout: 60, // seconds

  working_dir: "$app",

  env_vars: {

    TEMP_VAR: "override"

  }

})

Manage Sandboxes

List Sandboxes

mcp__flow-nexus__sandbox_list({

  status: "running" // running, stopped, all

})

Get Sandbox Status

mcp__flow-nexus__sandbox_status({

  sandbox_id: "sandbox_id"

})

Upload File to Sandbox

mcp__flow-nexus__sandbox_upload({

  sandbox_id: "sandbox_id",

  file_path: "$app$config$database.json",

  content: JSON.stringify(databaseConfig, null, 2)

})

Get Sandbox Logs

mcp__flow-nexus__sandbox_logs({

  sandbox_id: "sandbox_id",

  lines: 100 // max 1000

})

Stop Sandbox

mcp__flow-nexus__sandbox_stop({

  sandbox_id: "sandbox_id"

})

Delete Sandbox

mcp__flow-nexus__sandbox_delete({

  sandbox_id: "sandbox_id"

})

Sandbox Templates

• node: Node.js environment with npm

• python: Python 3.x with pip

• react: React development setup

• nextjs: Next.js full-stack framework

• vanilla: Basic HTML/CSS/JS

• base: Minimal Linux environment

• claude-code: Claude Code integrated environment

Common Sandbox Patterns

API Development Sandbox

mcp__flow-nexus__sandbox_create({

  template: "node",

  name: "api-development",

  install_packages: [

    "express",

    "cors",

    "helmet",

    "dotenv",

    "jsonwebtoken",

    "bcrypt"

  ],

  env_vars: {

    PORT: "3000",

    NODE_ENV: "development"

  },

  startup_script: "npm run dev"

})

Machine Learning Sandbox

mcp__flow-nexus__sandbox_create({

  template: "python",

  name: "ml-training",

  install_packages: [

    "numpy",

    "pandas",

    "scikit-learn",

    "matplotlib",

    "tensorflow"

  ],

  env_vars: {

    CUDA_VISIBLE_DEVICES: "0"

  }

})

Full-Stack Development

mcp__flow-nexus__sandbox_create({

  template: "nextjs",

  name: "fullstack-app",

  install_packages: [

    "prisma",

    "@prisma$client",

    "next-auth",

    "zod"

  ],

  env_vars: {

    DATABASE_URL: "postgresql://...",

    NEXTAUTH_SECRET: "secret"

  }

})

App Store & Deployment

Browse & Search

Search Applications

mcp__flow-nexus__app_search({

  search: "authentication api",

  category: "backend",

  featured: true,

  limit: 20

})

Get App Details

mcp__flow-nexus__app_get({

  app_id: "app_id"

})

List Templates

mcp__flow-nexus__app_store_list_templates({

  category: "web-api",

  tags: ["express", "jwt", "typescript"],

  limit: 20

})

Get Template Details

mcp__flow-nexus__template_get({

  template_name: "express-api-starter",

  template_id: "template_id" // alternative

})

List All Available Templates

mcp__flow-nexus__template_list({

  category: "backend",

  template_type: "starter",

  featured: true,

  limit: 50

})

Publish Applications

Publish App to Store

mcp__flow-nexus__app_store_publish_app({

  name: "JWT Authentication Service",

  description: "Production-ready JWT authentication microservice with refresh tokens",

  category: "backend",

  version: "1.0.0",

  source_code: sourceCodeString,

  tags: ["auth", "jwt", "express", "typescript", "security"],

  metadata: {

    author: "Your Name",

    license: "MIT",

    repository: "github.com$username$repo",

    homepage: "https:/$yourapp.com",

    documentation: "https:/$docs.yourapp.com"

  }

})

Update Application

mcp__flow-nexus__app_update({

  app_id: "app_id",

  updates: {

    version: "1.1.0",

    description: "Added OAuth2 support",

    tags: ["auth", "jwt", "oauth2", "express"],

    source_code: updatedSourceCode

  }

})

Deploy Templates

Deploy Template

mcp__flow-nexus__template_deploy({

  template_name: "express-api-starter",

  deployment_name: "my-production-api",

  variables: {

    api_key: "your_api_key",

    database_url: "postgres:/$user:pass@host:5432$db",

    redis_url: "redis:/$localhost:6379"

  },

  env_vars: {

    NODE_ENV: "production",

    PORT: "8080",

    LOG_LEVEL: "info"

  }

})

Analytics & Management

Get App Analytics

mcp__flow-nexus__app_analytics({

  app_id: "your_app_id",

  timeframe: "30d" // 24h, 7d, 30d, 90d

})

View Installed Apps

mcp__flow-nexus__app_installed({

  user_id: "your_user_id"

})

Get Market Statistics

mcp__flow-nexus__market_data()

App Categories

• web-api: RESTful APIs and microservices

• frontend: React, Vue, Angular applications

• full-stack: Complete end-to-end applications

• cli-tools: Command-line utilities

• data-processing: ETL pipelines and analytics

• ml-models: Pre-trained machine learning models

• blockchain: Web3 and blockchain applications

• mobile: React Native and mobile apps

Publishing Best Practices

• Documentation: Include comprehensive README with setup instructions

• Examples: Provide usage examples and sample configurations

• Testing: Include test suite and CI/CD configuration

• Versioning: Use semantic versioning (MAJOR.MINOR.PATCH)

• Licensing: Add clear license information (MIT, Apache, etc.)

• Deployment: Include Docker$docker-compose configurations

• Migrations: Provide upgrade guides for version updates

• Security: Document security considerations and best practices

Revenue Sharing

• Earn rUv credits when others deploy your templates

• Set pricing (0 for free, or credits for premium)

• Track usage and earnings via analytics

• Withdraw credits or use for Flow Nexus services

Payments & Credits

Balance & Credits

Check Credit Balance

mcp__flow-nexus__check_balance()

Check rUv Balance

mcp__flow-nexus__ruv_balance({

  user_id: "your_user_id"

})

View Transaction History

mcp__flow-nexus__ruv_history({

  user_id: "your_user_id",

  limit: 100

})

Get Payment History

mcp__flow-nexus__get_payment_history({

  limit: 50

})

Purchase Credits

Create Payment Link

mcp__flow-nexus__create_payment_link({

  amount: 50 // USD, minimum $10

})

// Returns secure Stripe payment URL

Auto-Refill Configuration

Enable Auto-Refill

mcp__flow-nexus__configure_auto_refill({

  enabled: true,

  threshold: 100,  // Refill when credits drop below 100

  amount: 50       // Purchase $50 worth of credits

})

Disable Auto-Refill

mcp__flow-nexus__configure_auto_refill({

  enabled: false

})

Credit Pricing

Service Costs:

• Swarm Operations: 1-10 credits$hour

• Sandbox Execution: 0.5-5 credits$hour

• Neural Training: 5-50 credits$job

• Workflow Runs: 0.1-1 credit$execution

• Storage: 0.01 credits/GB$day

• API Calls: 0.001-0.01 credits$request

Earning Credits

Ways to Earn:

• Complete Challenges: 10-500 credits per challenge

• Publish Templates: Earn when others deploy (you set pricing)

• Referral Program: Bonus credits for user invites

• Daily Login: Small daily bonus (5-10 credits)

• Achievements: Unlock milestone rewards (50-1000 credits)

• App Store Sales: Revenue share from paid templates

Earn Credits Programmatically

mcp__flow-nexus__app_store_earn_ruv({

  user_id: "your_user_id",

  amount: 100,

  reason: "Completed expert algorithm challenge",

  source: "challenge" // challenge, app_usage, referral, etc.

})

Subscription Tiers

Free Tier

• 100 free credits monthly

• Basic sandbox access (2 concurrent)

• Limited swarm agents (3 max)

• Community support

• 1GB storage

Pro Tier ($29$month)

• 1000 credits monthly

• Priority sandbox access (10 concurrent)

• Unlimited swarm agents

• Advanced workflows

• Email support

• 10GB storage

• Early access to features

Enterprise Tier (Custom Pricing)

• Unlimited credits

• Dedicated compute resources

• Custom neural models

• 99.9% SLA guarantee

• Priority 24/7 support

• Unlimited storage

• White-label options

• On-premise deployment

Cost Optimization Tips

• Use Smaller Sandboxes: Choose appropriate templates (base vs full-stack)

• Optimize Neural Training: Tune hyperparameters, reduce epochs

• Batch Operations: Group workflow executions together

• Clean Up Resources: Delete unused sandboxes and storage

• Monitor Usage: Check user_stats regularly

• Use Free Templates: Leverage community templates

• Schedule Off-Peak: Run heavy jobs during low-cost periods

Challenges & Achievements

Browse Challenges

List Available Challenges

mcp__flow-nexus__challenges_list({

  difficulty: "intermediate", // beginner, intermediate, advanced, expert

  category: "algorithms",

  status: "active", // active, completed, locked

  limit: 20

})

Get Challenge Details

mcp__flow-nexus__challenge_get({

  challenge_id: "two-sum-problem"

})

Submit Solutions

Submit Challenge Solution

mcp__flow-nexus__challenge_submit({

  challenge_id: "challenge_id",

  user_id: "your_user_id",

  solution_code: `

    function twoSum(nums, target) {

      const map = new Map();

      for (let i = 0; i < nums.length; i++) {

        const complement = target - nums[i];

        if (map.has(complement)) {

          return [map.get(complement), i];

        }

        map.set(nums[i], i);

      }

      return [];

    }

  `,

  language: "javascript",

  execution_time: 45 // milliseconds (optional)

})

Mark Challenge as Complete

mcp__flow-nexus__app_store_complete_challenge({

  challenge_id: "challenge_id",

  user_id: "your_user_id",

  submission_data: {

    passed_tests: 10,

    total_tests: 10,

    execution_time: 45,

    memory_usage: 2048 // KB

  }

})

Leaderboards

Global Leaderboard

mcp__flow-nexus__leaderboard_get({

  type: "global", // global, weekly, monthly, challenge

  limit: 100

})

Challenge-Specific Leaderboard

mcp__flow-nexus__leaderboard_get({

  type: "challenge",

  challenge_id: "specific_challenge_id",

  limit: 50

})

Achievements & Badges

List User Achievements

mcp__flow-nexus__achievements_list({

  user_id: "your_user_id",

  category: "speed_demon" // Optional filter

})

Challenge Categories

• algorithms: Classic algorithm problems (sorting, searching, graphs)

• data-structures: DS implementation (trees, heaps, tries)

• system-design: Architecture and scalability challenges

• optimization: Performance and efficiency problems

• security: Security-focused vulnerabilities and fixes

• ml-basics: Machine learning fundamentals

• distributed-systems: Concurrency and distributed computing

• databases: Query optimization and schema design

Challenge Difficulty Rewards

• Beginner: 10-25 credits

• Intermediate: 50-100 credits

• Advanced: 150-300 credits

• Expert: 400-500 credits

• Master: 600-1000 credits

Achievement Types

• Speed Demon: Complete challenges in record time

• Code Golf: Minimize code length

• Perfect Score: 100% test pass rate

• Streak Master: Complete challenges N days in a row

• Polyglot: Solve in multiple languages

• Debugger: Fix broken code challenges

• Optimizer: Achieve top performance benchmarks

Tips for Success

• Start Simple: Begin with beginner challenges to build confidence

• Review Solutions: Study top solutions after completing

• Optimize: Aim for both correctness and performance

• Daily Practice: Complete daily challenges for bonus credits

• Community: Engage with discussions and learn from others

• Track Progress: Monitor achievements and leaderboard position

• Experiment: Try multiple approaches to problems

Storage & Real-time

File Storage

Upload File

mcp__flow-nexus__storage_upload({

  bucket: "my-bucket", // public, private, shared, temp

  path: "data$users.json",

  content: JSON.stringify(userData, null, 2),

  content_type: "application$json"

})

List Files

mcp__flow-nexus__storage_list({

  bucket: "my-bucket",

  path: "data/", // prefix filter

  limit: 100

})

Get Public URL

mcp__flow-nexus__storage_get_url({

  bucket: "my-bucket",

  path: "data$report.pdf",

  expires_in: 3600 // seconds (default: 1 hour)

})

Delete File

mcp__flow-nexus__storage_delete({

  bucket: "my-bucket",

  path: "data$old-file.json"

})

Storage Buckets

• public: Publicly accessible files (CDN-backed)

• private: User-only access with authentication

• shared: Team collaboration with ACL

• temp: Auto-deleted after 24 hours

Real-time Subscriptions

Subscribe to Database Changes

mcp__flow-nexus__realtime_subscribe({

  table: "tasks",

  event: "INSERT", // INSERT, UPDATE, DELETE, *

  filter: "status=eq.pending AND priority=eq.high"

})

List Active Subscriptions

mcp__flow-nexus__realtime_list()

Unsubscribe

mcp__flow-nexus__realtime_unsubscribe({

  subscription_id: "subscription_id"

})

Execution Monitoring

Subscribe to Execution Stream

mcp__flow-nexus__execution_stream_subscribe({

  stream_type: "claude-flow-swarm", // claude-code, claude-flow-swarm, claude-flow-hive-mind, github-integration

  deployment_id: "deployment_id",

  sandbox_id: "sandbox_id" // alternative

})

Get Stream Status

mcp__flow-nexus__execution_stream_status({

  stream_id: "stream_id"

})

List Generated Files

mcp__flow-nexus__execution_files_list({

  stream_id: "stream_id",

  created_by: "claude-flow", // claude-code, claude-flow, git-clone, user

  file_type: "javascript" // filter by extension

})

Get File Content from Execution

mcp__flow-nexus__execution_file_get({

  file_id: "file_id",

  file_path: "$path$to$file.js" // alternative

})

System Utilities

Queen Seraphina AI Assistant

Seek Guidance from Seraphina

mcp__flow-nexus__seraphina_chat({

  message: "How should I architect a distributed microservices system?",

  enable_tools: true, // Allow her to create swarms, deploy code, etc.

  conversation_history: [

    { role: "user", content: "I need help with system architecture" },

    { role: "assistant", content: "I can help you design that. What are your requirements?" }

  ]

})

Queen Seraphina is an advanced AI assistant with:

• Deep expertise in distributed systems

• Ability to create swarms and orchestrate agents

• Code deployment and architecture design

• Multi-turn conversation with context retention

• Tool usage for hands-on assistance

System Health & Monitoring

Check System Health

mcp__flow-nexus__system_health()

View Audit Logs

mcp__flow-nexus__audit_log({

  user_id: "your_user_id", // optional filter

  limit: 100

})

Authentication Management

Initialize Authentication

mcp__flow-nexus__auth_init({

  mode: "user" // user, service

})

Quick Start Guide

Step 1: Register & Login

// Register

mcp__flow-nexus__user_register({

  email: "dev@example.com",

  password: "SecurePass123!",

  full_name: "Developer Name"

})

// Login

mcp__flow-nexus__user_login({

  email: "dev@example.com",

  password: "SecurePass123!"

})

// Check auth status

mcp__flow-nexus__auth_status({ detailed: true })

Step 2: Configure Billing

// Check current balance

mcp__flow-nexus__check_balance()

// Add credits

const paymentLink = mcp__flow-nexus__create_payment_link({

  amount: 50 // $50

})

// Setup auto-refill

mcp__flow-nexus__configure_auto_refill({

  enabled: true,

  threshold: 100,

  amount: 50

})

Step 3: Create Your First Sandbox

// Create development sandbox

const sandbox = mcp__flow-nexus__sandbox_create({

  template: "node",

  name: "dev-environment",

  install_packages: ["express", "dotenv"],

  env_vars: {

    NODE_ENV: "development"

  }

})

// Execute code

mcp__flow-nexus__sandbox_execute({

  sandbox_id: sandbox.id,

  code: 'console.log("Hello Flow Nexus!")',

  language: "javascript"

})

Step 4: Deploy an App

// Browse templates

mcp__flow-nexus__template_list({

  category: "backend",

  featured: true

})

// Deploy template

mcp__flow-nexus__template_deploy({

  template_name: "express-api-starter",

  deployment_name: "my-api",

  variables: {

    database_url: "postgres://..."

  }

})

Step 5: Complete a Challenge

// Find challenges

mcp__flow-nexus__challenges_list({

  difficulty: "beginner",

  category: "algorithms"

})

// Submit solution

mcp__flow-nexus__challenge_submit({

  challenge_id: "fizzbuzz",

  user_id: "your_id",

  solution_code: "...",

  language: "javascript"

})

Best Practices

Security

• Never hardcode API keys - use environment variables

• Enable 2FA when available

• Regularly rotate passwords and tokens

• Use private buckets for sensitive data

• Review audit logs periodically

• Set appropriate file expiration times

Performance

• Clean up unused sandboxes to save credits

• Use smaller sandbox templates when possible

• Optimize storage by deleting old files

• Batch operations to reduce API calls

• Monitor usage via user_stats

• Use temp buckets for transient data

Development

• Start with sandbox testing before deployment

• Version your applications semantically

• Document all templates thoroughly

• Include tests in published apps

• Use execution monitoring for debugging

• Leverage real-time subscriptions for live updates

Cost Management

• Set auto-refill thresholds carefully

• Monitor credit usage regularly

• Complete daily challenges for bonus credits

• Publish templates to earn passive credits

• Use free-tier resources when appropriate

• Schedule heavy jobs during off-peak times

Troubleshooting

Authentication Issues

• Login Failed: Check email$password, verify email first

• Token Expired: Re-login to get fresh tokens

• Permission Denied: Check tier limits, upgrade if needed

Sandbox Issues

• Sandbox Won't Start: Check template compatibility, verify credits

• Execution Timeout: Increase timeout parameter or optimize code

• Out of Memory: Use larger template or optimize memory usage

• Package Install Failed: Check package name, verify npm$pip availability

Payment Issues

• Payment Failed: Check payment method, sufficient funds

• Credits Not Applied: Allow 5-10 minutes for processing

• Auto-refill Not Working: Verify payment method on file

Challenge Issues

• Submission Rejected: Check code syntax, ensure all tests pass

• Wrong Answer: Review test cases, check edge cases

• Performance Too Slow: Optimize algorithm complexity

Support & Resources

• Documentation: https:/$docs.flow-nexus.ruv.io

• API Reference: https:/$api.flow-nexus.ruv.io$docs

• Status Page: https:/$status.flow-nexus.ruv.io

• Community Forum: https:/$community.flow-nexus.ruv.io

• GitHub Issues: https:/$github.com$ruvnet$flow-nexus$issues

• Discord: https:/$discord.gg$flow-nexus

• Email Support: support@flow-nexus.ruv.io (Pro/Enterprise only)

Progressive Disclosure

Custom Docker Images

mcp__flow-nexus__sandbox_create({

  template: "base",

  name: "custom-environment",

  startup_script: `

    apt-get update

    apt-get install -y custom-package

    git clone https:/$github.com$user$repo

    cd repo && npm install

  `

})

Multi-Stage Execution

// Stage 1: Setup

mcp__flow-nexus__sandbox_execute({

  sandbox_id: "id",

  code: "npm install && npm run build"

})

// Stage 2: Run

mcp__flow-nexus__sandbox_execute({

  sandbox_id: "id",

  code: "npm start",

  working_dir: "$app$dist"

})

<$details>

Large File Upload (Chunked)

const chunkSize = 5 * 1024 * 1024 // 5MB chunks

for (let i = 0; i < chunks.length; i++) {

  await mcp__flow-nexus__storage_upload({

    bucket: "private",

    path: `large-file.bin.part${i}`,

    content: chunks[i]

  })

}

Storage Lifecycle

// Upload to temp for processing

mcp__flow-nexus__storage_upload({

  bucket: "temp",

  path: "processing$data.json",

  content: data

})

// Move to permanent storage after processing

mcp__flow-nexus__storage_upload({

  bucket: "private",

  path: "archive$processed-data.json",

  content: processedData

})

<$details>

Multi-Table Sync

const tables = ["users", "tasks", "notifications"]

tables.forEach(table => {

  mcp__flow-nexus__realtime_subscribe({

    table,

    event: "*",

    filter: `user_id=eq.${userId}`

  })

})

Event-Driven Workflows

// Subscribe to task completion

mcp__flow-nexus__realtime_subscribe({

  table: "tasks",

  event: "UPDATE",

  filter: "status=eq.completed"

})

// Trigger notification workflow on event

// (handled by your application logic)

<$details>

Version History

• v1.0.0 (2025-10-19): Initial comprehensive platform skill

• Authentication &#x26; user management

• Sandbox creation and execution

• App store and deployment

• Payments and credits

• Challenges and achievements

• Storage and real-time features

• System utilities and Queen Seraphina integration

This skill consolidates 6 Flow Nexus command modules into a single comprehensive platform management interface.