Pular para o conteúdo principal
PromptQuorumFeito para humanos. Estruturado para IA.
Início/LLMs locais avançados
Overview & Reference

Review do LMDeploy: serviço de LLM de alto throughput e quantização

·10 min de leituraPor Hans Kuepper · Fundador do PromptQuorum · Mecanismo de descoberta de IA de pesos abertos e código aberto

O LMDeploy é um toolkit e biblioteca Python gratuitos e de código aberto (Apache 2.0), de linha de comando, para comprimir, quantizar e servir grandes modelos de linguagem em GPUs NVIDIA, instalado via pip install lmdeploy. Desenvolvido pelas equipes MMRazor e MMDeploy dentro do ecossistema InternLM/OpenMMLab, ele traz dois mecanismos de inferência — TurboMind (um mecanismo C++/CUDA otimizado para throughput) e um mecanismo PyTorch em Python puro — além de quantização AWQ e de cache KV, um servidor de API compatível com a OpenAI, e suporte a bem mais de 50 famílias de LLMs e VLMs de pesos abertos.

Principais conclusões

  • O LMDeploy (github.com/InternLM/lmdeploy) é um toolkit de inferência e quantização gratuito, de código aberto e instalável via pip — uma CLI/biblioteca, não um app gráfico
  • Desenvolvido pelas equipes MMRazor e MMDeploy dentro do ecossistema InternLM/OpenMMLab (Shanghai AI Laboratory); repositório criado em 15 de junho de 2023
  • Licenciado sob Apache 2.0, confirmado pelo arquivo LICENSE do repositório no GitHub
  • Traz dois mecanismos de inferência: TurboMind (C++/CUDA, otimizado para throughput) e um mecanismo PyTorch em Python puro
  • Suporta quantização AWQ de 4 bits somente dos pesos e quantização int8/int4 do cache KV
  • Mais de 8.000 estrelas no GitHub e 750 forks no momento desta review; última release marcada v0.17.0, publicada em 1º de setembro de 2026

📍 Em uma frase

O LMDeploy é um toolkit gratuito e de código aberto (Apache 2.0) para comprimir, quantizar e servir LLMs em GPUs NVIDIA, desenvolvido pelas equipes MMRazor e MMDeploy no ecossistema InternLM/OpenMMLab, instalado via pip install lmdeploy, com mais de 8.000 estrelas no GitHub.

💬 Em termos simples

O LMDeploy é uma ferramenta de linha de comando e uma biblioteca Python que você instala com pip, e que pega um LLM que você já tem (do HuggingFace, por exemplo) e o executa rapidamente na sua própria GPU, opcionalmente reduzindo-o antes com quantização de 4 bits para usar menos memória. Não é um app de chat com uma janela para clicar — é uma infraestrutura que você executa em um servidor, e outras aplicações conversam com ela por meio de uma API compatível com a OpenAI.

📌Nota: Esta review se baseia no próprio repositório GitHub, README, documentação e página do PyPI do LMDeploy. Os números de throughput e velocidade de quantização (como "1,8x mais rápido que o vLLM") são benchmarks autopublicados pelo LMDeploy, não medições independentes da PromptQuorum — verifique os benchmarks publicados atuais antes de basear uma decisão de compra ou arquitetura em um número específico.

Ler em:
🇺🇸en🇩🇪de🇫🇷fr🇯🇵ja🇨🇳zh🇪🇸es🇧🇷pt🇸🇦ar🇰🇷ko

O LMDeploy (github.com/InternLM/lmdeploy) é um toolkit gratuito e de código aberto (Apache 2.0) para comprimir, quantizar e servir grandes modelos de linguagem, desenvolvido pelas equipes MMRazor e MMDeploy dentro do ecossistema InternLM/OpenMMLab. Ele é instalado via pip install lmdeploy e traz dois mecanismos de inferência — TurboMind e um mecanismo PyTorch em Python puro — além de um servidor de API compatível com a OpenAI, com mais de 8.000 estrelas no GitHub. Esta review é o complemento da entrada do LMDeploy no Diretório de Software LLM Local e explica o que ele realmente faz, como instalá-lo e para quem ele é indicado.

