Guia Completo de Implantação de LLM Local: Construindo seu Próprio Fluxo de Trabalho de Agentes para Liberdade de Tokens (Ideal para Iniciantes)

Este artigo tem como objetivo ser o mais fácil de entender possível, permitindo que qualquer jogador iniciante domine facilmente a implantação de modelos locais e construa seu próprio fluxo de trabalho.

Este ano, os modelos de código aberto nacionais têm estado muito ativos. DeepSeek, Qwen, Kimi, GLM, MiniMax... novos modelos surgem um após o outro, abrindo constantemente seus pesos e começando a competir com os modelos fechados dos EUA.

Mas quanto mais modelos existem, mais me preocupo com uma questão específica: esses modelos podem não ficar apenas em páginas da web e APIs, mas ser verdadeiramente instalados em nossas próprias máquinas, conectando-se a arquivos, ferramentas e fluxos de trabalho locais?

Embora o preço unitário dos tokens de API esteja geralmente diminuindo, o custo permanece alto ao encontrar chamadas de alta frequência e textos longos. Somado a questões como privacidade, rede e controle de dados, a implantação local está se tornando a escolha de cada vez mais desenvolvedores e empresas.

Então, desta vez, quero escolher um modelo com um tamanho desafiador e representativo de implantação em máquina única para percorrer o processo completo de implantação local.

O protagonista finalmente selecionado é o Ling-3.0-flash, de código aberto da Ant Bailing — um modelo Mixture of Experts (MoE) com um total de 124B parâmetros. Acontece que tenho um NVIDIA DGX Spark em mãos, que pode executá-lo.

Sem mais delongas, vamos começar o show principal.

01 Glossário de Termos

Antes de começarmos, vamos apresentar alguns termos relacionados a modelos para deixar todos a par ✌🏻

Precisão do Modelo

O mesmo modelo geralmente oferece diferentes versões de precisão ou quantizadas, que afetam diretamente o tamanho do modelo e o limite de execução.

Desta vez, estamos usando a versão oficial Ling INT4, que tem cerca de 71,75 GB.

Denso ou MoE

Observe que 5,1B é apenas o número de parâmetros ativados por inferência; os pesos completos de 124B ainda precisam ser carregados na memória.

Mecanismo de Inferência

O mecanismo de inferência é responsável por carregar pesos, gerenciar contexto e concorrência e fornecer interfaces. É a ferramenta para executar o modelo, não o modelo em si.

Escolhemos o vLLM desta vez porque a adaptação oficial atual suporta os pesos INT4 do Ling-3.0-flash e a decodificação especulativa MTP.

02 Instalação e Implantação do Modelo

Primeiro, vamos apresentar o ambiente de instalação: estou usando um NVIDIA DGX Spark, equipado com um chip GB10 e 121,6 GB de memória unificada, executando Ubuntu 24.04 na arquitetura ARM64. A implantação é o Ling-3.0-flash-INT4, e os testes de taxa de transferência subsequentes usarão o Qwen 3.8-27B local como referência.

O oficial fornece uma versão básica e diferentes versões de precisão como FP8, FP4 e INT4. Você pode escolher de acordo com seu hardware.

Há também um Ling-3.0-tiny de 8B e suas versões FP8, INT4. Usuários com um Mac comum ou uma única 4090 podem priorizar a experimentação das versões de baixa precisão do Tiny.

Passo 1: Baixar o modelo. Usei a versão INT4 oficial desta vez. Entradas para download 👇🏻

• Hugging Face: Ling-3.0-flash-int4
• ModelScope: Ling-3.0-flash-int4

Se o acesso ao Hugging Face for inconveniente, você pode baixar manualmente do ModelScope. Após o download, existem 24 fragmentos safetensors, totalizando cerca de 71,75 GB. Você também precisa deixar espaço para o mecanismo de inferência e o Cache KV durante a execução.

Passo 2: Preparar o ambiente. A arquitetura BailingMoeV3 do Ling-3.0-flash é bastante nova. Tentei usar GGUF com llama.cpp, mas ocorreu um erro com unknown model architecture: 'bailingmoe3'. Então, desta vez, usei o branch vLLM oficialmente adaptado diretamente:

1pip install uv
2uv venv ~/my_ling_env
3source ~/my_ling_env/bin/activate
4
5git clone -b ling_3_0 https://github.com/inclusionAI/vllm-ling-v3.git
6cd vllm-ling-v3
7VLLM_USE_PRECOMPILED=1 uv pip install --editable . --torch-backend=auto

