> ## Documentation Index
> Fetch the complete documentation index at: https://cache-pot.thatdevguy.in/llms.txt
> Use this file to discover all available pages before exploring further.

# Install Cache-Pot: Go, Docker, or build from source

> Install Cache-Pot using Go install, Docker, or by building from source. Cache-Pot is a single binary with zero external dependencies.

Cache-Pot ships as a single self-contained binary with no external dependencies — no database engine to install, no configuration file required, no companion services to keep running. Choose the installation method that fits your workflow: pull the binary with `go install`, run a Docker container, or build directly from source.

<Note>
  No external services or databases are required. Once the binary starts, it brings up its own RESP2 server, vector index, semantic cache, MCP bridge, and web dashboard by itself.
</Note>

## Installation methods

<Tabs>
  <Tab title="Go Install">
    If you have Go 1.25 or newer on your machine, `go install` fetches, compiles, and places the binary in `$GOPATH/bin` in a single command.

    ```bash theme={null}
    go install github.com/subh05sus/cache-pot/cmd/cache-pot@latest
    cache-pot
    ```

    Make sure `$GOPATH/bin` (usually `~/go/bin`) is on your `PATH` so you can run `cache-pot` from any directory:

    ```bash theme={null}
    export PATH="$PATH:$(go env GOPATH)/bin"
    ```

    <Note>
      Requires Go 1.25 or newer. Download Go from [go.dev/dl](https://go.dev/dl/) if you don't have it installed.
    </Note>
  </Tab>

  <Tab title="Docker">
    Pull and run the official image with a single command. Docker exposes both the Redis port and the dashboard port automatically.

    ```bash theme={null}
    docker run -p 6379:6379 -p 8080:8080 ghcr.io/subh05sus/cache-pot:latest
    ```

    **With a persistent data volume**

    By default the container stores its snapshot inside the container filesystem, which is lost when the container stops. Mount a named volume to keep your data across restarts:

    ```bash theme={null}
    docker run -p 6379:6379 -p 8080:8080 \
      -v cache-pot-data:/data \
      ghcr.io/subh05sus/cache-pot:latest
    ```

    **Passing configuration flags**

    Append any `cache-pot` flags after the image name, or use environment variables (every flag has a `CACHEPOT_*` equivalent):

    ```bash theme={null}
    docker run -p 6379:6379 -p 8080:8080 \
      -e CACHEPOT_AUTH=mysecretpassword \
      -e CACHEPOT_EMBED_URL=https://api.openai.com/v1/embeddings \
      -e CACHEPOT_EMBED_KEY=sk-your-key \
      ghcr.io/subh05sus/cache-pot:latest
    ```

    <Tip>
      For development you can omit the `-v` flag entirely. For any environment where data needs to survive container restarts, always mount a named volume or a host directory.
    </Tip>
  </Tab>

  <Tab title="Build from Source">
    Clone the repository and build the binary with the standard Go toolchain. This gives you the very latest code and lets you modify Cache-Pot before running it.

    ```bash theme={null}
    git clone https://github.com/subh05sus/cache-pot
    cd cache-pot
    go build -o cache-pot ./cmd/cache-pot
    ./cache-pot
    ```

    The resulting `cache-pot` binary in the current directory has no runtime dependencies — copy it wherever you need it.

    <Tip>
      To install the locally-built binary system-wide, copy it to a directory on your `PATH`:

      ```bash theme={null}
      cp cache-pot /usr/local/bin/cache-pot
      ```
    </Tip>
  </Tab>
</Tabs>

## Verifying the installation

After installation, confirm the binary is available and the server is responding:

```bash theme={null}
# Check the binary version
cache-pot --version

# Confirm the server is answering Redis commands
redis-cli -p 6379 ping
# PONG
```

If `redis-cli` returns `PONG`, Cache-Pot is running correctly and ready to accept connections.

## What starts up

When Cache-Pot launches you will see two lines in the terminal output:

```
cache-pot: listening on [::]:6379
cache-pot: dashboard on http://localhost:8080
```

Two services start on every run:

| Port    | Service          | Description                                                    |
| ------- | ---------------- | -------------------------------------------------------------- |
| `:6379` | RESP2 TCP server | Redis-compatible endpoint — connect any Redis client here      |
| `:8080` | Web dashboard    | Built-in management console — no build step or external assets |

Both ports are configurable. Pass `--addr` to change the Redis port, `--dashboard-addr` to change the dashboard port, or set either to an empty string to disable it:

```bash theme={null}
# Change ports
cache-pot --addr :6380 --dashboard-addr :9090

# Disable the dashboard entirely
cache-pot --dashboard-addr ""
```

## Next steps

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Connect a Redis client, run a vector search, and try the semantic cache in under 5 minutes.
  </Card>

  <Card title="Server configuration" icon="sliders" href="/configuration/server">
    Set up authentication, configure snapshot and AOF persistence, and connect an embeddings provider.
  </Card>
</CardGroup>