O que é o LMDeploy?

O LMDeploy é um toolkit para comprimir, implantar e servir grandes modelos de linguagem, construído para rodar inferência em GPUs NVIDIA com alto throughput. Sua própria descrição no GitHub afirma que ele foi desenvolvido pelas equipes MMRazor e MMDeploy — ambos projetos OpenMMLab, o ecossistema open source de visão computacional e implantação de modelos mantido pelo Shanghai AI Laboratory, a mesma organização por trás da família de modelos InternLM.

  • Tipo de produto: uma ferramenta de linha de comando e uma biblioteca Python — sem interface gráfica; usada a partir de um terminal, um script Python ou um contêiner Docker
  • Desenvolvedor: as equipes MMRazor e MMDeploy, parte do ecossistema InternLM/OpenMMLab sob o Shanghai AI Laboratory
  • Repositório: InternLM/lmdeploy no GitHub, criado em 15 de junho de 2023
  • Licença: Apache 2.0, confirmada pelo arquivo LICENSE do repositório
  • Escala: mais de 8.000 estrelas no GitHub, 750 forks e 596 issues abertas no momento desta review
  • Distribuição: publicado no PyPI como o pacote lmdeploy, além de imagens Docker oficiais segundo a documentação do projeto

História do projeto e marcos de versão

