// Deploy a template await mcp__flow-nexus__template_deploy({ template_name: "express-api-starter", deployment_name: "my-api", variables: { api_key: "your_api_key", database_url: "postgres://..." } });

// Publish your own app await mcp__flow-nexus__app_store_publish_app({ name: "My Auth Service", description: "JWT-based authentication microservice", category: "backend", source_code: sourceCode, tags: ["auth", "jwt", "express"] });


## When to Use

- Discovering pre-built applications and templates
- Publishing applications to the marketplace
- Deploying templates for rapid project setup
- Analyzing app performance and user engagement
- Managing installed applications
- Tracking marketplace trends and statistics

## Prerequisites

- Flow Nexus account with active session
- MCP server `flow-nexus` configured
- Publishing requires verified developer status

## Core Concepts

### App Categories

| Category | Description |
|----------|-------------|
| **Web APIs** | RESTful APIs, microservices, backend frameworks |
| **Frontend** | React, Vue, Angular apps and component libraries |
| **Full-Stack** | Complete applications with frontend and backend |
| **CLI Tools** | Command-line utilities and productivity tools |
| **Data Processing** | ETL pipelines, analytics, transformation tools |
| **ML Models** | Pre-trained models, inference services |
| **Blockchain** | Web3, smart contracts, DeFi protocols |
| **Mobile** | React Native apps, mobile-first solutions |

### Template Types

- **Starter Templates**: Basic project scaffolding
- **Feature Templates**: Pre-built feature modules
- **Full Applications**: Complete, deployable apps
- **Component Libraries**: Reusable UI components

## MCP Tools Reference

### App Discovery

```javascript
// Search apps
mcp__flow-nexus__app_search({
  search: "query string",      // Search term
  category: "backend",         // Category filter
  featured: true,              // Featured apps only
  limit: 20                    // Max results (1-100)
})
// Returns: { apps: [{ id, name, description, category, rating }] }

// Get app details
mcp__flow-nexus__app_get({
  app_id: "app_id"
})
// Returns: { id, name, description, version, author, downloads, rating }

// List installed apps
mcp__flow-nexus__app_installed({
  user_id: "user_id"
})
// Returns: { installed_apps: [{ app_id, installed_at, version }] }

Template Management

// List templates
mcp__flow-nexus__template_list({
  category: "backend",
  featured: true,
  limit: 20
})

// Alternative: app store templates
mcp__flow-nexus__app_store_list_templates({
  category: "frontend",
  tags: ["react", "typescript"],
  limit: 20
})

// Get template details
mcp__flow-nexus__template_get({
  template_name: "express-api-starter"
})
// Returns: { id, name, description, variables, requirements }

// Deploy template
mcp__flow-nexus__template_deploy({
  template_id: "template_id",    // Or use template_name
  template_name: "express-api-starter",
  deployment_name: "my-project",
  variables: {
    api_key: "key",
    database_url: "postgres://..."
  },
  env_vars: {
    NODE_ENV: "production"
  }
})
// Returns: { deployment_id, url, status }

App Publishing

mcp__flow-nexus__app_store_publish_app({
  name: "App Name",
  description: "Detailed description of the app",
  category: "backend",
  source_code: "// Your source code here",
  version: "1.0.0",
  tags: ["tag1", "tag2", "tag3"],
  metadata: {
    author: "Your Name",
    repository: "https://github.com/..."
  }
})
// Returns: { app_id, status, review_pending }

App Management

// Update app
mcp__flow-nexus__app_update({
  app_id: "app_id",
  updates: {
    description: "Updated description",
    version: "1.1.0"
  }
})

// Get analytics
mcp__flow-nexus__app_analytics({
  app_id: "app_id",
  timeframe: "30d"           // 24h, 7d, 30d, 90d
})
// Returns: { downloads, active_users, rating, revenue }

// Get market data
mcp__flow-nexus__market_data()
// Returns: { total_apps, total_downloads, trending, categories }

Usage Examples

Example 1: Finding and Deploying an API Template

// Search for API templates
const templates = await mcp__flow-nexus__template_list({
  category: "backend",
  featured: true
});

// Find the Express starter
const expressTemplate = templates.templates.find(
  t => t.name.includes("express")
);

// Get template details
const details = await mcp__flow-nexus__template_get({
  template_id: expressTemplate.id
});

console.log("Required variables:", details.variables);

// Deploy the template
const deployment = await mcp__flow-nexus__template_deploy({
  template_id: expressTemplate.id,
  deployment_name: "my-express-api",
  variables: {
    database_url: process.env.DATABASE_URL,
    jwt_secret: process.env.JWT_SECRET,
    port: "3000"
  },
  env_vars: {
    NODE_ENV: "production"
  }
});

console.log(`Deployed at: ${deployment.url}`);

Example 2: Publishing a New Application

// Prepare your application
const sourceCode = `
const express = require('express');
const jwt = require('jsonwebtoken');

