Plexe: Build ML Models from Natural Language
Describe your ML goal in plain language, and Plexe builds a deployable model automatically.
Evidence shows: the repository provides no permission model, user confirmation mechanism, data flow transparency, sensitive data handling, dependency security audit, external effects control, rollback mechanism, or source attribution. All trust-related criteria are unmet, hence score 0.
Evidence shows: README and pyproject.toml are consistent in feature description and dependency declarations, but no failure messages or error handling documentation is provided. Thus, self-consistency scores 2, dependency availability scores 2, and failure messages scores 1.
Evidence shows: README clearly identifies target audience (developers, researchers) and use cases (tabular data modeling), with CLI and Python API examples. Capability boundaries are described via supported model types and optional dependencies. Trigger precision is ensured through explicit commands and parameters. Environment fit is supported via Docker and configuration options. Hence, each criterion scores 2.
Evidence shows: README provides clear information architecture, detailed installation notes, stable naming, examples and FAQ, and known limitations section mentioning only OpenAI and Anthropic models are tested. License is Apache-2.0, version is in pyproject.toml, but no changelog is provided. Maintenance responsibility is indicated via contributing guidelines and Discord link. Thus, each criterion scores 2, license scores 3, known limitations and versioning changelog score 1.
Evidence shows: output usability is demonstrated via model package structure and example code, marginal value via automated model building and multiple framework support, cost-benefit partially via API key requirements and cloud service mention. Hence, output usability and marginal value score 2, cost-benefit scores 1.
Evidence shows: claims in README are partially supported by examples, but lack independent verification sources. Fact-inference separation is not clear. Hence, each criterion scores 1.
- No permission model or user confirmation mechanism, may execute arbitrary code or access sensitive data.
- Dependency security not audited, potential known vulnerabilities.
- No rollback mechanism, model building failures may not be recoverable.
- Source attribution unclear, publisher identity unverified.
What does this agent do, and when should you use it?
Plexe is a multi-agent system that transforms natural language descriptions into machine learning models. Users provide a tabular dataset (Parquet, CSV, ORC, Avro) and an intent like "predict whether a passenger was transported". The system orchestrates 14 specialized agents across a 6-phase workflow: data analysis, task identification, metric selection, hypothesis-driven model search, evaluation, and packaging. It supports popular frameworks including XGBoost, CatBoost, LightGBM, Keras, and PyTorch, with optional extras for specific frameworks or platforms. The final output is a self-contained model package (in `work_dir/model/`) that includes trained artifacts, inference code, schemas, config, and evaluation reports, with no dependency on Plexe itself. Plexe offers a CLI, Python API, Docker images, a Streamlit dashboard for visualization, and extensibility through a `WorkflowIntegration` interface. It uses LiteLLM to route to multiple LLM providers (defaulting to OpenAI and Anthropic), and supports YAML configuration for customization.
Plexe accepts a training dataset URI and a natural language intent via the CLI (python -m plexe.main) or Python API (main(intent=..., data_refs=...)). It invokes a multi-agent workflow: data analysis agents inspect the dataset and identify the ML task; hypothesiser agents propose modeling approaches with different hyperparameters; model definer agents select frameworks like XGBoost or PyTorch and generate training code; evaluator agents score models on the chosen metric; and a final packaging step creates a self-contained model directory with artifacts/, src/, schemas/, config/, evaluation/, model.yaml, and README.md. The system runs iterative search (controlled by max_iterations) and can optionally evaluate on held-out test sets (enable_final_evaluation). It calls LLM APIs (OpenAI/Anthropic by default) to drive agent decisions, and can be configured with YAML to change LLM routing, search parameters, Spark memory, and more. It also provides Docker images with PySpark and Java pre-installed, and a Streamlit dashboard via python -m plexe.viz --work-dir ./workdir.
- A data scientist exploring a new dataset wants to quickly get a baseline model without writing ML code, just by describing the prediction goal.
- An ML engineer needs to prototype a deployable model for a business stakeholder, and can hand over a data file and see a production-ready package.
- A researcher or student wants to understand the end-to-end ML pipeline and uses Plexe to generate a model from a custom dataset for educational purposes.
- A DevOps team integrates Plexe's Docker image into a CI/CD pipeline to automatically generate models from data artifacts on each release.
- A developer wants to compare different LLM providers (OpenAI vs Anthropic) for agent behavior and can switch them easily via YAML configuration.
- A business analyst with a clean dataset wants a prediction model without coding, using the cloud service or CLI as a low-code solution.
What are this agent's strengths and limitations?
- Natural-language driven model creation eliminates manual ML coding, making it accessible to non-experts.
- Multi-agent orchestration covers data analysis, model selection, evaluation, and packaging, producing a deployable artifact in one call.
- The output is self-contained and independent of Plexe, simplifying deployment and integration into existing systems.
- Supports multiple popular ML frameworks (XGBoost, CatBoost, LightGBM, Keras, PyTorch) with extensible extras.
- Integrates with multiple LLM providers via LiteLLM, allowing users to choose OpenAI, Anthropic, or others based on cost/latency.
- Includes Docker images and a Streamlit dashboard for visualization and reproducibility.
- Relies on external LLM API calls, incurring cost and latency per iteration; failures in LLM services affect the pipeline.
- Primarily designed for tabular data; support for image or text data is not documented (though
visionextra suggests some capability). - Python version lock-in (3.10–3.12) may conflict with legacy environments or require containerization.
- Full framework support requires installing multiple extras, increasing setup complexity for users.
- Only OpenAI and Anthropic models are actively tested; other providers may work but are not guaranteed.
- The automated search is not fully transparent, and fine-grained control over training is limited, which may be a drawback for advanced ML practitioners.
How do you install or deploy this agent?
Requires Python 3.10 up to 3.12. Install the core package: pip install plexe (includes XGBoost, Keras, scikit-learn). Add framework extras as needed: pip install "plexe[catboost]", pip install "plexe[lightgbm]", pip install "plexe[pytorch]", or task extras like pip install "plexe[tabular]" (CatBoost+LightGBM) and pip install "plexe[vision]" (PyTorch). Platform extras: pip install "plexe[pyspark]", pip install "plexe[aws]". After installation, set API keys: export OPENAI_API_KEY=<your-key> and export ANTHROPIC_API_KEY=<your-key> (other providers via LiteLLM).
How do you use this agent?
Run from the command line: python -m plexe.main --train-dataset-uri data.parquet --intent "predict whether a passenger was transported" --max-iterations 5. In Python: use from plexe.main import main; best_solution, metrics, report = main(intent="...", data_refs=["train.parquet"], max_iterations=5, work_dir=Path("./workdir")). Optional parameters include allowed_model_types (e.g., ["xgboost"]) and enable_final_evaluation=True. A YAML config file can be set via CONFIG_FILE=config.yaml to customize LLM routing, search parameters, and Spark settings. For Docker, build the image with make build or run directly with a command that mounts the data and workdir. After execution, the model package is in work_dir/model/ and the dashboard can be started with python -m plexe.viz --work-dir ./workdir.
FAQ
What API keys are required to run Plexe?
Does Plexe support non-tabular data?
vision extra for PyTorch, but no concrete example of image data is provided, so it's unclear.Can I customize the model search process?
max_iterations, allowed_model_types, and LLM routing in a YAML config file. You can also implement the WorkflowIntegration interface to hook into storage or deployment.