Passo 3: Iniciar o serviço de inferência. Substitua o caminho do modelo pelos pesos INT4 baixados localmente:

1vllm serve /path/to/Ling-3.0-flash-int4 \
2  --served-model-name ling-int4 \
3  --host 127.0.0.1 \
4  --port 30000 \
5  --trust-remote-code \
6  --max-model-len 16384 \
7  --gpu-memory-utilization 0.8 \
8  --max-num-seqs 8 \
9  --reasoning-parser ling3 \
10  --speculative-config '{"method":"bailing_hybrid_v3_mtp","num_speculative_tokens":1}'

⚠️

Substitua os caminhos no comando pelos caminhos reais em sua máquina.

Aqui, o limite de contexto é definido como 16K, a concorrência como 8 e a decodificação especulativa MTP está ativada.

Nota: MTP (Multi-Token Prediction) permite que o modelo tente prever vários tokens de uma só vez. Partes previstas corretamente podem ser adotadas diretamente, reduzindo as rodadas de cálculo para gerar tokens um por um e aumentando a velocidade de saída.

Passo 4: Verificar o serviço. Uma vez iniciado, envie uma solicitação simples:

1curl -s http://127.0.0.1:30000/v1/chat/completions \
2  -H "Content-Type: application/json" \
3  -d '{"model":"ling-int4",
4       "messages":[{"role":"user","content":"Olá, apresente-se em uma frase."}],
5       "stream":true}'

O terminal começa a retornar o conteúdo em streaming, indicando que este modelo de 124B está sendo executado localmente.

03 Testando o Desempenho e a Capacidade do Modelo

1. Taxa de Transferência de Tokens Quando o modelo foi iniciado pela primeira vez, executei uma rodada de testes usando o benchmark integrado do vLLM. Todas as 20 solicitações foram concluídas, com uma taxa de transferência de saída de 84,34 tok/s, taxa de transferência total de tokens de 133,10 tok/s e uma taxa de aceitação MTP de 67,35%.

Log de saída original 👇🏻

1============ Serving Benchmark Result ============
2Successful requests:                     20
3Failed requests:                         0
4Request rate configured (RPS):           2.00
5Benchmark duration (s):                  60.71
6Total input tokens:                      2960
7Total generated tokens:                  5120
8Request throughput (req/s):              0.33
9Output token throughput (tok/s):         84.34
10Peak output token throughput (tok/s):    61.00
11Peak concurrent requests:                20.00
12Total token throughput (tok/s):          133.10
13---------------Time to First Token----------------
14Mean TTFT (ms):                          19692.98
15Median TTFT (ms):                        18877.99
16P99 TTFT (ms):                           40039.02
17-----Time per Output Token (excl. 1st token)------
18Mean TPOT (ms):                          44.61
19Median TPOT (ms):                        44.09
20P99 TPOT (ms):                           49.68
21---------------Inter-token Latency----------------
22Mean ITL (ms):                           74.09
23Median ITL (ms):                         72.39
24P99 ITL (ms):                            280.71
25---------------Speculative Decoding---------------
26Acceptance rate (%):                     67.35
27Acceptance length:                       1.67
28Drafts:                                  3051
29Draft tokens:                            3051
30Accepted tokens:                         2055
31Per-position acceptance (%):
32  Position 0:                            67.35
33==================================================

Posteriormente, realizei testes de concorrência no Ling e no Qwen 3.8-27B local. Com 8 concorrências, a taxa de transferência agregada do Ling foi de 141,38 tok/s, enquanto o Qwen 3.8 foi de 32,61 tok/s, uma diferença de cerca de 4,34 vezes nesta rodada.

🔥🔥🔥Comparação de Teste de Estresse Ling-3.0-Flash Vs Qwen3.8-27B

Ling-3.0-flash

Qwen 3.8 -27B

Alguns podem se perguntar: por que a concorrência única do Ling é de apenas 34,77 tok/s, mas com 8 concorrências se torna 141,38 tok/s? Amigos técnicos também podem perguntar se essa pontuação de concorrência única é lenta em comparação com os dados oficiais.

Aqui, precisamos explicar o método de teste específico e as diferenças de velocidade causadas por diferentes métodos de avaliação:

