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

# Self-host

> Host Worlds locally or via Docker

Worlds self-hosting is available through the respective GitHub repositories. Use
the repository README and package docs for the component you are deploying. For
how hosted Worlds work, see [Worlds](/worlds/index).

## Current status

Self-hosting is not part of the private beta. The supported path depends on
which Worlds components you run:

* [`worlds-api`](https://github.com/wazootech/worlds-api): the self-hostable
  Worlds data-plane service (search, SPARQL, import, export).
* [`worlds-sdk-ts`](https://github.com/wazootech/worlds-sdk-ts): local and
  embedded Worlds SDK usage.
* [`worlds-client-ts`](https://github.com/wazootech/worlds-client-ts): generated
  data-plane HTTP client for the hosted or self-hosted Worlds API.
* [`worlds-libsql`](https://github.com/wazootech/worlds-libsql): durable
  SQLite-compatible storage through LibSQL/Turso-style backends.
* [`worlds-postgres`](https://github.com/wazootech/worlds-postgres): durable
  PostgreSQL-backed storage.
* [`worlds-vps`](https://github.com/wazootech/worlds-vps): full-stack VPS
  deployment composition with Terraform and Docker Compose.

Private networking patterns such as Docker Compose, Tailscale, or Cloudflare
Tunnel depend on your deployment environment and should be configured alongside
the repository-specific setup.

## Storage backends

Worlds storage drivers ship as standalone JSR packages. Pick the backend that
matches your persistence needs. All five durable backends now ship full SDK
factories with hybrid search and parity-green CI suites.

### LibSQL / Turso

[`@worlds/libsql`](https://jsr.io/@worlds/libsql) provides durable LibSQL
storage with hybrid full-text and vector search. `createLibsqlSdk` assembles a
quad store, search index, and SPARQL engine over a LibSQL connection:

```typescript theme={null}
import { createClient } from "@libsql/client";
import { createLibsqlSdk } from "@worlds/libsql";

const databaseClient = createClient({ url: ":memory:" });
const client = await createLibsqlSdk({ client: databaseClient });
```

Point the client at an embedded file or a remote Turso URL. The embedded `file:`
backend stores worlds locally; the remote URL keeps them in a managed LibSQL
database.

### PostgreSQL

[`@worlds/postgres`](https://jsr.io/@worlds/postgres) provides durable
PostgreSQL storage with hybrid tsvector + pgvector search. `createPostgresSdk`
assembles a quad store, search index, and SPARQL engine over a PostgreSQL
connection:

```typescript theme={null}
import postgres from "postgres";
import { createPostgresSdk } from "@worlds/postgres";

const sql = postgres("postgres://user:password@localhost/worlds");
const client = await createPostgresSdk({ sql });
```

### SQLite (local file)

[`@worlds/sqlite`](https://jsr.io/@worlds/sqlite) provides durable SQLite
storage via `node:sqlite` with hybrid FTS5 + sqlite-vec search.
`createSqliteSdk` assembles a quad store, search index, and SPARQL engine:

```typescript theme={null}
import { createSqliteSdk } from "@worlds/sqlite";

const client = await createSqliteSdk({ path: ":memory:" });
```

### Cloudflare D1

[`@worlds/cloudflare`](https://jsr.io/@worlds/cloudflare) provides durable D1
storage with FTS5 keyword search. `createCloudflareSdk` assembles a quad store,
search index, and SPARQL engine over a D1 binding:

```typescript theme={null}
import { createCloudflareSdk } from "@worlds/cloudflare";

// Inside a Cloudflare Worker with a D1 binding:
const client = await createCloudflareSdk({ d1: env.DB });
```

### IndexedDB (browser)

[`@worlds/indexeddb`](https://jsr.io/@worlds/indexeddb) provides durable
browser-native storage via IndexedDB with JS-side hybrid TF-IDF + cosine search.
`createIndexeddbSdk` assembles a quad store, search index, and SPARQL engine:

```typescript theme={null}
import { createIndexeddbSdk } from "@worlds/indexeddb";

const client = await createIndexeddbSdk({ dbName: "wazoo" });
```

## VPS deployment

[`worlds-vps`](https://github.com/wazootech/worlds-vps) owns full-stack
orchestration for running Wazoo services on a VPS: DigitalOcean droplet and
firewall Terraform, cloud-init bootstrap, Caddy routing, and Docker Compose
wiring for the service images.

Copy `.env.example` to `.env`, set the values used by `docker-compose.yml`, then
start the stack:

```sh theme={null}
cp .env.example .env
docker compose config
docker compose up -d
```

The compose file wires the `ghcr.io/wazootech` service images: `wazoo-api`,
`worlds-api`, and `wazoo-console`, fronted by Caddy for HTTPS routing. The
`worlds-api` service runs on a file-backed LibSQL database mounted as a Docker
volume.

For the DigitalOcean droplet, create `do.auto.tfvars` with the variables listed
in the repository README, then apply the Terraform composition:

```sh theme={null}
terraform init
terraform plan -out=tfplan
terraform apply "tfplan"
```

## Deployment responsibilities

When you self-host, you own:

* Worlds data services and storage.
* Network ingress and access control.
* Token issuance and rotation.
* Backups, monitoring, and incident response.

Do not assume a compliance posture from these docs alone. Treat each self-hosted
deployment as an architecture review for your environment.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.