# What Are the Dependencies for Marin? Complete Guide to the Python Workspace

> Explore Marin's dependencies in this comprehensive guide. Understand internal packages like marin-iris and external libraries like watchdog, all managed via pyproject.toml.

- Repository: [The Marin Project/marin](https://github.com/marin-community/marin)
- Tags: how-to-guide
- Published: 2026-08-27

---

**Marin is a multi-workspace Python project whose dependencies are defined across a root [`pyproject.toml`](https://github.com/marin-community/marin/blob/main/pyproject.toml) and multiple workspace member manifests under `lib/`, requiring internal packages like `marin-iris` and `marin-levanter` alongside external libraries such as `watchdog` and `pydantic`.**

Marin is a sophisticated, multi-package Python ecosystem hosted at `marin-community/marin`. Understanding the dependencies for Marin requires examining both the root project configuration and the individual workspace members that compose the full architecture. This guide breaks down the complete dependency graph, from core runtime requirements to constraint overrides and installation methods.

## Core Runtime Dependencies

The root [[`pyproject.toml`](https://github.com/marin-community/marin/blob/main/pyproject.toml)](https://github.com/marin-community/marin/blob/main/pyproject.toml) defines the essential packages required to run the base Marin system. These dependencies are declared in the project metadata section and include both internal workspace packages and external utilities.

The primary runtime dependencies specified at [lines 12‑44](https://github.com/marin-community/marin/blob/main/pyproject.toml#L12-L44) include:

- **Internal workspace packages**: `marin-iris`, `marin-fray`, `marin-haliax`, `marin-levanter`, `marin-core`, `marin-rigging[secrets]`, `marin-zephyr`, `marin-finelog`, `marin-deploy`, `marin-ducky`, `marin-dupekit`
- **External monitoring**: `watchdog` for filesystem monitoring

These dependencies establish the foundation upon which specific workspace members build their own requirements.

## Workspace Members and Sub-Package Dependencies

Marin employs UV workspace support to manage interdependent packages. The workspace structure is defined in the root [`pyproject.toml`](https://github.com/marin-community/marin/blob/main/pyproject.toml) at [lines 26‑42](https://github.com/marin-community/marin/blob/main/pyproject.toml#L26-L42), enumerating members across the `lib/` and `infra/` directories:

```toml
[tool.uv.workspace]
members = [
    "lib/iris",
    "lib/fray",
    "lib/finelog",
    "lib/dupekit",
    "lib/ducky",
    "lib/haliax",
    "lib/levanter",
    "lib/marin",
    "lib/rigging",
    "lib/zephyr",
    "lib/finestore",
    "infra/pulumi",
    "infra/buckets",
    "infra/deploy",
]

```

Each workspace member contributes its own dependency manifest, creating a composite dependency graph when the full project is installed.

### Dependency Breakdown: marin-iris

The `marin-iris` package demonstrates how workspace members extend the core dependencies. Defined in [[`lib/iris/pyproject.toml`](https://github.com/marin-community/marin/blob/main/lib/iris/pyproject.toml)](https://github.com/marin-community/marin/blob/main/lib/iris/pyproject.toml) at [lines 9‑47](https://github.com/marin-community/marin/blob/main/lib/iris/pyproject.toml#L9-L47), it requires:

- **Marin internal**: `marin-finestore`, `marin-rigging`, `marin-finelog`, `marin-finelog-server`, `marin-iris-native`
- **CLI and serialization**: `click`, `cloudpickle`, `pyyaml`, `cbor2` (via `zstandard` and other compression libs)
- **Cloud storage**: `fsspec`, `gcsfs`, `s3fs`, `google-auth`, `google-cloud-tpu`
- **Networking**: `grpcio`, `httpx`, `uvicorn[standard]`, `starlette`
- **Data and authentication**: `pydantic`, `PyJWT[crypto]`, `sqlalchemy`, `tabulate`, `typing-extensions`, `humanfriendly`

Other workspace packages like `marin-levanter` (JAX-based training) and `marin-zephyr` (dataset pipelines) maintain similar granular dependency lists in their respective [`pyproject.toml`](https://github.com/marin-community/marin/blob/main/pyproject.toml) files.

## Constraint and Override Dependencies

Marin manages complex version requirements through two specialized sections in the root manifest: constraints for pre-release packages and overrides for forced version pins.

### Pre-Release Constraints

Located at [lines 58‑66](https://github.com/marin-community/marin/blob/main/pyproject.toml#L58-L66), these dependencies are enabled only when pre-release versions are allowed:

- `tfp-nightly>=0.1.dev0`
- `opentelemetry-instrumentation>=0.41b0`
- `opentelemetry-instrumentation-grpc>=0.41b0`
- `opentelemetry-semantic-conventions>=0.1b0`

### Forced Version Overrides

The override section at [lines 68‑99](https://github.com/marin-community/marin/blob/main/pyproject.toml#L68-L99) forces specific minimum versions to resolve upstream compatibility issues:

- **Configuration**: `omegaconf>=2.4.0.dev4`
- **AI/ML libraries**: `anthropic>=0.71.0`, `litellm>=1.83.14`, `tiktoken>=0.12.0`
- **Web framework components**: `gradio>=6.14.0`, `aiofiles>=24.1.0`, `python-multipart>=0.0.27`
- **Jupyter ecosystem**: `jupyter-server>=2.18.2`, `jupyterlab>=4.5.7`, `notebook>=7.5.6`
- **Infrastructure**: `ray>=2.55.1`, `datasets>=3.1.0,<5.0.0`, `equinox>=0.11.10`

## Optional Extras and Conflict Rules

The Marin dependency tree includes optional extras that enable specific hardware accelerators or authentication methods. The root [`pyproject.toml`](https://github.com/marin-community/marin/blob/main/pyproject.toml) declares a conflict matrix at lines 100‑124 to prevent incompatible combinations (such as mixing GPU-only and TPU-only extras across different packages).

Key optional configurations include:

- **`marin-rigging[secrets]`**: Required for secret-driven cluster startup
- **`marin-rigging[iap]`**: Optional Identity-Aware Proxy login support
- **Hardware extras**: `--extra=cpu`, `--extra=gpu`, or `--extra=tpu` flags for UV installation

## Installing Marin with UV

The Marin project uses UV for dependency resolution and workspace management. To install the complete dependency graph including all workspace members:

```bash

# Sync the full workspace with all internal packages

uv sync --all-packages --extra=cpu

```

For GPU or TPU support, substitute the appropriate extra flag:

```bash
uv sync --all-packages --extra=gpu

# or

uv sync --all-packages --extra=tpu

```

To install only specific workspace members without the full ecosystem:

```bash
uv pip install ./lib/iris

```

Alternatively, to install just the core runtime without workspace development dependencies:

```bash
pip install marin-root

```

## Summary

- **Marin dependencies** are distributed across a root [`pyproject.toml`](https://github.com/marin-community/marin/blob/main/pyproject.toml) and multiple workspace member manifests under `lib/`.
- **Core runtime** requires internal packages like `marin-iris`, `marin-levanter`, and external tools like `watchdog` ([lines 12‑44](https://github.com/marin-community/marin/blob/main/pyproject.toml#L12-L44)).
- **Workspace members** such as `lib/iris` and `lib/levanter` define their own granular dependency sets for cloud storage, ML frameworks, and networking.
- **Constraint and override sections** manage pre-release packages (`tfp-nightly`, OpenTelemetry) and force minimum versions for critical libraries (`anthropic`, `gradio`, `ray`).
- **Installation** requires UV with `--all-packages` flag to resolve the workspace graph correctly.

## Frequently Asked Questions

### What package manager should I use to install Marin dependencies?

Use **UV** to install Marin. The project is structured as a UV workspace, and the `uv sync` command correctly resolves interdependencies between the root package and workspace members like `marin-iris` and `marin-levanter`. Standard `pip` can install individual packages but may not resolve workspace-internal dependencies correctly.

### Where are the hardware-specific dependencies defined in Marin?

Hardware-specific dependencies (CPU, GPU, TPU) are managed through optional extras in the root [`pyproject.toml`](https://github.com/marin-community/marin/blob/main/pyproject.toml) and individual workspace members. The conflict matrix at lines 100‑124 prevents mixing incompatible hardware extras, while `marin-levanter`'s manifest contains JAX-related dependencies for accelerator support.

### Can I install a single workspace member without the full Marin dependency tree?

Yes. Navigate to the specific workspace directory (e.g., `lib/iris/`) and run `uv pip install .` or `pip install .` to install only that package's dependencies. However, note that internal Marin dependencies (like `marin-rigging`) will still resolve from the workspace if not available on PyPI.

### What is the purpose of the override dependencies in Marin's pyproject.toml?

The override section ([lines 68‑99](https://github.com/marin-community/marin/blob/main/pyproject.toml#L68-L99)) forces specific minimum versions to resolve upstream compatibility issues with transitive dependencies. This ensures critical packages like `omegaconf`, `anthropic`, and `ray` meet version requirements even if other packages in the tree specify lower bounds.