Metadata-Version: 2.5
Name: create-ailab
Version: 0.1.0
Summary: The Vite-style project scaffolder for AI/ML engineering.
Project-URL: Homepage, https://github.com/rizatalebi/create-ai
Project-URL: Repository, https://github.com/rizatalebi/create-ai
Project-URL: Documentation, https://github.com/rizatalebi/create-ai/tree/main/docs
Project-URL: Changelog, https://github.com/rizatalebi/create-ai/blob/main/CHANGELOG.md
Project-URL: Issues, https://github.com/rizatalebi/create-ai/issues
Author-email: Riza Talebi <rizatalebi@eoailab.com>
License: MIT
License-File: LICENSE
Keywords: ai,cli,generator,llm,ml,pytorch,scaffold,template
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Software Development :: Code Generators
Requires-Python: >=3.10
Requires-Dist: jinja2>=3.1.3
Requires-Dist: pydantic>=2.6.0
Requires-Dist: questionary>=2.0.1
Requires-Dist: rich>=13.7.0
Requires-Dist: typer>=0.12.0
Provides-Extra: dev
Requires-Dist: mypy>=1.10; extra == 'dev'
Requires-Dist: pytest-cov>=5.0; extra == 'dev'
Requires-Dist: pytest>=8.0; extra == 'dev'
Requires-Dist: ruff>=0.5.0; extra == 'dev'
Description-Content-Type: text/markdown

# create-ai