1. Método de Teste e Link Fim a Fim Real: Este teste usa uma interface local compatível com OpenAI, testando estresse via solicitações HTTP em streaming, não um teste de inferência offline separado da estrutura de serviço. Cada solicitação Ling usa um prompt de texto longo de cerca de 150 tokens, gerando até 512 tokens. O tempo começa a partir da solicitação HTTP do cliente até que a resposta em streaming seja concluída, incluindo chamadas HTTP locais, agendamento de serviço, processamento do Tokenizer, Prefill, decodificação token por token e retorno em streaming.
2. Taxa de Saída de Fluxo Único vs. Taxa de Transferência Agregada da Máquina: Velocidade de fluxo único (experiência real do usuário): Em $c=1$, a taxa de saída fim a fim é de cerca de 35,34 tok/s (testes reais de conversa única em 38+ tok/s), equivalente a mais de 35 caracteres chineses por segundo, o que é extremamente rápido visualmente; Taxa de transferência agregada (saída total sob concorrência): À medida que a concorrência aumenta, o vLLM usa Continuous Batching para combinar várias solicitações em cálculos de GPU, utilizando totalmente a largura de banda de memória unificada do Blackwell. Com 8 concorrências, a taxa de transferência agregada da máquina disparou para 141,38 tok/s.

Quanto à diferença de alguns benchmarks oficiais, o segredo está nos critérios de teste. Precisão do modelo, mecanismo de inferência, comprimento do contexto, contagem de tokens de entrada/saída, escala de concorrência e se é usado inferência offline ou serviços HTTP afetam o resultado final. Somente quando essas condições são basicamente consistentes os números são adequados para comparação direta.

Simplificando: A velocidade varia devido aos métodos de avaliação — se testado em concorrência extremamente alta (como 32/64) ou em um ambiente de computação puro sem protocolos de rede, os números de taxa de transferência total pareceriam mais altos; em nossas chamadas diárias de conversa única ou produção de codificação, a velocidade de fluxo único de 35+ tok/s do Ling e a latência do primeiro token abaixo de 220ms já parecem extremamente suaves e sem atraso.

Em concorrência única, a velocidade média de fluxo único do Ling é de cerca de 35,34 tok/s; com 8 concorrências, a taxa de transferência agregada atinge 141,38 tok/s. A taxa de transferência agregada do Qwen3.8 com 8 concorrências é de 32,61 tok/s. Nesta rodada, a vantagem do Ling se reflete principalmente na velocidade de saída e na taxa de transferência simultânea, com respostas visivelmente mais rápidas no uso real.

2. Capacidades Reais

Os benchmarks refletem apenas parte do desempenho; a usabilidade real depende do desempenho do modelo em problemas específicos. Escolhi três direções para testes simples.

(1) Raciocínio Lógico

Preparei uma variação do problema da galinha e do coelho, um problema clássico de lavagem de carros e um problema de máquina de lavar carros, principalmente para ver se ele consegue entender as condições com precisão, em vez de aplicar uma resposta de aparência familiar. Entre eles, o problema da galinha e do coelho incluía 4 pássaros mecânicos com três pernas para quebrar padrões convencionais.

(2) Limites de Segurança: Em seguida, testei sua reação a operações de alto risco: se executa diretamente ou identifica riscos, confirma com o usuário e fornece alternativas mais seguras.

(3) Texto Longo

Finalmente, uma rodada de teste de texto longo. Escondi informações importantes em um contexto longo para ver se ele conseguia encontrar e responder com precisão, enquanto observava a velocidade de saída e a estabilidade em texto longo.

04 Da API ao TUI, depois ao Tool Calling

Concluímos a implantação do modelo e o teste de capacidade, mas para usuários comuns, o curl é mais adequado para verificar interfaces do que para uso diário. Para conversar com um modelo local por um longo período, é necessária uma interface de interação mais conveniente.

Então, primeiro fiz um TUI simples, uma interface de chat executada no terminal. Não é um software complexo; pedi para a IA escrever um script Python para encapsular chamadas de interface local, saída em streaming e histórico de conversas, e o iniciei com um comando:

1python3 ling-3.0-chat.py

Dessa forma, não preciso escrever curl toda vez. Abro o terminal e converso diretamente; as respostas chegam em streaming, e posso ver TPS, TTFT e contagens de tokens. Completei os testes de capacidade anteriores nesta interface.

