> ## Documentation Index
> Fetch the complete documentation index at: https://docs.monk.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Package Ecosystem

> Pre-built, battle-tested packages — automatically adapted to your stack

## What It Does

Monk's package ecosystem gives you hundreds of pre-built packages for databases, services, APIs, and infrastructure. The [orchestrator](/features/containerization) uses them to deploy resources. Monk agents use them to understand and manage everything about those resources.

## How It Works

### What Packages Contain

Monk packages are comprehensive definitions. They carry everything needed to deploy and manage a service.

**Deployable workloads:**

* Container-based services (databases, web servers, message queues, etc.)
* Configuration for running the service
* Health checks and lifecycle management

**Infrastructure definitions:**

* Cloud resource requirements (VMs, storage, networking)
* Infrastructure blueprints for optimal deployment
* Multi-cloud compatibility specifications

**Custom resource definitions:**

* Interfaces for managing virtually any resource
* Integration points for third-party services
* Lifecycle hooks and operational patterns

**Extensions for Monk agents:**

* Service-specific behaviors and actions
* Monitoring and troubleshooting capabilities
* Cost estimation interfaces

### Composable by Design

Packages compose other packages. That's how you build systems without reinventing anything.

A web application package might compose a PostgreSQL database package, a Redis cache package, and an Nginx web server package. Each sub-package brings its own capabilities and management logic. The composed system works as a unified whole.

You don't copy-paste. You compose.

### Extensible Without Duplication

Want a custom PostgreSQL configuration? Override the base package. Only define what's different. Inherit everything else — container runtime setup, health checks, the works.

Less repeated code. More succinct definitions. Easier to maintain.

```yaml theme={null}
# Override just what you need:
namespace: my-app

postgresql:
  inherits: monk-postgresql # Base PostgreSQL package
  variables:
    max-connections: 200
    shared-buffers: "2GB"
```

### Programmable with Scripting

Packages can contain arbitrary scripting for complex behaviors:

* **ArrowScript** — Monk's declarative scripting language for defining service behaviors, health checks, and operational patterns inside packages.
* **TypeScript framework** — For full customization and complex logic
* **Custom operation patterns** — Entirely custom workflows and actions

Use these for database backup automation, custom health checks, complex deployment orchestration, or service-specific management operations.

### Your Code Becomes Packages

When Monk performs [code analysis](/features/code-analysis) on your application:

1. Monk packages up your services — each component becomes a package definition
2. It composes them with existing packages — your services combined with databases, caches, etc.
3. You review the resulting definition — see the full packaged system

Your application gets treated the same way as pre-built packages. Same capabilities for deployment, scaling, and management.

### Content-Addressed and Immutable

Security is built into the package system.

* **Content-addressed** — packages identified by cryptographic hash of their contents
* **Immutable** — once published, a package can't be changed
* **Guarded against supply chain attacks** — tampering is prevented by design

Packages are currently permissioned and vetted by the Monk team. Quality standards are enforced before publication, and community contributions are reviewed and tested.

### The Ecosystem

Hundreds of packages. Databases like PostgreSQL, MySQL, MongoDB, Redis. Message queues like Kafka and RabbitMQ. Monitoring stacks, DevOps tools, CMS platforms, AI/ML runtimes, and more.

See [Integrations](/integrations) for the full list.

### Open Source Contributions

Many Monk packages are open source on GitHub at [monk-io](https://github.com/monk-io). You can review package definitions, submit improvements, contribute new packages, or learn from existing implementations.

Popular repositories include [monk-metabase](https://github.com/monk-io/monk-metabase), [monk-prometheus-grafana](https://github.com/monk-io/monk-prometheus-grafana), [monk-ollama](https://github.com/monk-io/monk-ollama), and 100+ more.

<Info>Private packages for teams — team-specific repositories, version control, access control — are on the roadmap. [Vote on what to prioritize](https://monk.io/roadmap).</Info>

<CardGroup cols={2}>
  <Card title="Containerization & Orchestration" icon="cubes" href="/features/containerization">
    How the orchestrator uses packages to deploy your stack.
  </Card>

  <Card title="Code Analysis" icon="magnifying-glass-code" href="/features/code-analysis">
    How Monk turns your code into packages.
  </Card>
</CardGroup>