# Open AI Micro Drama Generator: An Agentic Pipeline from Text Idea to Video

> Open AI Micro Drama Generator (MicroDrama AI) is a Python/Node.js pipeline that converts a text idea into a short-form drama video by chaining four AI agents: a screenwriter, a storyboard artist, a frame generator, and a video producer. All AI calls go through a single MuAPI key.

**Anil-matcha/Open-AI-Micro-Drama-Generator** — AI short drama & micro-drama video generator — turns any idea into a complete short-form drama using multi-agent AI pipeline (screenwriter → storyboard → frames → video). Seedance 2 VIP, Kling 3.0 Pro, Veo 3.1, Sora 2.

- Repository: https://github.com/Anil-matcha/Open-AI-Micro-Drama-Generator
- Website: https://muapi.ai?utm_source=github&utm_medium=about&utm_campaign=open-ai-micro-drama-generator
- Stars: 517 · Forks: 97
- Language: Python
- License: not declared
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/anil-matcha-open-ai-micro-drama-generator

## From Text Idea to Short Drama in Eight Automated Stages

Most AI video workflows require stitching together separate tools: one for scripting, one for image generation, one for video generation. The result is manual handoffs at each stage and no consistent treatment of characters across shots. Open AI Micro Drama Generator addresses this by running the entire pipeline end to end from a single text prompt.

The eight stages for the full idea-to-video path are: story development, character extraction, scene scripting, character portrait generation, storyboard design, per-shot frame generation, per-shot video generation, and final concatenation. All LLM calls for the first three stages go through MuAPI's LLM endpoint. Character portraits are generated using MuAPI's flux-dev-image text-to-image model. Shot frames are generated using flux-kontext-dev-i2i, an image-to-image model that uses the character portrait as a reference. Videos are produced using kling-v2.1-standard-i2v, which takes a frame as input and generates a five-second video clip. The final step concatenates all clips into a single video file using moviepy.

This pipeline is aimed at content creators who want to produce short-form drama for social platforms and at developers experimenting with multi-agent AI pipelines for creative media generation.

## MuAPI as the Unified Backend for All AI Calls

The README states that the pipeline is powered entirely by a single MuAPI key. MuAPI is an API aggregator that proxies several AI models under one endpoint. All LLM calls in the pipeline route through MuAPI's endpoint, including the screenwriter, character extractor, and storyboard artist agents. The image-to-image and image-to-video models are also accessed via MuAPI.

This single-key design simplifies the credentials setup: one account, one API key, one billing relationship. The trade-off is that the pipeline is fully dependent on MuAPI's availability and pricing. If MuAPI changes the models it offers or adjusts its pricing, the pipeline behavior changes without any code update. Because all the AI calls go through a third party, neither MuAPI nor the specific models it proxies are under the control of the repository author.

The specific models used are kling-v2.1-standard-i2v for video generation and flux-dev-image for character portraits. The README also mentions Seedance 2 VIP, Kling 3.0 Pro, Veo 3.1, and Sora 2 in the description as supported video models, indicating the pipeline can be configured for different video backends.

## Setting Up the Server and Client

The project requires Python 3.10 or higher and Node.js 18 or higher. Clone the repository:

```bash
git clone https://github.com/Anil-matcha/Open-AI-Micro-Drama-Generator.git
cd Open-AI-Micro-Drama-Generator
```

The server and client are in separate directories. For the server, navigate into the server folder and create a Python virtual environment:

```bash
cd server
python -m venv venv
```

Activate the virtual environment using the appropriate command for your operating system before installing the Python dependencies. The README is structured as a Quick Start with numbered steps, but the full install instructions are truncated in the visible portion of the documentation.

A MuAPI API key is required before the server can make any AI calls. The README links to muapi.ai as the source for the key. Without a working API key, none of the pipeline stages that call image or video generation models will execute.

## Character Consistency Across Shots

Maintaining consistent character appearances across multiple video shots is one of the harder problems in AI-generated video. If the model generates each shot independently, the same character can look like a different person in every cut.

