Large Language Model Text Generation Inference
Go to file
Nicolas Patry 88702d8763
Fixing CI. (#1748)
# What does this PR do?

Congratulations! You've made it this far! You're not quite done yet

Once merged, your PR is going to appear in the release notes with the
title you set, so make sure it's a great title that fully reflects the
extent of your awesome contribution.

Then, please replace this with a description of the change and which
issue is fixed (if applicable). Please also include relevant motivation
and context. List any dependencies (if any) that are required for this

Once you're done, someone will review your PR shortly (see the section
"Who can review?" below to tag some potential reviewers). They may
suggest changes to make the code even better. If no one reviewed your PR
after a week has passed, don't hesitate to post a new comment
@-mentioning the same persons---sometimes notifications get lost.

<!-- Remove if not applicable -->

Fixes # (issue)

## Before submitting
- [ ] This PR fixes a typo or improves the docs (you can dismiss the
other checks if that's the case).
- [ ] Did you read the [contributor
      Pull Request section?
- [ ] Was this discussed/approved via a Github issue or the
[forum]( Please add a link
      to it if that's the case.
- [ ] Did you make sure to update the documentation with your changes?
Here are the
[here are tips on formatting
- [ ] Did you write any new necessary tests?

## Who can review?

Anyone in the community is free to review the PR once the tests have
passed. Feel free to tag
members/contributors who may be interested in your PR.

<!-- Your PR will be replied to more quickly if you can figure out the
right person to tag with @

@OlivierDehaene OR @Narsil

2024-04-15 18:47:36 +02:00
.github Fixing CI. (#1748) 2024-04-15 18:47:36 +02:00
assets Fix AMD documentation (#1307) 2023-12-04 22:09:51 +09:00
benchmark v1.4.5 (#1686) 2024-03-29 19:17:24 +01:00
clients/python feat: update client to 0.7 (#1667) 2024-03-22 17:10:56 +01:00
docs v2.0.0 (#1736) 2024-04-12 18:38:34 +02:00
integration-tests v2.0.0 (#1736) 2024-04-12 18:38:34 +02:00
launcher Improve the defaults for the launcher (#1727) 2024-04-12 14:20:31 +02:00
load_tests chore: add pre-commit (#1569) 2024-02-16 11:58:58 +01:00
proto feat: starcoder2 (#1605) 2024-02-28 12:07:08 +01:00
router Improve the defaults for the launcher (#1727) 2024-04-12 14:20:31 +02:00
server v2.0.0 (#1736) 2024-04-12 18:38:34 +02:00
.dockerignore chore: add `flash-attention` to docker ignore (#287) 2023-05-05 17:52:09 +02:00
.gitignore chore: add pre-commit (#1569) 2024-02-16 11:58:58 +01:00
.pre-commit-config.yaml chore: add pre-commit (#1569) 2024-02-16 11:58:58 +01:00
Cargo.lock v2.0.0 (#1736) 2024-04-12 18:38:34 +02:00
Cargo.toml v2.0.0 (#1736) 2024-04-12 18:38:34 +02:00
Dockerfile Dev/mask ldconfig output v2 (#1716) 2024-04-11 19:31:48 +02:00
Dockerfile_amd v1.4.1 (#1568) 2024-02-16 17:50:57 +01:00
LICENSE Revert license to Apache 2.0 (#1714) 2024-04-08 15:06:16 +02:00
Makefile docs(README): update readme 2023-07-25 19:45:25 +02:00 v2.0.0 (#1736) 2024-04-12 18:38:34 +02:00
rust-toolchain.toml chore: add pre-commit (#1569) 2024-02-16 11:58:58 +01:00 feat(sagemaker): add trust remote code to entrypoint (#394) 2023-06-02 09:51:06 +02:00 Dev/mask ldconfig output v2 (#1716) 2024-04-11 19:31:48 +02:00 chore: formatting 2023-12-11 14:49:52 +01:00

Making TGI deployment optimal

Text Generation Inference

GitHub Repo stars Swagger API documentation

A Rust, Python and gRPC server for text generation inference. Used in production at HuggingFace to power Hugging Chat, the Inference API and Inference Endpoint.

Table of contents

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 :
  • 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

Get Started


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

volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run

docker run --gpus all --shm-size 1g -p 8080:80 -v $volume:/data --model-id $model

And then you can make requests like

curl \
    -X POST \
    -d '{"inputs":"What is Deep Learning?","parameters":{"max_new_tokens":20}}' \
    -H 'Content-Type: application/json'

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 --gpus all 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 docker run --device /dev/kfd --device /dev/dri --shm-size 1g -p 8080:80 -v $volume:/data --model-id $model 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 text-generation-inference REST API using the /docs route. The Swagger UI is also available at:

Using a private or gated model

You have the option to utilize the HUGGING_FACE_HUB_TOKEN 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
  2. Copy your cli READ token
  3. Export HUGGING_FACE_HUB_TOKEN=<your cli READ token>

or with Docker:

volume=$PWD/data # share a volume with the Docker container to avoid downloading weights every run
token=<your cli READ token>

docker run --gpus all --shm-size 1g -e HUGGING_FACE_HUB_TOKEN=$token -p 8080:80 -v $volume:/data --model-id $model

A note on Shared Memory (shm)

NCCL 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 NCCL 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 --shm-size 1g on the above command.

If you are running text-generation-inference inside Kubernetes. You can also add Shared Memory to the container by creating a volume with:

- name: shm
   medium: Memory
   sizeLimit: 1Gi

and mounting it to /dev/shm.

Finally, you can also disable SHM sharing by using the NCCL_SHM_DISABLE=1 environment variable. However, note that this will impact performance.

Distributed Tracing

text-generation-inference 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.


TGI architecture

Local install

You can also opt to install text-generation-inference locally.

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

curl --proto '=https' --tlsv1.2 -sSf | sh

conda create -n text-generation-inference python=3.11
conda activate text-generation-inference

You may also need to install Protoc.

On Linux:
sudo unzip -o $PROTOC_ZIP -d /usr/local bin/protoc
sudo unzip -o $PROTOC_ZIP -d /usr/local 'include/*'

On MacOS, using Homebrew:

brew install protobuf

Then run:

BUILD_EXTENSIONS=True make install # Install repository and HF/transformer fork with CUDA kernels
text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2

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

sudo apt-get install libssl-dev gcc -y

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:

AutoModelForCausalLM.from_pretrained(<model>, device_map="auto")


AutoModelForSeq2SeqLM.from_pretrained(<model>, device_map="auto")

Run locally


text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2


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

text-generation-launcher --model-id mistralai/Mistral-7B-Instruct-v0.2 --quantize

4bit quantization is available using the NF4 and FP4 data types from bitsandbytes. It can be enabled by providing --quantize bitsandbytes-nf4 or --quantize bitsandbytes-fp4 as a command line argument to text-generation-launcher.


make server-dev
make router-dev


# python
make python-server-tests
make python-client-tests
# or both server and client tests
make python-tests
# rust cargo tests
make rust-tests
# integration tests
make integration-tests