# CoML: the Jupyter assistant whose PyPI name is still mlcopilot

> CoML is Microsoft's MIT-licensed interactive coding assistant for data scientists and machine learning work, loaded into Jupyter as a magic extension and driven by a pinned gpt-3.5-turbo-16k model. It is a notebook-only tool with a hard platform ceiling and a cost per request, and its last push was 2024-10-08.

**microsoft/CoML** — Interactive coding assistant for data scientists and machine learning developers, empowered by large language models.

- Repository: https://github.com/microsoft/CoML
- Stars: 100 · Forks: 17
- Language: Python
- License: MIT
- Published: 2026-08-17 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/microsoft-coml

## The distribution is named mlcopilot because coml is taken on PyPI

The first surprise arrives at the install step. The project is called CoML everywhere in its own code, its magic commands, and its extension name, but the install command is:

```bash
pip install mlcopilot
```

The reason is stated plainly in the docs: we can't have the name coml on PyPI, so we use mlcopilot instead. The project was also renamed, from MLCopilot to CoML, so the old name survives in two places at once: the package you install and the config agent that was built as its own component. That mismatch between distribution name and import name is the sort of thing that wastes an afternoon if you do not know about it, because `import coml` after a failed `pip install coml` looks like a broken tool rather than a name collision.

## Two pieces of setup, then three magic commands

Getting CoML into a session takes two prerequisites and then gives you a small command set. First, you need to have exported OPENAI_API_KEY=sk-xxxx in your environment, or alternatively use a .env file. Second, you use %load_ext coml in your notebook to activate the extension. After that there are three commands. %coml <task> prompts CoML to write a cell for your task. %comlfix fixes the cell just above the current cell, and it also accepts an argument: %comlfix <reason> lets you supply details about what is wrong. %comlinspire goes the other way and gives you a cell describing what to do next. The design is a narrow loop around the one cell you are looking at.

## nbclassic on Linux is the ceiling, and the newer front ends are unfinished

The platform support is narrower than the Jupyter name suggests, and the project says so directly. CoML currently supports Jupyter Lab and classical Jupyter notebook, which the docs specify as nbclassic and only on Linux platforms. Everything else is a work in progress: newer Jupyter notebook, Jupyter-vscode, and Google Colab are all named as still being worked on. So the combination that works today is Jupyter Lab anywhere, or the old notebook interface on Linux, and if your workflow lives in VS Code or Colab then there is no supported path at all. The package metadata reinforces the boundary from the other side, with classifiers for JupyterLab 4 and Prebuilt extensions and supported Python versions from 3.8 to 3.11.

## The model is pinned, and every cell you generate costs about $0.04

There is one configuration detail that decides whether this tool is usable for you, and it is not adjustable. CoML uses the gpt-3.5-turbo-16k model in its implementation, and the docs state there is no way to change the model for now. The same paragraph gives the price: the cost of using this model is around $0.04 per request, with an explicit note to be aware of that cost. Multiply by the loop described earlier and you get a bill that scales with iteration rather than with time, which suits a workflow where you ask for a handful of cells and not one where you are trying many candidates. The dependency list explains the plumbing: langchain, langchain-community, and langchain-openai sit alongside tiktoken for token counting.

## The config agent wants a database copied into your home directory

The CoML config agent is a separate component that suggests a machine learning configuration within a specific task for a specific space. It currently lives on its own inside coml.configagent, and the docs are explicit that in the future it will be integrated into the CoML system, which tells you not to design around it being part of the notebook flow yet. Using it takes preparation steps, and one of them is worth reading carefully: clone this repo with `git clone REPO_URL; cd coml`, where REPO_URL is an unfilled placeholder rather than a real address. After cloning you put assets/coml.db in your home directory with `cp assets/coml.db ~/.coml/coml.db`, then copy coml/.env.template to ~/.coml/.env and put your API keys in the file.

## The config agent answers to flags, an interactive prompt, or a Python import

