---
title: "Install and Use NVIDIA PAIR — Set Up the PAIR App"
canonical: "https://build.nvidia.com/spark/pair/app-setup.md"
---

# Step 1. Install and open PAIR

Install PAIR on each desktop system that will join the cluster. Download the
appropriate package from the
[PAIR releases page](https://github.com/NVIDIA/Personal-AI-Router/releases).

## Windows

1. Download the Windows installer that matches the system's architecture.
2. Run the installer and approve the operating-system and firewall prompts.
3. Open **NVIDIA Personal AI Router** from the Start menu.

## Debian or Ubuntu

Open a terminal in the directory that contains the downloaded package, then
run:

```bash
sudo apt install "./NVPAIR-Setup-VERSION-ARCH.deb"
```

Replace `VERSION` and `ARCH` with the values in the downloaded filename. Then
open **NVIDIA Personal AI Router** from the desktop application menu.

## macOS

1. Open the downloaded `.dmg`.
2. Drag **NVIDIA Personal AI Router** to **Applications**.
3. Open PAIR from **Applications**.

PAIR opens when the installation is complete.

# Step 2. Complete first-run setup

When you first open PAIR, it shows the engines that it can install. Ollama is
selected by default when it is available for the platform.

1. Review the available engines.
2. Select the engines to install, or skip engines that you manage separately.
3. Finish setup and wait for the selected engine to report that it is running.

The first start can take longer while PAIR starts its background services. If
**Overview** still shows **Loading...** after one or two minutes, open
**Settings → Service**, then use the **Troubleshooting** tab.

You can return to engine settings by selecting a node in **Overview**. Use
**Settings → Cluster** to pair systems at any time.

# Step 3. Pair systems

Start PAIR on each system. Confirm that the systems are on the same trusted
local network.

1. On a system already in the cluster, select **Add node** in the top-right
toolbar. You can also open **Settings → Cluster** and use **Available nodes
to add**.
2. Select a discovered system. If PAIR does not find it, add the system by IP
address.
3. PAIR shows a six-digit PIN and sends an invitation.
4. On the invited system, accept the **Cluster invitation** and enter the PIN.
5. Open **Settings → Cluster** and check that the peer appears under
**Connected nodes**. You can also check the node list in **Overview**.
6. Repeat these steps from any cluster member to add more systems.

The peer appears as a connected node when pairing is complete.

# Step 4. Start an engine and add a model

Repeat these steps on every system that should serve the model:

1. Select the system in **Overview** to open its engine settings.
2. Install the engine if needed, then use its switch to start it.
3. Expand the engine and select **Add model**.
4. Download a model and wait for the download to finish.
5. Load the model if the engine requires a separate load step.

A system can serve a request when it is online, the engine is running, and the
requested model is available there. To route requests across several systems,
add the same model to each system that should serve it.

# Step 5. Copy the local endpoint

Applications connect to PAIR on the system where they run. They do not connect
directly to an engine or to the system that will run the request.

1. Select **Endpoints** in PAIR's top toolbar.
2. In the **API endpoints** window, find the engine that you prepared.
3. Copy its `http://127.0.0.1:<port>` URL.

If the window says **No engines are running**, return to step 4 and start an
engine. The endpoint appears when that engine is running on any system in the
cluster, including a remote system.

> [!IMPORTANT]
> Copy the URL from **Endpoints**. PAIR puts a proxy on the engine's usual port
> and moves the engine to the next available port.

# Step 6. Send a test request

Replace `<PAIR_BASE_URL>` with the endpoint from step 5. Replace
`<MODEL_NAME>` with the exact model name from step 4.

## Choose a request style

PAIR passes each request to the selected engine without rewriting it.

| Endpoint | OpenAI `/v1/chat/completions` | Ollama `/api/chat` |
| --- | --- | --- |
| Ollama | Works | Works |
| LM Studio | Works | Not available |

If you are unsure, use the OpenAI-style request. It works with either engine.

## OpenAI-style request

```bash
curl <PAIR_BASE_URL>/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "<MODEL_NAME>",
"messages": [
{
"role": "user",
"content": "Tell me a short story about a dog who learns to skateboard."
}
]
}'
```

## Ollama-style request

Use this request only with an Ollama endpoint. The `-N` option shows the
response as it streams.

```bash
curl -N <PAIR_BASE_URL>/api/chat \
-H "Content-Type: application/json" \
-d '{
"model": "<MODEL_NAME>",
"messages": [
{
"role": "user",
"content": "Tell me a short story about a dog who learns to skateboard."
}
]
}'
```

Open **Overview**, select the **Jobs** filter, and read **Ran on** or
**Running on** on the job card. A response and a job card show that PAIR routed
the request.

# Step 7. Connect an application

Set the application's base URL to the endpoint from step 5. Select a model
that you added in step 4.

PAIR accepts requests only from the system where it is running. The proxy uses
plaintext HTTP on loopback. A network request to an address such as
`http://some-node:11434` returns `403`.

Install PAIR on the system where you use the application. Join that system to
the cluster, then use its local endpoint. The system does not need a GPU or an
engine when another cluster system can serve the request.

PAIR does not provide a network-reachable inference endpoint. Configuring an
engine to listen on the network is outside PAIR and creates security exposure
that you must manage separately.

## Port reference

PAIR's proxy uses the port that an engine normally uses. PAIR moves the engine
to the next available port.

| Service | Default port |
| --- | --- |
| Ollama-compatible proxy | `11434` |
| Ollama engine behind PAIR | `11435` and upward |
| LM Studio / OpenAI-compatible proxy | `1234` |
| LM Studio engine behind PAIR | `1235` and upward |

If `OLLAMA_HOST` names a different local loopback address, PAIR also serves
that address when the port is free. PAIR does not use a remote or HTTPS
`OLLAMA_HOST` value.

PAIR uses these ports to communicate between cluster systems:

| Port | Purpose |
| --- | --- |
| `5353/udp` | Local-network discovery through mDNS |
| `14318` | Node hardware and model inventory |
| `14319` | Service-error synchronization |
| `14320` | Workload propagation |
| `14321` | Pairing and cluster membership |
| `14322` | Model list served to cluster peers |
| `14323` | Cluster-scoped remote engine control |

The Windows installer adds the firewall rules. If a Linux firewall is
restrictive, allow these ports between trusted cluster systems.

# Next steps

## Change a port

1. Open **Overview** and expand **Engine settings** on the local system's card.
2. Expand **Ports** for the engine.
3. Edit **Proxy**, **Server**, or both, then select **Apply ports**.

PAIR applies the change as one operation and restores the new values when it
next starts. You can change ports only on the local system. Remote system cards
show them as read-only. If you change a proxy port, update the application's
base URL. **Endpoints** always shows the current URL.

If another application uses a port that PAIR does not manage, choose a
different port in PAIR or stop the other application. Then restart the service
from **Settings → Service**.

## Use an engine's command line

PAIR-installed engines are normal installations, but their binaries are not in
`PATH` and their server ports differ from the usual defaults.

Ollama locations:

| Platform | Path |
| --- | --- |
| Windows | `%LOCALAPPDATA%\Nvidia Corporation\Personal AI Router\engine-bin\ollama\ollama.exe` |
| Linux | `~/.config/Nvidia Corporation/Personal AI Router/engine-bin/ollama/bin/ollama` |
| macOS | `~/Library/Application Support/Nvidia Corporation/Personal AI Router/engine-bin/ollama/Ollama.app/Contents/Resources/ollama` |

Linux example:

```bash
ENGINE="$HOME/.config/Nvidia Corporation/Personal AI Router/engine-bin/ollama"
LD_LIBRARY_PATH="$ENGINE/lib/ollama" OLLAMA_HOST=127.0.0.1:11435 "$ENGINE/bin/ollama" list
```

Windows PowerShell example:

```powershell
$ollama = "$env:LOCALAPPDATA\Nvidia Corporation\Personal AI Router\engine-bin\ollama\ollama.exe"
$env:OLLAMA_HOST = "127.0.0.1:11435"
& $ollama list
```

LM Studio installs to its standard location:

```bash
~/.lmstudio/bin/lms status
```

On Windows, the executable is `%USERPROFILE%\.lmstudio\bin\lms.exe`.

Set `OLLAMA_HOST` to the engine's **Server** value when you want to inspect the
local engine. Otherwise, the CLI uses proxy port `11434` and returns the
cluster-wide view. The proxy shows what the cluster can serve. The server port
shows what is on that system.