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

# Deploy a checkpoint

> Deploy a trained model or LoRA adapter from an inference checkpoint to dedicated model inference.

To serve a trained model, deploy one of its [inference checkpoints](https://docs.together.ai/docs/post-training/checkpoints.md#inference-checkpoints) to [dedicated model inference](https://docs.together.ai/docs/dedicated-endpoints/overview.md).

A low-rank adapter (LoRA) can be [merged into its base model](#deploy-a-lora-adapter-in-merged-mode) when the deployment starts, so it serves at the base model's speed and cost. It can also be served in [multi-LoRA mode](#serve-the-adapter-on-a-multi-lora-deployment) on an existing deployment for quicker experiments.

For production traffic, deploy the model on its own deployment rather than attaching it to a multi-LoRA deployment. Depending on the base model, you may be able to optimize performance by first [preparing the adapter for FP4 inference](#deploy-lora-adapters-for-fp4-inference).

## Find your model's ID

An inference checkpoint registers its weights in your project's model registry, so you deploy it by its registry ID. Read the ID from the checkpoint's `registration`:

```python theme={null}
from together import Together

client = Together()
session = client.post_training.sessions.retrieve("<session_id>")
registration = session.inference_checkpoints[-1].registration
if registration is None:
    print("Not registered. Download the checkpoint instead.")
elif registration.model:
    print("Merged model:", registration.model.id)
elif registration.adapter:
    print("Adapter:", registration.adapter.id)
    print("Revision:", registration.adapter.revision_id)
```

What you deploy depends on what the checkpoint's `registration` holds:

* **`registration.adapter`:** A LoRA session registers only the adapter. [Deploy the adapter](#deploy-a-lora-adapter-in-merged-mode) on its own deployment, or [attach it to a multi-LoRA deployment](#serve-the-adapter-on-a-multi-lora-deployment).
* **`registration.model`:** A full-weight session, or a LoRA session on custom base weights, registers a merged model. [Deploy its ID](#deploy-a-merged-model) directly.
* **No `registration`:** The checkpoint wasn't uploaded to the model registry, so it can't be deployed. Checkpoints on models marked **Not registered** in [Supported models](https://docs.together.ai/docs/post-training/supported-models.md#checkpoints-and-deployment) aren't uploaded. [Download the weights](https://docs.together.ai/docs/post-training/checkpoints.md#download-the-weights) instead.

To find the IDs from the terminal, run `tg training ls-checkpoints --type inference --session <session_id>`. The **Registry artifact** column holds each inference checkpoint's registry ID and revision ID as `<ID>@<REVISION_ID>`. `tg training get <checkpoint_id>` prints the same IDs for one checkpoint. You can also [look up a checkpoint's IDs without the session](https://docs.together.ai/docs/post-training/checkpoints.md#find-a-checkpoint).

## Deploy a LoRA adapter in merged mode

To serve a LoRA adapter for production traffic, deploy it on its own deployment with `--merge`. Each replica merges the adapter into its base model's weights when it starts, then serves the merged model at the base model's speed and cost. There's no merge job or upload.

Adapters trained on [models served only in FP4](https://docs.together.ai/docs/post-training/supported-models.md#checkpoints-and-deployment) can't deploy with `--merge`. [Prepare them for FP4 inference](#deploy-lora-adapters-for-fp4-inference) instead.

Run `tg endpoints deploy` with the adapter's ID:

```bash theme={null}
tg endpoints deploy "<ADAPTER_ID>" \
  --endpoint my-trained-model \
  --merge \
  --config "<CONFIG_ID>" \
  --project "<PROJECT_ID>"
```

| Parameter | Description |
| - | - |
| `<ADAPTER_ID>` | The adapter's registry ID, `registration.adapter.id`. |
| `--endpoint` | A name for the new endpoint. |
| `--merge` | Serves the adapter merged into its base model. A LoRA adapter needs `--merge`, or `--attach-adapter` to [attach it to a multi-LoRA deployment](#serve-the-adapter-on-a-multi-lora-deployment). |
| `--config` | [A B200 profile](#choose-a-config) of the serving base model whose `adapter_mode` is `disabled`. |
| `--project` | Your project ID, from `tg whoami`. Pass it, or set `TOGETHER_PROJECT_ID`, even for your default project. Without either, the CLI resolves a private model ID to its base model and deploys that instead. |

Merging adds to each replica's startup time, including replicas that autoscaling adds later. A new deployment can take 20 minutes or more to become ready.

You can also [deploy the adapter with the SDK](https://docs.together.ai/docs/dedicated-endpoints/adapter.md#deploy-the-adapter).

### Choose a config

To find a profile for `--config`, pass the adapter ID to `tg models configs`, which lists the [deployment profiles](https://docs.together.ai/docs/dedicated-endpoints/configs.md) of the adapter's serving base model:

```bash theme={null}
tg models configs "<ADAPTER_ID>"
```

Pick a profile whose `accelerator_type` is `nvidia-b200-180gb` and whose `adapter_mode` is `disabled`, then pass its **Config ID** to `--config`. The profile's `accelerator_count` sets the number of GPUs each replica uses. If no B200 profile is listed, contact your account team for B200 serving support.

## Deploy LoRA adapters for FP4 inference

To serve an adapter on its own deployment when it was trained on a [model served only in FP4](https://docs.together.ai/docs/post-training/supported-models.md#checkpoints-and-deployment), first run an FP4 preparation job. The job merges the adapter into the base model's weights, then calibrates and quantizes the merged model to FP4. A base model that already ships in the format it serves in skips calibration and quantization. The job registers the result as a private model in your project.

Estimate the job, then start it:

```bash theme={null}
tg training fp4 estimate "<ADAPTER_ID>"
tg training fp4 create "<ADAPTER_ID>" --watch
```

`estimate` prints the job's price and running time without creating anything. The running time depends on the base model and excludes any wait for GPU capacity. `create --watch` starts the paid job and prints the prepared model's ID when it completes. Then [deploy the prepared model](#deploy-a-merged-model) by that ID.

For custom calibration data, job monitoring, cancellation, and the SDK, see [Prepare for FP4 inference](https://docs.together.ai/docs/post-training/prepare-for-fp4-inference.md).

## Deploy a merged model

Deploy a merged model, such as a full-weight checkpoint or an FP4-prepared model, with `tg endpoints deploy`:

```bash theme={null}
tg endpoints deploy "<MODEL_ID>" \
  --endpoint my-trained-model \
  --config "<CONFIG_ID>" \
  --project "<PROJECT_ID>"
```

| Parameter | Description |
| - | - |
| `<MODEL_ID>` | `registration.model.id` for a full-weight session or a LoRA session on custom base weights. For an uploaded or [FP4-prepared](#deploy-lora-adapters-for-fp4-inference) model, that model's ID. |
| `--endpoint` | A name for the new endpoint. |
| `--config` | A profile of the model whose `adapter_mode` is `disabled`. List the profiles with `tg models configs "<MODEL_ID>"`. For a trained checkpoint, pick one whose `accelerator_type` is `nvidia-b200-180gb`. For an FP4-prepared model, use its [FP4 profile](https://docs.together.ai/docs/post-training/prepare-for-fp4-inference.md#deploy-the-prepared-model). Required when the model has more than one profile. |
| `--project` | Your project ID, from `tg whoami`. Pass it, or set `TOGETHER_PROJECT_ID`, even for your default project. Without either, the CLI resolves a private model ID to its base model and deploys that instead. |

`deploy` creates the endpoint and routes all traffic to the new deployment. The [dedicated model inference quickstart](https://docs.together.ai/docs/dedicated-endpoints/quickstart.md) walks through the rest of the flow, from choosing a config to calling the endpoint. Scale the deployment to zero or delete the endpoint when you're done.

## Serve the adapter on a multi-LoRA deployment

Instead of deploying a LoRA adapter on its own, you can [attach it to a running deployment](https://docs.together.ai/docs/post-training/multi-lora-deployment.md) of its base model, if the base model [supports multi-LoRA deployment](https://docs.together.ai/docs/post-training/multi-lora-deployment.md#supported-models). Attaching takes about a minute, with no extra job or upload.

Each request does extra work for the adapter, and a deployment holds a limited number of adapters. Use it to [compare candidates](https://docs.together.ai/docs/post-training/evaluate.md#compare-candidates) and to serve adapters with low or mixed traffic. For production traffic, [deploy the adapter](#deploy-a-lora-adapter-in-merged-mode) on its own deployment.

## Next steps

> [card] [Multi-LoRA deployment](https://docs.together.ai/docs/post-training/multi-lora-deployment.md)
>
> Attach candidate adapters to one deployment and compare them per request.

> [card] [Prepare for FP4 inference](https://docs.together.ai/docs/post-training/prepare-for-fp4-inference.md)
>
> Merge an adapter into its base model and quantize the result to FP4.

> [card] [Dedicated model inference quickstart](https://docs.together.ai/docs/dedicated-endpoints/quickstart.md)
>
> Follow the CLI and SDK deploy flow, step by step.

> [card] [Manage checkpoints](https://docs.together.ai/docs/post-training/checkpoints.md)
>
> Save the inference checkpoints you deploy.


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