> ## 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.

# Get started with Cache-Pot in under 5 minutes

> Install Cache-Pot, connect your first Redis client, run your first vector search, and explore the web dashboard — all in under 5 minutes.

By the end of this guide you will have Cache-Pot running locally, a Redis client talking to it, a working vector search, and a semantic cache query — plus a live look at the built-in web dashboard. The whole walkthrough takes less than five minutes from a fresh machine.

<Steps>
  <Step title="Install Cache-Pot">
    Pick whichever method suits your environment. Both options produce the same running server.

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

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

    The `go install` path requires Go 1.25 or newer and places the binary in `$GOPATH/bin`. The Docker image requires no local Go toolchain.
  </Step>

  <Step title="Start the server">
    If you installed via Go, launch the binary directly. You should see two startup lines confirming the RESP2 listener and the dashboard are both up.

    ```bash theme={null}
    cache-pot
    ```

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

    Cache-Pot listens for Redis clients on `:6379` and serves the management dashboard on `:8080`. Both ports are configurable — see the [configuration reference](/configuration/server) for details.
  </Step>

  <Step title="Connect with redis-cli">
    Open a second terminal and connect with `redis-cli`. Any Redis client or library works in exactly the same way — this step just confirms the server is healthy.

    ```bash theme={null}
    redis-cli ping
    ```

    ```
    PONG
    ```

    Now set and retrieve a key:

    ```bash theme={null}
    redis-cli set hello world
    # OK

    redis-cli get hello
    # "world"
    ```

    <Tip>
      Any Redis client library works with Cache-Pot out of the box. Here are quick examples for two popular ones.

      <CodeGroup>
        ```js Node.js (ioredis) theme={null}
        const Redis = require('ioredis');
        const client = new Redis({ host: 'localhost', port: 6379 });
        await client.set('hello', 'world');
        const val = await client.get('hello');
        console.log(val); // world
        ```

        ```python Python (redis-py) theme={null}
        import redis
        r = redis.Redis(host='localhost', port=6379)
        r.set('hello', 'world')
        print(r.get('hello'))  # b'world'
        ```
      </CodeGroup>
    </Tip>
  </Step>

  <Step title="Try the AI features">
    **Vector search** stores your embeddings directly — pass the float values and Cache-Pot handles the index. No API key is needed for vector search itself.

    ```bash theme={null}
    # Insert two vectors into the "embeddings" collection
    redis-cli VSET embeddings doc1 0.1 0.2 0.3 META "hello world"
    redis-cli VSET embeddings doc2 0.9 0.8 0.7 META "goodbye world"

    # Find the nearest neighbour to a query vector
    redis-cli VSEARCH embeddings 0.1 0.2 0.3
    # 1) "doc1"
    # 2) "hello world"
    ```

    **Semantic caching** stores model responses and returns them when a close-enough prompt arrives later, saving you a model call.

    ```bash theme={null}
    redis-cli SCACHE.SET "What is the capital of France?" "Paris"
    redis-cli SCACHE.GET "whats the capital of france" THRESHOLD 0.9
    # "Paris"
    ```

    <Note>
      Semantic caching requires an embeddings provider. Set `CACHEPOT_EMBED_URL`, `CACHEPOT_EMBED_MODEL`, and (if needed) `CACHEPOT_EMBED_KEY` before starting the server. A free local [Ollama](https://ollama.com) instance works, and so does the OpenAI embeddings API. See [Semantic Cache configuration](/concepts/semantic-cache) for setup instructions.
    </Note>
  </Step>

  <Step title="Open the dashboard">
    Navigate to [http://localhost:8080](http://localhost:8080) in your browser. The dashboard is baked into the binary — no build step, no external assets.

    From the dashboard you can:

    * Watch live command throughput, memory usage, and key counts on the **Overview** panel
    * Browse, inspect, and edit every key in the **Browser**
    * Run commands interactively in the **Workbench**
    * Stream a live command log with the **Profiler**
    * Review slow commands in the **SlowLog**
    * Publish and subscribe to channels in the **Pub/Sub** panel
    * Analyse memory distribution by type and namespace in **Analysis**
    * List and kill active connections from **Clients**
  </Step>
</Steps>

## What's next

You now have a fully working Cache-Pot instance. Explore the areas below to go deeper.

* [Introduction](/introduction) — understand the full feature set and how Cache-Pot compares to Redis
* [Installation](/installation) — persistent volumes, build-from-source, and production flags
* [Configuration](/configuration/server) — authentication, persistence (snapshots and AOF), and embedding providers
* [AI Agents & MCP](/guides/ai-agents) — connect Claude or another MCP agent to Cache-Pot