The pipeline addresses this by extracting character descriptions early, generating a reference portrait for each character during the character portrait stage, and then passing that reference portrait to the frame generator for every shot featuring that character. The flux-kontext-dev-i2i image-to-image model takes the portrait as a conditioning input when generating the first frame of each shot. This pipeline step is described as providing coherent visual identity across every shot.

The storyboard artist agent designs three to five shots per scene, specifying visual description, motion description, and audio description for each shot. This structured intermediate output is what allows the later stages to generate frames and video clips that follow a coherent plan rather than improvising from the scene script alone.

## Script to Video Mode and Real-Time Progress Streaming

The pipeline has two entry points. The full idea-to-video path starts from a raw text idea. The script-to-video path skips the story development, character extraction, and scene scripting stages and starts directly from a script you provide. For the shorter path, the same character portrait, frame generation, video generation, and concatenation stages apply.

Both paths send real-time progress updates to the client via Server-Sent Events (SSE) streaming. The README describes a live animated stage timeline in the web view that lights up step by step as the pipeline advances. This means you can watch the pipeline move through storyboard design to frame generation to video generation without polling or refreshing.

## No License, Hard MuAPI Dependency, and Output Control Limits

The repository lists no license. Without a license, the default copyright law applies: the code is not free to use, modify, or redistribute. This is a genuine barrier for anyone who wants to build on this project commercially or include it in an open-source project. The README does not address this.

The manual AI video workflow is the natural alternative. Developers who want more control over model choice can use the models directly: script writing with any LLM, image generation with Flux or another model, video generation with Kling or another provider. This requires assembling the pipeline manually, which is exactly the problem MicroDrama AI solves, but it removes the single-vendor dependency and the licensing uncertainty.

The pipeline also has no mechanism for adjusting pacing, choosing different shot durations, or controlling the concatenation beyond the default moviepy join. Each video clip is five seconds. If you need shorter or longer clips, the pipeline does not document how to change this.

## Maintenance Status

The last push to the repository was on 2026-08-02. The repository is not archived. No GitHub releases are listed. The top-level directory contains a demo video file (601483250-f8b5d09c-8c58-40c1-b171-e3f42b0d71a8.mp4) alongside the README, client/, and server/ directories. The author maintains a related list of open-source AI apps at github.com/Anil-matcha/awesome-generative-ai-apps, which the README links to.

## Conclusion

Open AI Micro Drama Generator is the right choice for developers who want a complete automated pipeline from text to drama video and are willing to depend entirely on MuAPI's models and pay-per-call pricing. The repository has no license, which is a real barrier for commercial use or redistribution. Anyone building a production application on top of this should treat the lack of a license as a blocker until the author clarifies terms. For experimentation and personal projects, verify that a MuAPI account is set up before cloning, since the pipeline will not run without it.

## FAQ

### Are micro dramas AI generated?

They can be. Open AI Micro Drama Generator automates the full production: the pipeline writes the script, extracts characters, designs storyboards, generates frames, and produces video clips without manual steps between stages.

### How to make a micro drama with AI?

With Open AI Micro Drama Generator, you clone the repository, set up a MuAPI API key, and provide a text idea or a script. The pipeline handles story development, character portrait generation, storyboarding, frame generation, and video production automatically.

### What are micro drama apps?

Open AI Micro Drama Generator is a self-hosted pipeline rather than a hosted app. It runs locally and calls MuAPI's AI models to produce short-form drama videos from text input. The README also links to related projects for YouTube Shorts and faceless video generation.

## Sources

- [Anil-matcha/Open-AI-Micro-Drama-Generator on GitHub](https://github.com/Anil-matcha/Open-AI-Micro-Drama-Generator)
- [Issues](https://github.com/Anil-matcha/Open-AI-Micro-Drama-Generator/issues)
- [Project website](https://muapi.ai?utm_source=github&utm_medium=about&utm_campaign=open-ai-micro-drama-generator)
- [README](https://github.com/Anil-matcha/Open-AI-Micro-Drama-Generator/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/anil-matcha-open-ai-micro-drama-generator