Table of contents

• Get Started
  • API Documentation
  • Using a private or gated model
  • A note on Shared Memory
  • Distributed Tracing
  • Local Install
  • CUDA Kernels
• Optimized architectures
• Run Mistral
  • Run
  • Quantization
• Develop
• Testing

Text Generation Inference (TGI) is a toolkit for deploying and serving Large Language Models (LLMs). TGI enables high-performance text generation for the most popular open-source LLMs, including Llama, Falcon, StarCoder, BLOOM, GPT-NeoX, and more. TGI implements many features, such as:

• Simple launcher to serve most popular LLMs
• Production ready (distributed tracing with Open Telemetry, Prometheus metrics)
• Tensor Parallelism for faster inference on multiple GPUs
• Token streaming using Server-Sent Events (SSE)
• Continuous batching of incoming requests for increased total throughput
• Optimized transformers code for inference using Flash Attention and Paged Attention on the most popular architectures
• Quantization with :
  • bitsandbytes
  • GPT-Q
  • EETQ
  • AWQ
• Safetensors weight loading
• Watermarking with A Watermark for Large Language Models
• Logits warper (temperature scaling, top-p, top-k, repetition penalty, more details see transformers.LogitsProcessor)
• Stop sequences
• Log probabilities
• Speculation ~2x latency
• Guidance/JSON. Specify output format to speed up inference and make sure the output is valid according to some specs..
• Custom Prompt Generation: Easily generate text by providing custom prompts to guide the model's output
• Fine-tuning Support: Utilize fine-tuned models for specific tasks to achieve higher accuracy and performance

Hardware support

• Nvidia
• AMD (-rocm)
• Inferentia
• Intel GPU
• Gaudi

Get Started

Docker

For a detailed starting guide, please see the Quick Tour. The easiest way of getting started is using the official Docker container:

And then you can make requests like

Note: To use NVIDIA GPUs, you need to install the NVIDIA Container Toolkit. We also recommend using NVIDIA drivers with CUDA version 12.2 or higher. For running the Docker container on a machine with no GPUs or CUDA support, it is enough to remove the

flag and add

--disable-custom-kernels

, please note CPU is not the intended platform for this project, so performance might be subpar.

Note: TGI supports AMD Instinct MI210 and MI250 GPUs. Details can be found in the Supported Hardware documentation. To use AMD GPUs, please use

instead of the command above.

To see all options to serve your models (in the code or in the cli):

text-generation-launcher --help

API documentation

You can consult the OpenAPI documentation of the

REST API using the

/docs

route. The Swagger UI is also available at: https://huggingface.github.io/text-generation-inference.

Using a private or gated model

You have the option to utilize the

environment variable for configuring the token employed by

text-generation-inference

. This allows you to gain access to protected resources.

For example, if you want to serve the gated Llama V2 model variants:

1. Go to https://huggingface.co/settings/tokens
2. Copy your cli READ token
3. Export
   HUGGING_FACE_HUB_TOKEN=<your cli READ token>

or with Docker:

A note on Shared Memory (shm)

is a communication framework used by

PyTorch

to do distributed training/inference.

text-generation-inference

make use of

NCCL

to enable Tensor Parallelism to dramatically speed up inference for large language models.

In order to share data between the different devices of a

group,

NCCL

might fall back to using the host memory if peer-to-peer using NVLink or PCI is not possible.

To allow the container to use 1G of Shared Memory and support SHM sharing, we add

on the above command.

If you are running

inside

Kubernetes

. You can also add Shared Memory to the container by creating a volume with:

and mounting it to

.

Finally, you can also disable SHM sharing by using the

environment variable. However, note that this will impact performance.

Distributed Tracing

is instrumented with distributed tracing using OpenTelemetry. You can use this feature by setting the address to an OTLP collector with the

--otlp-endpoint

argument.

Architecture

Local install

You can also opt to install

locally.

First install Rust and create a Python virtual environment with at least Python 3.9, e.g. using

:

You may also need to install Protoc.

On Linux:

On MacOS, using Homebrew:

Then run:

Note: on some machines, you may also need the OpenSSL libraries and gcc. On Linux machines, run:

Optimized architectures

TGI works out of the box to serve optimized models for all modern models. They can be found in this list.

Other architectures are supported on a best-effort basis using:

or

Run locally

Run

Quantization

You can also quantize the weights with bitsandbytes to reduce the VRAM requirement:

4bit quantization is available using the NF4 and FP4 data types from bitsandbytes. It can be enabled by providing

or

--quantize bitsandbytes-fp4

as a command line argument to

text-generation-launcher

.

Develop

Testing