Invoked independently, the agent gives you three ways in. The command line takes a space and a task directly:

```
coml-configagent --space <space> --task <task>
```

If you are not sure what belongs in either slot, the docs point you at the interactive mode:

```
coml-configagent --interactive
```

There is also an API path, which returns both the suggested configurations and the knowledge it used:

```python
from coml.configagent.suggest import suggest

space = import_space("YOUR_SPACE_ID")
task_desc = "YOUR_TASK_DESCRIPTION_FOR_NEW_TASK"
suggest_configs, knowledge = suggest(space, task_desc)
```

The console entry point is registered as coml-configagent and resolves to coml.configagent.cli:main, so the command name and the module path both stay stable even though the tool is not yet wired into the notebook.

## Developers install editable with the dev extra, then link the lab extension

The development path splits into Python and TypeScript halves, and you need both. The Python side installs as an editable package with the dev extra:

```
pip install -e .[dev]
```

If you are developing the Jupyter Lab extension you also need NodeJS and npm, then link your development version of the extension and rebuild its TypeScript source:

```
# Link your development version of the extension with JupyterLab
jupyter labextension develop . --overwrite
# Rebuild extension Typescript source after making changes
jlpm run build
```

Removal is manual in three places. You disable the server extension with `jupyter server extension disable coml`, uninstall the Python package with `pip uninstall mlcopilot`, and then delete the symlink that jupyter labextension develop created. To find it, run `jupyter labextension list` to locate the labextensions folder and remove the symlink named coml inside it.

## Version 0.0.8 lives in two files, and packaging goes through hatch

The build is split across a Python package and a Jupyter extension, which is why there are two manifest files. pyproject.toml names the project mlcopilot at version 0.0.8 with hatchling as the build backend and hatch-nodejs-version in the build requirements, and package.json names the extension coml at the same 0.0.8 with lib/index.js as its entry point. The version is read from the Node side: the hatch version source is set to nodejs with the description field as a metadata hook, so editing one file moves both. Packaging itself is one command, `hatch build`. On the dependency side the list is broad and honest about what the tool leans on: langchain for the model plumbing, peewee and psycopg2-binary for storage, pandas, numpy, scikit_learn, and xgboost for the machine learning side, and ipython, ipywidgets, and ipylab for the notebook layer.

## Conclusion

CoML fits someone already working inside Jupyter Lab on Linux who wants a cell written from a sentence and a fix applied to the cell above. Skip it if you need VS Code, Google Colab, or a modern notebook front end, since none of those work yet, and skip it if you need to choose the model, because there is no way to change it from gpt-3.5-turbo-16k. Before you install, note that pip install mlcopilot is the correct command and that coml is not available on PyPI, and budget roughly $0.04 per request against your OPENAI_API_KEY.

## FAQ

### What is CoML, and what was it called before?

CoML, formerly MLCopilot, is an interactive coding assistant for data scientists and machine learning developers. It is MIT licensed and its codebase lives in the coml package.

### How do I install CoML for Jupyter?

Run pip install mlcopilot. The package is named mlcopilot because the name coml is not available on PyPI, even though the package and its Jupyter magic are both called coml.

### What do I need before CoML works in a notebook?

Export OPENAI_API_KEY=sk-xxxx in your environment, or use a .env file, then run %load_ext coml in the notebook to activate the CoML extension.

### Which Jupyter environments does CoML support?

CoML currently supports Jupyter Lab and the classical Jupyter notebook, meaning nbclassic and only on Linux platforms. Support for newer Jupyter notebook, Jupyter-vscode, and Google Colab is still in progress.

### Which model does CoML use and what does a request cost?

CoML uses gpt-3.5-turbo-16k in its implementation, and there is no way to change the model for now. The cost of using this model is around $0.04 per request.

## Sources

- [Official README](https://github.com/microsoft/CoML#readme)
- [Project repository](https://github.com/microsoft/CoML)
- [Release notes](https://github.com/microsoft/CoML/releases)

---

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