[![CI](https://github.com/rizatalebi/create-ai/actions/workflows/ci.yml/badge.svg)](https://github.com/rizatalebi/create-ai/actions/workflows/ci.yml)
[![PyPI](https://img.shields.io/pypi/v/create-ailab.svg)](https://pypi.org/project/create-ailab/)
[![Python](https://img.shields.io/pypi/pyversions/create-ailab.svg)](https://pypi.org/project/create-ailab/)
[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

**The Vite experience for AI/ML engineering.** Run one command, answer a few
questions, and get a clean, modern, production-ready AI project — structure,
dependencies, config, tooling, tests, docs and *runnable* example code.

```bash
create-ai my-project
```

```text
🚀 Create AI Project

? Project name: my-project
? What type of AI project? › Machine Learning
? Python version? › 3.12
? Framework? › scikit-learn
? Environment manager? › uv
? Testing? › pytest
? Code quality? › Ruff
? Experiment tracking? › None
? Docker? › No
? Jupyter? › No
? Initialize Git? › Yes

✔ Created my-project/
✔ Created 5 scaffold directories
✔ Rendered 27 files
✔ Created .venv with uv
✔ Installed dependencies with uv sync
✔ Initialised Git repository with an initial commit

🎉 Project created successfully!

Next steps:
  cd my-project
  source .venv/bin/activate
  uv run python train.py
```

---

## 1. What is create-ai?

`create-ai` is an **orchestrator / scaffolder**, not another ML framework. It
composes the tools you already use — `uv`, PyTorch, scikit-learn, Hugging Face,
`pytest`, Ruff, Docker, MLflow — into a coherent project you can run immediately.

```text
                    create-ai
                        │
        ┌───────────────┼───────────────┐
      Domain         Framework        Tooling
      ML             PyTorch          uv / venv
      Deep Learning  TensorFlow       pytest
      LLM / GenAI    scikit-learn     Ruff / Black
      Computer Vision Hugging Face    Docker · MLflow · W&B
```

## 2. Why it exists

Starting an AI project means re-deciding the same twenty things every time:
`src/` layout, config strategy, where checkpoints go, how to wire an experiment
tracker, a Dockerfile that isn't 2 GB, tests that actually exercise a training
step. `create-ai` encodes sensible, modern defaults so you start from a working
baseline instead of a blank directory.

## 3. Installation

```bash
uv tool install create-ailab      # recommended
# or
pipx install create-ailab
# or
pip install create-ailab
```

> The PyPI package is **`create-ailab`**; the command it installs is **`create-ai`**.

From source:

```bash
git clone https://github.com/rizatalebi/create-ai
cd create-ai
uv sync
uv run create-ai --help
```

## 4. Quick start

Interactive:

```bash
create-ai my-project
```

Non-interactive (CI-friendly — flags and prompts build the *same* config):

```bash
create-ai my-project \
  --type deep-learning \
  --framework pytorch \
  --python 3.12 \
  --manager uv \
  --testing pytest \
  --linting ruff \
  --yes
```

Scaffold files only, no environment:

```bash
create-ai my-project --type ml --no-install --yes
```

## 5. Supported project types

| key               | domain            | frameworks                          |
| ----------------- | ----------------- | ----------------------------------- |
| `ml`              | Machine Learning  | scikit-learn (default), none, +torch/tf |
| `deep-learning`   | Deep Learning     | PyTorch (default), TensorFlow       |
| `llm`             | LLM / GenAI       | PyTorch + Hugging Face              |
| `computer-vision` | Computer Vision   | PyTorch (default), TensorFlow       |

The architecture is built so NLP, Reinforcement Learning, Robotics, ROS 2,
MLOps, Multimodal and Agentic types drop in as **new files, not new `if`
branches** (see §8).

## 6. CLI reference

```bash
create-ai                     # interactive
create-ai <name>              # alias for `create-ai new <name>`
create-ai new <name> [flags]
create-ai list                # show registered project types
create-ai doctor              # check Python / Git / uv / Docker
create-ai add <component>     # v0.2 — extend an existing project
create-ai --version
create-ai --help
```

Key `new` flags: `--type/-t`, `--framework/-f`, `--python`, `--manager/-m`,
`--testing`, `--linting`, `--tracking`, `--docker/--no-docker`,
`--jupyter/--no-jupyter`, `--git/--no-git`, `--yes/-y`, `--no-install`,
`--dry-run`, `--force`, `--output-dir/-o`, `--debug`.

## 7. Generated structure (Machine Learning)

```text
my-project/
├── data/{raw,processed,external}/
├── notebooks/                 # only with --jupyter
├── src/my_project/
│   ├── data/          dataset.py       load + split
│   ├── features/      preprocessing.py scaling pipeline
│   ├── models/        model.py         build / save / load
│   ├── evaluation/    metrics.py       accuracy, f1, report
│   ├── inference/     predict.py
│   └── pipeline.py                     load → split → train → evaluate → save
├── configs/config.yaml
├── tests/                     # exercises a real end-to-end run on tiny data
├── train.py  evaluate.py  predict.py
├── pyproject.toml  README.md  .gitignore  .env.example
└── Dockerfile  .dockerignore  # only with --docker
```

Deep Learning / Computer Vision add `datasets/ models/ training/ evaluation/
inference/` (plus `transforms/` for CV), `configs/{model,training}.yaml`, and
`checkpoints/ experiments/`. LLM adds `prompts/`, `data/sample.jsonl`, and
`configs/{model,training,evaluation}.yaml`.

Every generated project runs out of the box:

```bash
cd my-project && uv sync && uv run python train.py
```

## 8. Architecture

```text
CLI flags ─┐
           ├─▶ ProjectConfig ─▶ Project ─▶ GenerationEngine ─▶ TemplateEngine
prompts  ──┘   (pydantic)      (+context)   (pipeline of      (Jinja2, layered
                                             named steps)      template roots)
```

* **`core/configuration.py`** — one immutable `ProjectConfig`. Prompts and flags
  both do nothing but fill it in.
* **`core/registry.py`** — a generic `Registry`. Project types, environment
  managers and (later) plugins register themselves; the core never enumerates
  them.
* **`generators/`** — one declarative `ProjectGenerator` per domain: which
  template roots, which extra dirs, which logical dependencies, which extra
  context, is-this-config-valid. No side effects.
* **`core/dependencies.py`** — the *only* place that maps a logical name
  (`"torch"`) to a pinned requirement, and folds in framework / tracking /
  testing / linting / Jupyter choices. Isolated from generators.
* **`core/templating.py`** — Jinja2 only. Template roots layer
  (`["common", "ml"]`); later roots win; a template that renders to whitespace
  is skipped (how files opt out).
* **`integrations/`** — one wrapper per external tool, each degrading gracefully
  when the tool is missing. `EnvironmentManager` is an ABC with `uv` and `venv`
  implementations; Poetry / Conda slot in the same way.
* **`core/generator.py`** — the single side-effecting pipeline.

Adding a project type = add `generators/nlp.py` with an `@generator_registry.register("nlp")`
class and a `templates/nlp/` folder. Nothing else changes.

## 9. Development

```bash
uv sync
uv run pytest             # unit + integration
uv run ruff check .
uv run ruff format --check .
uv run create-ai --help
```

Layout: `src/create_ai/{cli,core,generators,integrations,templates,utils}`,
tests in `tests/{unit,integration}`.

## 10. Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md) and
[CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md). Good first contributions: a new
framework backend, a new integration, or a new project type.

## 11. Roadmap

### v0.1 (this release)

- [x] Interactive + non-interactive project creation
- [x] Machine Learning, Deep Learning, LLM, Computer Vision
- [x] PyTorch, TensorFlow, scikit-learn
- [x] `uv` and `venv`
- [x] `pytest`, Ruff (+ Black), Docker, Jupyter, Git
- [x] `create-ai list` / `doctor`

### v0.2

- [ ] `create-ai add` (layer integrations / domains onto an existing project)
- [ ] Poetry and Conda environment managers
- [ ] MLflow / W&B wired into generated training loops by default
- [ ] Configurable / user-overridable templates

### v0.3

- [ ] NLP, Reinforcement Learning, MLOps templates
- [ ] Robotics, ROS 2

### Future

- [ ] Plugin system, community + remote templates

## License

MIT — see [LICENSE](LICENSE).