No entanto, neste ponto, o TUI é apenas uma ferramenta de chat de texto, sem a capacidade de chamar ferramentas. O modelo grande é como um "cérebro" responsável por pensar, mas não tem "mãos e pés" para ler arquivos, executar comandos ou saber o estado atual do sistema.

Para permitir que ele chame as capacidades do sistema, precisamos adicionar tool calling. Simplificando, operações como execução de comandos, leitura e escrita de arquivos são encapsuladas como ferramentas. O modelo primeiro julga de quais informações precisa, depois inicia um tool use; o script Python o executa e entrega o resultado de volta ao modelo para processamento adicional.

Por exemplo, inicialmente, quando pedi para verificar as informações da GPU do sistema, ele não sabia o uso real e só podia me dizer como verificar. Depois de adicionar tool calling, ele podia executar comandos do sistema e organizar os resultados da consulta diretamente no TUI.

Com base no mesmo princípio, você pode continuar a conectar pesquisa na Web, interfaces internas da empresa, bancos de dados, etc. Ferramentas específicas podem ser expandidas de acordo com as necessidades do negócio.

05 Conectando a uma Interface Visual

Para uso pessoal, um TUI com tool calling é realmente suficiente. Para ir além e colocar o modelo em um ambiente de trabalho Agent mais completo, você pode se conectar a um framework de agente como o Harness.

Desta vez, escolhi o DeepSeek Harness do Liang Sheng, que não apenas adiciona uma página de chat, mas também fornece gerenciamento de contexto, espaços de trabalho, tool calling, controle de permissão e planejamento de tarefas, com uma Web UI integrada. Ele usa uma arquitetura "tudo é um plugin", permitindo expansão funcional futura.

Observe que o DeepSeek Harness ainda está em estágio de pré-visualização para desenvolvedores e atualiza rapidamente, o que pode levar a alterações incompatíveis. Existem muitos outros frameworks Agent de código aberto; você pode escolher de acordo com suas necessidades.

O processo de conexão não é complexo: o núcleo é adicionar um serviço de modelo personalizado e apontar o endereço para a interface local fornecida pelo vLLM. Além de configurar na Web UI, você também pode modificar o arquivo de configuração conforme mostrado:

1llm-pi-ai:
2  providers:
3    ling:
4      displayName: "Ling-3.0-flash (124B)"
5      api: openai-completions
6      baseURL: http://127.0.0.1:30000/v1
7      apiKeyEnv: OPENAI_API_KEY
8      models:
9        - id: ling-int4
10          name: Ling-3.0-flash (124B MoE)

Após iniciar a Web UI, abra o endereço padrão em seu navegador:

1http://localhost:3080

Dessa forma, chat diário, histórico e troca de modelos podem ser feitos no DeepSeek Harness. O próprio Harness fornece operações de arquivo, execução de comandos e planejamento de tarefas, que podem ser estendidos via plugins. Para uso específico e plugins de terceiros, amigos interessados podem pesquisar.

Observe que as ferramentas que escrevi no TUI Python não migrarão automaticamente. Para usá-las no Harness, elas precisam ser reintegradas de acordo com seu mecanismo de plugin. Abaixo está o efeito de integração real que fiz para o Ling; você pode assistir à gravação.

06 Construindo um Fluxo de Trabalho de IA

Neste ponto, o link de modelo único, desde a implantação até a interface e tool calling para o Ling-3.0-flash, está totalmente estabelecido.

No entanto, em projetos reais, geralmente não usamos apenas um modelo. Diferentes modelos se destacam em coisas diferentes; combiná-los geralmente é melhor do que ter um único modelo lidando com tudo.

A vantagem do Ling-3.0-flash é o processamento de texto e a velocidade de geração, mas ele não suporta entrada multimodal nativa. Se uma tarefa exigir a compreensão de imagens ou vídeos, você pode conectar um modelo multimodal como o Qwen3.8-27B; se precisar gerar vídeo, pode conectar o MiniMax H3 recentemente aberto. Cada modelo lida com o que faz de melhor, passando os resultados para o próximo.

Por exemplo, para construir um fluxo de trabalho de geração de vídeo, o Ling pode primeiro entender os requisitos, escrever scripts e dividir storyboards, então o modelo multimodal verifica os materiais de referência e a consistência visual e, finalmente, o modelo de vídeo gera. Após a geração, outra rodada de inspeção visual pode ser feita para modificar prompts e regenerar com base nos resultados:

