# Vibe Workflow: Self-Hosted Node-Based AI Image and Video Pipeline Builder

> Vibe Workflow is an open-source, MIT-licensed node-based AI workflow builder for generative image and video pipelines. It positions itself as a self-hostable alternative to Weavy AI, Krea Nodes, Freepik Spaces, and FloraFauna AI. The project uses MuAPI for generative AI capabilities and ships as a Next.js frontend, a FastAPI backend, and a shared workflow-builder package in a npm monorepo.

**SamurAIGPT/Vibe-Workflow** — Free, open-source alternative to Weavy AI, Krea Nodes, Freepik Spaces & FloraFauna AI — node-based AI workflow builder for generative image & video pipelines

- Repository: https://github.com/SamurAIGPT/Vibe-Workflow
- Website: https://muapi.ai/workflow
- Stars: 606 · Forks: 153
- Language: JavaScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/samuraigpt-vibe-workflow

## What Vibe Workflow Is and Who It Is For

Vibe Workflow is a visual workflow editor that represents AI processing steps as nodes connected by data flows. Users build pipelines by placing nodes on a canvas, connecting them, and running the resulting workflow to generate or transform images and video. The design is described in the README as inspired by Blender Nodes and ComfyUI.

The README positions the tool against four specific commercial products: Weavy AI, Krea Nodes, Freepik Spaces, and FloraFauna AI. All four are closed-source SaaS tools with subscription fees. Vibe Workflow is MIT-licensed and designed to run on infrastructure the user controls.

The target audience breaks into four groups according to the README. Creative professionals who need custom AI pipelines for high-volume asset production. Studios that need consistent generative output across many variations. Developers who want to extend and integrate generative AI into existing systems through the API. Researchers who want to self-host and experiment with AI models without usage caps.

A hosted version is available at muapi.ai/workflow for teams that want the interface without managing infrastructure. The hosted version adds API access and an embeddable widget, allowing the node editor to be dropped into another product's interface.

## Monorepo Structure and Technology Stack

The repository is an npm monorepo with three main packages. The client/ directory is a Next.js frontend application. The packages/workflow-builder/ directory is a shared UI library containing the core node editor component. The server/ directory is a FastAPI backend.

The root package.json uses npm workspaces to manage the three packages:

```bash
npm install
```

This single command installs dependencies for the frontend, the workflow-builder library, and links the packages through npm workspaces. The build scripts are defined at the root: dev:app runs the Next.js dev server, and build:lib builds the workflow-builder library.

The FastAPI backend handles the generative AI requests. It connects to MuAPI, which is the API layer provided by Vadoo AI, to execute image and video generation. MuAPI is a required external service; without an API key, the generative nodes in the workflow editor have no backend to call.

The docker-compose.yml orchestrates both the client and server containers. The client service runs on port 3000, the server on port 8000, and they communicate through a shared Docker network named app-network. Both containers have health checks configured.

## Getting the Project Running

For local development without Docker, the prerequisites are Node.js version 20 or later, Python version 3.10 or later, and npm version 7 or later for workspace support.

After cloning and installing dependencies, the backend configuration needs a MuAPI key:

```bash
git clone https://github.com/samuraigpt/vibe-workflow.git
cd vibe-workflow
npm install
cd server
cp .env.example .env
```

Open the .env file and set MU_API_KEY to the key obtained from muapi.ai. Start the Next.js frontend from the repository root:

```bash
npm run dev:app
```

The frontend is available at http://localhost:3000. Start the FastAPI backend:

```bash
cd server
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
```

The Docker Compose path is simpler. The .env.example at the repository root shows the one required environment variable:

```bash
MU_API_KEY=your_api_key_here
```

Set that variable and run docker compose up. The compose file starts both services with health checks and restarts them if they exit unexpectedly. The client container waits for the server container to pass its health check before starting.

## The MuAPI Dependency and What It Means for Self-Hosting

Vibe Workflow's generative capabilities are provided by MuAPI, described in the README as powered by Vadoo AI. The application layer is self-hosted: the Next.js dashboard and the FastAPI backend run on infrastructure the user controls. The model inference does not. Every image or video generation request routes through the MuAPI endpoint.

This matters for teams evaluating the tool under a self-hosted or data-sovereignty requirement. The README is transparent about this: users must obtain an API key from muapi.ai to use the generative features. Teams in regulated industries or with data residency requirements need to determine whether routing generation requests through a third-party API is acceptable before adopting Vibe Workflow.