const app = express();
app.use(express.json());

// JWT authentication middleware
const authenticate = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) return res.status(401).json({ error: 'Unauthorized' });

  try {
    req.user = jwt.verify(token, process.env.JWT_SECRET);
    next();
  } catch {
    res.status(401).json({ error: 'Invalid token' });
  }
};

// Routes
app.post('/login', (req, res) => {
  const { username, password } = req.body;
  // Authentication logic
  const token = jwt.sign({ username }, process.env.JWT_SECRET);
  res.json({ token });
});

app.get('/protected', authenticate, (req, res) => {
  res.json({ message: 'Protected data', user: req.user });
});

module.exports = app;
`;

// Publish to app store
const published = await mcp__flow-nexus__app_store_publish_app({
  name: "JWT Auth Service",
  description: "A complete JWT authentication service with Express.js. Includes login, token verification, and protected route middleware.",
  category: "backend",
  source_code: sourceCode,
  version: "1.0.0",
  tags: ["authentication", "jwt", "express", "middleware", "security"],
  metadata: {
    author: "Your Name",
    license: "MIT",
    repository: "https://github.com/yourname/jwt-auth-service"
  }
});

console.log(`App published with ID: ${published.app_id}`);

Example 3: Analyzing App Performance

// Get your app's analytics
const analytics = await mcp__flow-nexus__app_analytics({
  app_id: "your_app_id",
  timeframe: "30d"
});

console.log(`
App Performance Report (Last 30 Days):
- Total Downloads: ${analytics.downloads}
- Active Users: ${analytics.active_users}
- Average Rating: ${analytics.rating}/5
- Revenue: ${analytics.revenue} rUv credits
`);

// Get market trends
const market = await mcp__flow-nexus__market_data();

console.log(`
Market Overview:
- Total Apps: ${market.total_apps}
- Total Downloads: ${market.total_downloads}
- Trending Categories: ${market.trending.categories.join(', ')}
`);

Example 4: Managing Installed Apps

// List installed apps
const installed = await mcp__flow-nexus__app_installed({
  user_id: "your_user_id"
});

for (const app of installed.installed_apps) {
  // Get details for each installed app
  const details = await mcp__flow-nexus__app_get({
    app_id: app.app_id
  });

  console.log(`${details.name} v${app.version} - Installed: ${app.installed_at}`);
}

Execution Checklist

For App Discovery

Search with relevant keywords and filters
Review app details and documentation
Check ratings and reviews
Verify category and template requirements
Deploy with appropriate configuration

For App Publishing

Prepare clean, well-documented source code
Write comprehensive description
Add relevant tags for discoverability
Set appropriate version number
Include metadata (author, license, repository)
Submit for review

Best Practices

Clear Descriptions: Write detailed, helpful app descriptions
Proper Tagging: Use relevant tags for discoverability
Version Management: Follow semantic versioning
Documentation: Include README and usage examples
Security Scanning: Ensure code passes security checks
Regular Updates: Keep apps updated and maintained

Error Handling

Error	Cause	Solution
`app_not_found`	Invalid app_id	Use `app_search` to find valid IDs
`publish_failed`	Invalid source code or metadata	Verify all required fields
`template_deploy_failed`	Missing required variables	Check template requirements
`unauthorized`	Not logged in or insufficient permissions	Authenticate first
`duplicate_app_name`	App name already exists	Choose unique name

Metrics & Success Criteria

App Downloads: Track total and daily downloads
User Rating: Target >4.0/5 average rating
Active Users: Monitor engagement over time
Revenue: Track rUv credit earnings
Deployment Success: >95% successful deployments

Integration Points

With Sandboxes

// Deploy template to sandbox for testing
const sandbox = await mcp__flow-nexus__sandbox_create({
  template: "node"
});

await mcp__flow-nexus__template_deploy({
  template_name: "express-api-starter",
  variables: { sandbox_id: sandbox.sandbox_id }
});

With Payments

// Track app revenue
const balance = await mcp__flow-nexus__ruv_balance({
  user_id: "publisher_id"
});

// Revenue from published apps appears in balance

Related Skills

cloud-sandbox - Execution environments
cloud-workflow - Workflow automation
cloud-payments - Credit management

References

Version History

1.0.0 (2026-01-02): Initial release - converted from flow-nexus-app-store agent

cloud-app-store

Cloud App Store

Quick Start