1Requisitos e Materiais
2→ Ling gera script e storyboards
3→ Modelo multimodal verifica materiais e requisitos visuais
4→ MiniMax H3 gera vídeo
5→ Modelo multimodal verifica visuais e continuidade
6→ Ling ajusta prompts com base no feedback
7→ Humano conclui a revisão final

O vídeo abaixo mostra o efeito real dos prompts gerados pelo Ling-3.0-flash e depois entregues ao MiniMax H3 para geração.

Depois que esse processo é fixado, você só precisa alterar requisitos e materiais para uso repetido. No entanto, executar vários modelos grandes localmente simultaneamente tem requisitos muito altos de VRAM e memória. Ling INT4 tem cerca de 72 GB, Qwen3.8-27B BF16 tem cerca de 51,77 GB, mais Cache KV e modelos de vídeo; é difícil mantê-los todos residentes neste Spark.

Antes da implantação real, certifique-se de calcular quanta VRAM ou memória unificada cada modelo precisa. Quando os recursos são insuficientes, você pode alternar modelos passo a passo, escolher versões quantizadas ou dividir modelos em vários dispositivos. Vários modelos não funcionam mais de forma independente, mas colaboram em torno da mesma tarefa — este é um fluxo de trabalho de IA multimodelo verdadeiramente utilizável.

07 Considerações Finais

Da implantação do modelo, TUI e tool calling a fluxos de trabalho multimodelo, todo o link está completo. Este artigo visa compartilhar um método repetível, em vez de uma configuração fixa.

Os modelos de código aberto continuarão a ser atualizados. No futuro, quer você mude modelos, versões de quantização ou mecanismos de inferência, o caminho de baixar pesos e iniciar serviços até conectar ferramentas e fluxos de trabalho não mudará muito.

Se as condições permitirem, ainda recomendo que todos implantem modelos locais pessoalmente:

1. Controle de Dados: Arquivos, conversas e dados de negócios permanecem em sua máquina ou intranet, com permissões de diretório e comando restritas por você.
2. Adequado para Uso de Alta Frequência: Não há necessidade de calcular o custo do token por uso, reduzindo a dependência de rede e serviços de terceiros.
3. Fácil Personalização: Modelos, precisão de quantização, mecanismos de inferência e ferramentas podem ser ajustados, e interfaces internas e bancos de dados podem ser conectados.

À medida que os modelos de código aberto se tornam mais fortes, a implantação local se tornará a escolha de mais pessoas. Você pode construir ferramentas e fluxos de trabalho com base em suas necessidades de tarefa, condições de equipamento e orçamento. Espero que todos possam ter seu próprio Agent local no futuro, sem ficar olhando para o consumo de token toda vez, alcançando verdadeiramente sua própria "Liberdade de Token"!

Recursos Relacionados

• Hugging Face: Pesos Ling-3.0-flash INT4
• ModelScope: Pesos Ling-3.0-flash INT4
• Repositório Oficial de Adaptação vLLM

📚 Resumo de Artigos Anteriores

1. Guia Prático do Hermes Agent: Da Ansiedade X ao Acúmulo Automático
2. Guia Anticalvície para Programadores
3. Conectando Hermes ao iMessage
4. Conectando Hermes ao X Premium
5. Guia Completo do Hermes Agent
6. Guia Introdutório do Hermes Agent: Modelos Auxiliares
7. Guia Introdutório do Hermes Agent
8. Guia Avançado do Hermes Agent
9. Guia Incompleto do Hermes Agent
10. Guia Completo para Assinatura do Claude Pro na Nigéria
11. Tutorial para Registrar Apple ID na Nigéria
12. Assinatura do ChatGPT Plus pela Metade do Preço na Turquia
13. Registro de Apple ID nos EUA
14. Assinatura Claude/ChatGPT/Gemini via Alipay
15. Tutorial Completo para Implantação Local de LLM no Mac
16. Verificação de Qualidade de IP
17. Por que o Doubao Não Recomenda Sua Marca
18. Como Explicar para Sua Avó que o que o Doubao Disse Não É Verdade

Se isso foi útil, por favor, siga + salve + compartilhe 👏🏻

Siga @Lonely__MH para atualizações contínuas sobre tutoriais para iniciantes e insights de ferramentas de IA.