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

# Quickstart

> Run InferCrane locally and send an OpenAI-compatible request in under five minutes.

# Your first InferCrane request

In this guide you will start the complete control and request path, call a stable model endpoint, and
inspect the durable state behind it. No GPU or cloud account is required.

<Info>
  The local stack uses GPU-free fake vLLM workers. It proves application and lifecycle behavior, not
  model quality, GPU performance, or real-provider compatibility.
</Info>

## See the complete safety loop first

From a repository checkout, one command runs the local product proof and cleans up its isolated
Docker project:

```bash theme={"theme":{"light":"github-light-default","dark":"vesper"}}
make demo
```

It connects an existing endpoint, sends and inspects a request, creates an intentionally unready
candidate without provisioning it, records a deterministic Release Guard rejection, verifies the
active revision did not change, rejects the candidate, and removes all temporary state. The output
is explicitly marked as fixture evidence; it does not claim GPU or provider qualification.

## Prerequisites

* Git
* Docker with Compose v2
* Port `18000` available

<Steps>
  <Step title="Clone InferCrane">
    ```bash theme={"theme":{"light":"github-light-default","dark":"vesper"}}
    git clone https://github.com/infercrane/infercrane.git
    cd infercrane
    ```
  </Step>

  <Step title="Start the local stack">
    ```bash theme={"theme":{"light":"github-light-default","dark":"vesper"}}
    docker compose up --build -d
    curl -fsS http://127.0.0.1:18000/readyz
    ```

    The stack includes PostgreSQL, InferCrane, two fake workers, and a development router. The
    development API key is `infercrane`; production mode rejects that default.
  </Step>

  <Step title="Send a request">
    <CodeGroup>
      ```bash InferCrane CLI theme={"theme":{"light":"github-light-default","dark":"vesper"}}
      docker compose exec infercrane \
        infercrane request qwen-prod --message "Explain durable operations in one sentence."
      ```

      ```bash cURL theme={"theme":{"light":"github-light-default","dark":"vesper"}}
      curl -fsS http://127.0.0.1:18000/v1/chat/completions \
        -H 'Authorization: Bearer infercrane' \
        -H 'Content-Type: application/json' \
        -d '{
          "model": "qwen-prod",
          "messages": [{"role": "user", "content": "Hello"}]
        }'
      ```

      ```python Python theme={"theme":{"light":"github-light-default","dark":"vesper"}}
      from openai import OpenAI

      client = OpenAI(
          base_url="http://127.0.0.1:18000/v1",
          api_key="infercrane",
      )

      response = client.chat.completions.create(
          model="qwen-prod",
          messages=[{"role": "user", "content": "Hello"}],
      )
      print(response.choices[0].message.content)
      ```

      ```typescript TypeScript theme={"theme":{"light":"github-light-default","dark":"vesper"}}
      import OpenAI from "openai";

      const client = new OpenAI({
        baseURL: "http://127.0.0.1:18000/v1",
        apiKey: "infercrane",
      });

      const response = await client.chat.completions.create({
        model: "qwen-prod",
        messages: [{ role: "user", content: "Hello" }],
      });
      console.log(response.choices[0].message.content);
      ```
    </CodeGroup>

    Add `--stream` to the CLI request to print response text as chunks arrive.
  </Step>

  <Step title="Inspect what happened">
    ```bash theme={"theme":{"light":"github-light-default","dark":"vesper"}}
    docker compose exec infercrane infercrane status qwen-prod
    docker compose exec infercrane infercrane events qwen-prod
    docker compose exec infercrane infercrane explain qwen-prod
    ```

    These commands use the authenticated control-plane API. Public CLI workflows never connect
    directly to PostgreSQL.
  </Step>

  <Step title="Open the terminal operations view">
    ```bash theme={"theme":{"light":"github-light-default","dark":"vesper"}}
    docker compose exec infercrane infercrane ui
    ```

    The terminal workspace reads the same durable control API and can be closed without cancelling
    operations. The separately released browser console is currently in private preview; see
    [Operations console](/features/dashboard) for the local self-hosted boundary.
  </Step>

  <Step title="Stop the stack">
    ```bash theme={"theme":{"light":"github-light-default","dark":"vesper"}}
    docker compose down
    ```

    This preserves PostgreSQL data. Add `--volumes` only when you intend to delete the local state.
  </Step>
</Steps>

## Choose your next path

<CardGroup cols={3}>
  <Card title="Deploy a real model" icon="server" href="/showcase/build-inference">
    Plan provider and runtime choices before creating billable capacity.
  </Card>

  <Card title="Connect an endpoint" icon="plug" href="/showcase/connect-existing">
    Observe an existing vLLM, LiteLLM, or OpenAI-compatible endpoint first.
  </Card>

  <Card title="Understand the model" icon="shapes" href="/concepts">
    Learn endpoints, environments, serving plans, deployments, and revisions.
  </Card>
</CardGroup>

## Before creating real infrastructure

The Homebrew formula and release archives are prepared but not yet publicly released. Until the
release package is published, build the CLI from source:

```bash theme={"theme":{"light":"github-light-default","dark":"vesper"}}
go build -o ./bin/infercrane ./cmd/infercrane
export INFERCRANE_API_KEY='ISSUED_CONTROL_PLANE_CREDENTIAL'
./bin/infercrane init --url https://infercrane.example
./bin/infercrane auth status
./bin/infercrane doctor --cloud
./bin/infercrane plan Qwen/Qwen3-8B --cloud runpod --gpu L40S
```

`plan` is side-effect free. A real `deploy` can create billable resources, so check
[provider setup](/provider-setup) and the [capability matrix](/project-status) first. Adapter
registration does not prove that an exact model, runtime, GPU, and provider combination has passed
real-infrastructure qualification.