For researchers who want to run their own models, the README mentions the ability to swap AI providers freely and connect custom diffusion models or LoRAs. The README does not document the mechanism for doing this with a self-hosted model endpoint, beyond stating the architecture supports it. The .env.example shows only MU_API_KEY as a configuration option.

ComfyUI is the closest self-contained alternative for teams that need fully local model inference. ComfyUI is also a node-based workflow editor for generative AI and runs entirely on local hardware without external API dependencies, but it does not offer the same web-based multi-user deployment model that Vibe Workflow's Docker Compose setup provides.

## Extensibility, API, and Embed Support

The README describes an extensible architecture as a core design property. Users can add new AI model nodes, connect external APIs, and build reusable workflow templates. The workflow-builder library in packages/workflow-builder/ is the shared component that implements the node editor, separating it from the frontend application so it can be embedded or extended independently.

The hosted version at muapi.ai/workflow includes API support for programmatically running workflows and integrating generative pipelines into other applications. It also includes embed support, allowing the node editor to be dropped into another platform's interface through an embeddable widget. The README targets this feature at developers who want their users to have a node-based AI editor without leaving the developer's own product.

The docker-compose.yml exposes the backend on port 8000. A developer who wants to call the backend API directly from their own application can do so without going through the frontend. The health check endpoint at /api/health is used by the compose file and can serve as a readiness probe in a Kubernetes deployment.

The comparison table in the README lists the following properties for Vibe Workflow: MIT open source, self-hostable, node-based editor, custom AI models, no subscription, and full API support. The comparison contrasts these with the closed-source SaaS alternatives, which the README describes as offering limited custom model support and limited API access.

## Limitations and When Vibe Workflow May Not Fit

The MuAPI dependency is the central limitation for teams evaluating fully self-hosted deployments. The README promotes self-hosting but routes model inference through an external service. Teams that need all compute on-premises need either a different tool or to implement custom model nodes that bypass MuAPI.

The project has no published GitHub releases. Active development occurs on the main branch. The last push was on 2026-09-17. Teams that need a reproducible deployment should pin to a specific git commit rather than tracking main.

The workflow-builder library in packages/workflow-builder/ is described as the core node editor but is a shared internal package rather than a published npm package. Teams that want to embed the node editor in their own product would need to consume it from the git repository rather than from a registry.

For the hosted version, the relevant constraint is the terms of service for the muapi.ai platform. The README does not document rate limits or data handling policies for the hosted version. Teams using the hosted API for commercial pipelines should consult the muapi.ai documentation before scaling up.

Version 1.0.0 is listed in the root package.json, indicating an initial release. The combination of a v1.0 designation and active development on the main branch suggests API stability between versions is not yet guaranteed.

## Conclusion

Vibe Workflow is for developers, creative studios, and researchers who want a visual, node-based pipeline editor for generative AI without subscribing to Weavy AI or Krea Nodes. The hosted version at muapi.ai/workflow removes the infrastructure requirement for teams that do not want to self-host. The critical dependency to evaluate before committing is MuAPI: all generative AI capabilities route through that API, so the self-hosted label applies to the application layer only, not to the AI model inference. The last push was on 2026-09-17, confirming active development.

## FAQ

### Does Vibe Workflow require an external API to generate images?

Yes. Vibe Workflow uses MuAPI, provided by Vadoo AI, for all generative image and video capabilities. A MuAPI API key, obtained from muapi.ai, is required to run the generative nodes. The application layer (Next.js frontend and FastAPI backend) is self-hosted, but model inference routes through MuAPI.

### How is Vibe Workflow different from Weavy AI and Krea Nodes?

Vibe Workflow is MIT-licensed and self-hostable, while Weavy AI and Krea Nodes are closed-source SaaS products with subscription fees. According to the comparison table in the README, Vibe Workflow also supports custom AI models and provides full API access, which the paid alternatives offer only in limited form.

### Can I run Vibe Workflow with Docker?

Yes. The repository includes a docker-compose.yml that starts the Next.js frontend on port 3000 and the FastAPI backend on port 8000 with health checks and automatic restarts. Set MU_API_KEY in the environment or in a .env file at the repository root before running Docker Compose.

## Sources

- [Issues](https://github.com/SamurAIGPT/Vibe-Workflow/issues)
- [License: MIT](https://github.com/SamurAIGPT/Vibe-Workflow/blob/main/LICENSE)
- [Project website](https://muapi.ai/workflow)
- [README](https://github.com/SamurAIGPT/Vibe-Workflow/blob/main/README.md)
- [SamurAIGPT/Vibe-Workflow on GitHub](https://github.com/SamurAIGPT/Vibe-Workflow)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/samuraigpt-vibe-workflow