O repositório GitHub do LMDeploy foi criado em junho de 2023, e o projeto vem sendo lançado continuamente desde então, expandindo-se de um único mecanismo de inferência TurboMind para um toolkit de dois mecanismos com quantização, suporte multimodal (VLM) e serviço distribuído.

  1. 1
    2023/08 — Quantização AWQ de 4 bits e lançamento no HuggingFace Hub
    Why it matters: Adicionou quantização de pesos de 4 bits baseada em AWQ e publicou modelos de 4 bits prontos para uso no HuggingFace, segundo o changelog oficial.
  2. 2
    2024/01 — Mecanismo de inferência PyTorch introduzido
    Why it matters: Adicionou um segundo mecanismo de inferência, em Python puro, ao lado do TurboMind, reduzindo a barreira para que desenvolvedores estendam ou depurem o stack de serviço.
  3. 3
    2024/06–2024/07 — Suporte a VLM e chamada de funções
    Why it matters: Adicionou pipelines de inferência multimodal (modelos de visão e linguagem) e seu serviço, além de chamada de ferramentas/funções para Llama 3.1 e InternLM2.5.
  4. 4
    2025/01 — Suporte a DeepSeek-V3 e R1
    Why it matters: Adicionou suporte quase imediato às famílias de modelos DeepSeek-V3 e R1, uma linhagem de modelos de raciocínio amplamente usada.
  5. 5
    2025/06 — Desagregação PD do DeepSeek
    Why it matters: Integrou a desagregação de prefill/decode para modelos DeepSeek via DLSlime e Mooncake, uma técnica de produção para escalar o serviço de grandes modelos MoE entre várias máquinas.
  6. 6
    2025/09 — Suporte a MXFP4 em GPUs NVIDIA (V100 e mais recentes)
    Why it matters: Adicionou inferência quantizada MXFP4, que segundo o próprio changelog do LMDeploy alcança 1,5x o throughput do vLLM em GPUs H800 para modelos gpt-oss da OpenAI.
  7. 7
    2026/02 — Suporte ao Qwen3.5 e integração com llm-compressor
    Why it matters: Adicionou suporte à coleção de modelos Qwen3.5 e integrou o vllm-project/llm-compressor para quantização simétrica/assimétrica de 4 bits.
  8. 8
    v0.17.0 — 1º de setembro de 2026
    Why it matters: A última release marcada no GitHub no momento desta review — consulte diretamente a [página de releases do GitHub](https://github.com/InternLM/lmdeploy/releases) para qualquer coisa lançada após a data de publicação desta review.

O que dá para fazer com o LMDeploy?

O conjunto de recursos do LMDeploy se concentra em três tarefas: reduzir um modelo por meio de quantização, executá-lo com eficiência e expô-lo como um serviço de rede. Veja o que cada parte realmente faz, segundo o próprio README e a documentação do LMDeploy.

  • Dois mecanismos de inferência — TurboMind, um mecanismo C++/CUDA que o LMDeploy posiciona como sua opção de maior throughput, e um mecanismo PyTorch em Python puro, mais fácil de estender e de receber novas arquiteturas de modelos; escolha conforme o modelo com base na própria tabela de modelos suportados do LMDeploy
  • Batching contínuo e atenção paginada — batching persistente (contínuo), cache KV em blocos/paginado e split-and-fuse dinâmico, a mesma classe de técnicas usada por outros mecanismos de inferência em produção para aumentar a utilização da GPU sob requisições concorrentes
  • Quantização — quantização AWQ de 4 bits somente dos pesos, além de quantização int8/int4 do cache KV que pode ser combinada com AWQ ao mesmo tempo, e (desde 2026/02) quantização simétrica/assimétrica de 4 bits via integração com o llm-compressor
  • Amplo suporte a modelos — dezenas de famílias de LLM, incluindo Llama, Llama2/3/3.1/3.2, InternLM2/3, Qwen1.5/2/2.5/3, Qwen3-MoE, Qwen3-Next, DeepSeek-MoE/V2/V3/R1, Mistral, Mixtral, ChatGLM2, GLM-4, Yi, Baichuan2 e Code Llama, segundo a documentação de modelos suportados do LMDeploy
  • Suporte a modelos de visão e linguagem (VLM) — pipelines de inferência offline e serviço via API para modelos multimodais como InternVL, LLaVA, MiniGemini e CogVLM2
  • Servidor de API compatível com a OpenAI — lmdeploy serve api_server inicia um servidor que reproduz o formato de requisição/resposta de chat completions da OpenAI, documentado separadamente para LLMs e VLMs
  • Pipeline de inferência em lote offline — uma API Python lmdeploy.pipeline() para executar inferência diretamente dentro de um script, sem precisar subir um servidor
  • Servidor proxy multimodelo e multimáquina — um serviço de distribuição de requisições para executar vários modelos em várias máquinas e GPUs atrás de um único ponto de entrada
  • Suporte a hardware além das GPUs NVIDIA CUDA — suporte a NPUs Huawei Ascend via o mecanismo PyTorch, e suporte ao Windows (grau de paralelismo tensorial 1) via TurboMind

Exemplos de uso: três formas de usar o LMDeploy

Estes são fluxos de trabalho concretos construídos a partir dos comandos documentados do LMDeploy acima — não casos de uso hipotéticos.

Rodar inferência em lote offline a partir de um script Python

Depois do pip install lmdeploy, rode um modelo diretamente dentro do Python com a API de pipeline: `import lmdeploy; pipe = lmdeploy.pipeline("internlm/internlm3-8b-instruct"); print(pipe(["Hi, please introduce yourself"]))`. Por padrão, o LMDeploy baixa o modelo do HuggingFace (ou do ModelScope/openMind Hub, se você definir a variável de ambiente correspondente) e o executa por meio do mecanismo adequado para aquele modelo.

Iniciar um servidor de API compatível com a OpenAI para outros apps usarem

Execute lmdeploy serve api_server <model-path-or-hf-id> para iniciar um servidor local que fala o formato de chat completions da OpenAI. Aponte qualquer biblioteca cliente OpenAI ou aplicativo para esse endereço em vez de api.openai.com, permitindo reutilizar código de integração OpenAI já existente contra um modelo auto-hospedado.

Quantizar um modelo em 4 bits AWQ antes de servi-lo

Use o fluxo de quantização AWQ do LMDeploy (documentado em docs/en/quantization/w4a16.md) para produzir uma versão de 4 bits somente dos pesos de um modelo suportado e, em seguida, sirva esse modelo quantizado via TurboMind — os próprios números do LMDeploy colocam a inferência de 4 bits em até 2,4x o throughput do FP16 no mesmo hardware, permitindo encaixar um modelo maior ou atender mais requisições concorrentes na mesma GPU.

Preços e licenciamento

O LMDeploy é gratuito e de código aberto, sem nenhum plano pago. O arquivo LICENSE do repositório GitHub aplica a Apache License, versão 2.0, sem modificações, e não existe nenhuma página de preços na documentação do projeto.

  • Sem assinatura, sem plano pago, sem limites de uso impostos pelo próprio LMDeploy
  • Não é necessário criar conta nem se cadastrar para instalar ou usar o toolkit
  • Seu custo real é o do hardware de GPU ou da instância de GPU na nuvem em que você roda o LMDeploy — o LMDeploy em si não adiciona nenhuma taxa
  • Apache 2.0 é uma licença permissiva: sem obrigação de copyleft de liberar seu próprio código, e o uso comercial/em produção é explicitamente permitido

LMDeploy vs. vLLM

O LMDeploy e o vLLM estão entre os mecanismos de inferência de LLM de código aberto mais usados, e o próprio marketing do LMDeploy se compara explicitamente ao vLLM. Ambos são gratuitos, próximos da Apache 2.0 (o vLLM também é Apache 2.0), instaláveis via Python e suportam um servidor de API compatível com a OpenAI — as diferenças estão principalmente na arquitetura do mecanismo, no tamanho do ecossistema e no foco em certas famílias de modelos.

Mecanismos principais

LMDeploy:
TurboMind (C++/CUDA) mais um mecanismo PyTorch
vLLM:
Um único mecanismo baseado em PagedAttention

Alegação de throughput

LMDeploy:
Até 1,8x o vLLM (autodeclarado)
vLLM:
Amplamente citado como referência padrão do setor

Quantização

LMDeploy:
AWQ, cache KV int8/int4, MXFP4
vLLM:
AWQ, GPTQ, FP8 e outros formatos

Tamanho do ecossistema

LMDeploy:
~8.000 estrelas no GitHub
vLLM:
Uma comunidade maior e uma superfície de integração de terceiros mais ampla

Força por família de modelos

LMDeploy:
Suporte de primeira classe forte para InternLM e Qwen
vLLM:
Muito amplo, frequentemente o primeiro a suportar novos lançamentos de muitos laboratórios

Desenvolvedor

LMDeploy:
Equipes MMRazor/MMDeploy (Shanghai AI Laboratory)
vLLM:
Originado na UC Berkeley, hoje um amplo projeto open source com várias empresas

As alegações de throughput do LMDeploy são números próprios autopublicados, não um benchmark independente da PromptQuorum — faça sua própria comparação com seu modelo, GPU e padrão de tráfego alvo antes de escolher um deles para produção. Veja o explicador do vLLM para mais detalhes sobre o vLLM em si.

Comparar no diretório

Para quem o LMDeploy é indicado?

O LMDeploy se encaixa em equipes que implantam LLMs na própria infraestrutura de GPU NVIDIA e querem um stack de serviço com suporte a quantização e alto throughput, em vez de um app de chat de desktop.

Use o LMDeploy se você

  • implanta inferência de LLM em hardware de GPU NVIDIA que você controla, em um data center ou instância de GPU na nuvem
  • quer quantização AWQ e de cache KV integradas para encaixar modelos maiores ou mais requisições concorrentes na mesma memória de GPU
  • roda as famílias de modelos InternLM ou Qwen, para as quais o LMDeploy tem suporte de primeira classe particularmente forte
  • quer um servidor de API compatível com a OpenAI que possa colocar atrás de código cliente OpenAI já existente
  • precisa de serviço multimodal (VLM) junto com o serviço de LLM somente texto no mesmo toolkit
  • está confortável trabalhando a partir de um terminal, script Python ou contêiner Docker em vez de um app gráfico

Procure outra opção se você

  • quer um aplicativo de chat de desktop com uma janela e um seletor de modelos — o LMDeploy não tem GUI; veja o Diretório de Software LLM Local para apps de desktop
  • precisa de inferência somente com CPU ou em Apple Silicon — o mecanismo TurboMind do LMDeploy tem como alvo GPUs NVIDIA CUDA; considere llama.cpp ou MLX-LM para esses casos
  • quer o maior ecossistema e as ferramentas de terceiros mais amplas em torno de um mecanismo de inferência — o vLLM tem uma comunidade e superfície de integração maiores
  • precisa de contratos de suporte empresarial ou de um SLA — os canais de suporte do LMDeploy são GitHub Issues, Discord e WeChat, típicos de um projeto open source de laboratório de pesquisa, não de um fornecedor comercial

Concorrentes e alternativas

O LMDeploy fica no segmento de mecanismos de serviço de LLM em produção, ao lado do vLLM, TensorRT-LLM, SGLang e ExLlamaV2 — ferramentas construídas para rodar modelos em escala em hardware de GPU dedicado, diferentes dos apps de desktop voltados ao consumidor.

vLLM

Conhecida por:
O mecanismo de inferência open source mais adotado, PagedAttention, amplo suporte desde o primeiro dia
Link:
vLLM explicado
Artigos sobre vLLM (10)

+92 mais não exibidos

TensorRT-LLM

Conhecida por:
A biblioteca de inferência própria da NVIDIA baseada em compilador, profundamente otimizada para seu hardware
Link:
TensorRT-LLM explicado
Artigos sobre TensorRT-LLM (7)

Também mencionado em:

+1 mais não exibidos

SGLang

Conhecida por:
Um mecanismo de inferência e linguagem de geração estruturada construído em torno do cache RadixAttention
Link:
SGLang explicado
Artigos sobre SGLang (8)

Também mencionado em:

+5 mais não exibidos

ExLlamaV2

Conhecida por:
Um mecanismo focado em quantização, popular para rodar modelos GPTQ/EXL2 em GPUs de consumo
Link:
ExLlamaV2 explicado
Artigos sobre ExLlamaV2 (3)

Também mencionado em:

Esta lista reflete ferramentas comumente comparadas ao LMDeploy no segmento de serviço em produção, não um ranking independente da PromptQuorum — verifique o conjunto de recursos e os requisitos de hardware atuais de cada ferramenta antes de escolher.

Comparar no diretório

Erros comuns ao avaliar o LMDeploy

A maior parte da confusão em torno do LMDeploy vem de tratá-lo como um app de chat de desktop, ou de citar seus números de benchmark autodeclarados como se fossem verificados de forma independente.

Erro 1: esperar uma interface de chat gráfica

O LMDeploy não tem GUI. É um toolkit de linha de comando e uma biblioteca Python usados para rodar servidores de inferência e pipelines em lote — para uma janela de chat, veja em vez disso apps de desktop como Jan ou LM Studio, que costumam usar mecanismos diferentes por baixo.

Erro 2: citar "1,8x mais rápido que o vLLM" como um fato verificado de forma independente

Esse número, e alegações de throughput semelhantes no README do LMDeploy, são benchmarks autopublicados pelo próprio projeto, não uma medição de terceiros ou da PromptQuorum. Rode um benchmark com seu próprio modelo, GPU e padrão de tráfego antes de confiar nele para uma decisão de planejamento de capacidade.

Erro 3: presumir que o LMDeploy roda em qualquer GPU ou apenas em CPU

O mecanismo principal do LMDeploy, o TurboMind, tem como alvo GPUs NVIDIA CUDA. O suporte a NPUs Huawei Ascend existe via o mecanismo PyTorch, mas esta review não encontrou um caminho apenas de CPU ou Apple Silicon — verifique a documentação de modelos e hardware suportados para sua configuração específica.

Erro 4: presumir que todo modelo é suportado igualmente bem

O LMDeploy documenta quais modelos cada mecanismo (TurboMind vs. PyTorch) suporta, e a profundidade do suporte varia conforme a família de modelos — modelos InternLM e Qwen tendem a receber tratamento de primeira classe dada a origem do LMDeploy. Consulte a tabela de modelos suportados para seu modelo específico antes de se comprometer com ele.

Perguntas frequentes

O que é o LMDeploy?

O LMDeploy (github.com/InternLM/lmdeploy) é um toolkit gratuito e de código aberto (Apache 2.0) para comprimir, quantizar e servir grandes modelos de linguagem em GPUs NVIDIA, desenvolvido pelas equipes MMRazor e MMDeploy dentro do ecossistema InternLM/OpenMMLab.

O LMDeploy é gratuito?

Sim. O LMDeploy é licenciado sob Apache 2.0, sem página de preços nem plano pago. Seu custo real é o do hardware de GPU ou da instância na nuvem em que você o roda.

Como instalo o LMDeploy?

Execute pip install lmdeploy em um ambiente Python 3.10–3.13 (recomenda-se um ambiente conda). Desde a v0.13.0, as wheels padrão do PyPI têm como alvo o CUDA 12.8, então isso costuma bastar sem uma instalação de CUDA separada em configurações típicas de GPU NVIDIA.

O LMDeploy tem interface gráfica?

Não. O LMDeploy é um toolkit de linha de comando e uma biblioteca Python. Ele não tem janela de chat — você interage por meio do terminal, um script Python ou seu servidor de API compatível com a OpenAI.

O LMDeploy é mais rápido que o vLLM?

O próprio README do LMDeploy relata throughput de requisições até 1,8x maior que o vLLM, com base em benchmarks próprios autopublicados. Esse não é um número verificado de forma independente — rode seu próprio benchmark com seu modelo e hardware alvo antes de confiar nele.

Que quantização o LMDeploy suporta?

Quantização AWQ de 4 bits somente dos pesos, quantização int8/int4 do cache KV (combinável com AWQ), MXFP4 em GPUs NVIDIA suportadas e, desde 2026/02, quantização simétrica/assimétrica de 4 bits via integração com o vllm-project/llm-compressor.

Que modelos o LMDeploy suporta?

Dezenas de famílias de LLM — incluindo Llama, InternLM2/3, Qwen1.5 até Qwen3, DeepSeek-MoE/V2/V3/R1, Mistral, ChatGLM2, GLM-4 e Code Llama — além de modelos de visão e linguagem como InternVL, LLaVA e CogVLM2. Consulte a própria documentação de modelos suportados do LMDeploy para a lista completa e atualizada.

O LMDeploy suporta GPUs além da NVIDIA?

Seu mecanismo principal, o TurboMind, tem como alvo GPUs NVIDIA CUDA. O mecanismo PyTorch acrescenta suporte a NPUs Huawei Ascend. Esta review não encontrou um caminho de suporte apenas de CPU ou Apple Silicon.

Quem desenvolve o LMDeploy?

As equipes MMRazor e MMDeploy, parte do ecossistema open source InternLM/OpenMMLab mantido pelo Shanghai AI Laboratory.

O LMDeploy tem um servidor de API compatível com a OpenAI?

Sim. Executar lmdeploy serve api_server inicia um servidor local que reproduz o formato de requisição/resposta de chat completions da OpenAI, permitindo que código cliente OpenAI já existente aponte para ele em vez de para um endpoint na nuvem.

Fontes

← Voltar para LLMs locais avançados

MCP