Formulário de contato

Nome

E-mail *

Mensagem *

Imagem

Como Configurar Modelos NVIDIA Build no Kimi Code

Como Configurar Modelos NVIDIA Build no Kimi Code

Publicado por em


@CanalQb no YouTube


@CanalQb

Como Configurar Modelos NVIDIA Build no Kimi Code


Feito com Master Rules Claude v9.4

Leitura: ~16 min

TL;DR
  • O Kimi Code acessa os modelos do build.nvidia.com pela nuvem da NVIDIA, e um proxy local de 120 linhas em Python corrige o erro HTTP 400 causado pelo parâmetro prompt_cache_key.
  • Três arquivos resolvem tudo: o nvidia_shim.py na porta 8878, o config.toml apontando para ele e uma chave nvapi- guardada fora de qualquer repositório ou print.
  • Teste cada modelo antes de confiar nele: em 12/11/2026, só 7 dos modelos testados responderam, e GLM-5.3 e Kimi K3 já tinham sido aposentados no NIM.

Nota Técnica: Os scripts deste post têm fins exclusivamente educacionais. Teste sempre em ambiente controlado. @CanalQb não se responsabiliza por danos, perdas, bloqueios de conta ou vazamento de chaves decorrentes do uso indevido.

Existe uma ideia errada muito comum: quem vê o nome NVIDIA aparecendo no terminal do Kimi Code imagina que a placa de vídeo do próprio computador está trabalhando. Não está. Na máquina que serviu de base para este tutorial nem existe placa NVIDIA, só a gráfica integrada da Intel, e mesmo assim um modelo de 1 trilhão de parâmetros responde em segundos.

O que acontece é mais interessante e muito mais barato: seu terminal conversa com os servidores da NVIDIA por uma API compatível com a da OpenAI, e um pequeno programa local precisa limpar um detalhe da requisição para ela ser aceita. Neste guia você monta essa ponte inteira, copia os dois arquivos prontos e descobre como não vazar a sua chave no processo.

Quais são as soluções rápidas para os erros mais comuns?

Quase todo problema desta configuração cai em cinco causas: parâmetro rejeitado pela NVIDIA, modelo aposentado, nome de modelo sem o prefixo do fabricante, limite de requisições por minuto e chave exposta. Cada uma tem correção curta, e o passo completo está no bloco de erros no fim do post.

  • HTTP 400 "Unsupported parameter(s): prompt_cache_key": o shim não está rodando ou o base_url não aponta para a porta 8878. ver passo completo
  • HTTP 410 em um modelo: a NVIDIA aposentou aquele modelo, então troque por outro que apareça no catálogo atual. ver passo completo
  • HTTP 404 "not found for account": o nome está incompleto ou sua conta não tem acesso ao modelo. ver passo completo
  • HTTP 429: você passou do limite por minuto, então espere ou reduza o paralelismo. ver passo completo
  • Chave nvapi- colada em print ou chat: revogue e gere outra imediatamente. ver passo completo

O que é o NVIDIA Build e por que o Kimi Code não usa a GPU do seu PC?

O NVIDIA Build (build.nvidia.com) é o portal onde a NVIDIA hospeda dezenas de modelos de linguagem em sua própria nuvem e os expõe por uma API compatível com a OpenAI. Seu computador envia texto pela internet e recebe a resposta pronta, sem usar nenhuma placa de vídeo local.

Por trás do portal está o NVIDIA NIM, sigla de NVIDIA Inference Microservices: contêineres que rodam modelos em GPUs de datacenter com otimizações como o TensorRT-LLM. A documentação oficial descreve um único endpoint, o POST /v1/chat/completions em https://integrate.api.nvidia.com, que atende chat, perguntas e respostas, resumo e geração de código. Para o seu programa, isso é só mais um servidor no padrão OpenAI.

Essa arquitetura tem duas consequências práticas. A primeira é que a qualidade do modelo não depende do seu hardware: o mesmo Mistral Large 4 de 1 trilhão de parâmetros que citei responde igual numa máquina com gráfica integrada. A segunda é que sua máquina vira apenas cliente, então o gargalo passa a ser internet, limite de requisições e disponibilidade do catálogo, nunca memória de vídeo.

Aqui em @CanalQb validamos o fluxo verificando o hardware antes de escrever: consultamos WMI, PnP e o barramento PCI com o identificador de fabricante da NVIDIA, e não apareceu nenhuma placa. Quem quiser rodar modelo de verdade no próprio PC usa Ollama local, que é outro caminho. Pesquisando por Ollama aqui no blog você encontra esse assunto separado, porque misturar nuvem e local é a principal fonte de confusão nessa área.

Como gerar a API key no build.nvidia.com sem expor a sua chave?

Entre em build.nvidia.com com sua conta, abra qualquer modelo do catálogo e clique em Get API Key, ou vá direto à página de chaves nas configurações. A chave começa com nvapi- e aparece uma única vez, então copie e guarde em local seguro imediatamente.

A NVIDIA exige uma conta no programa de desenvolvedores, e o acesso gratuito não pede cartão de crédito segundo os guias que consultei. Ao gerar a chave, o portal mostra o valor completo uma só vez. Se você fechar a janela sem copiar, o caminho é gerar outra, o que não custa nada, mas obriga a atualizar todos os lugares onde a antiga estava em uso.

A regra que sustenta todo o resto do post é simples: a chave nunca aparece em captura de tela, em chat, em repositório Git, em vídeo ou em comentário de código publicado. Neste tutorial todas as chaves aparecem como nvapi-SUA_CHAVE_AQUI, e o arquivo original que serviu de base teve as chaves reais substituídas antes de entrar na página. Se você já colou uma chave real em algum lugar público, ela deve ser considerada comprometida.

Como tratar a chave desde o primeiro minuto

Crie um nome descritivo para a chave no painel, como "kimi-code-notebook", para saber qual revogar caso suma o controle. Mantenha uma chave por máquina ou projeto: se uma vazar, você revoga só ela, sem derrubar o resto. Em Windows, guarde o valor num gerenciador de senhas e, quando precisar dela no terminal, use variável de ambiente da sessão em vez de arquivo versionado.

Aviso: uma chave nvapi- dá acesso a tudo que a sua conta pode chamar. Quem a tem consome a sua cota de requisições e pode gerar tráfego em seu nome.

Como o Kimi Code se conecta ao NVIDIA NIM na prática?

O Kimi Code lê o arquivo config.toml, escolhe o provedor do modelo padrão e envia as requisições para o base_url configurado. Em vez de apontar direto para a NVIDIA, apontamos para um proxy local na porta 8878, que repassa tudo para a nuvem após limpar um parâmetro.

O desenho completo tem quatro etapas. Primeiro, o Kimi Code CLI lê default_model no ~/.kimi-code/config.toml. Segundo, o provedor chamado nvidia tem base_url = "http://127.0.0.1:8878/v1", ou seja, aponta para a própria máquina. Terceiro, o shim em Python remove o campo prompt_cache_key do JSON e reencaminha para https://integrate.api.nvidia.com/v1 com a sua chave. Quarto, a NVIDIA executa o modelo e devolve a resposta em streaming, byte a byte, até o terminal.

EtapaOnde rodaO que faz
Kimi Code CLISeu PCMonta a requisição no formato OpenAI e envia para o provedor escolhido
nvidia_shim.pySeu PC, porta 8878Remove prompt_cache_key e repassa cabeçalhos, streaming e ferramentas
integrate.api.nvidia.comNuvem NVIDIAAutentica a chave, localiza o modelo e executa a inferência

Um detalhe que poupa tempo de diagnóstico: como o proxy escuta só em 127.0.0.1, nenhum outro computador da sua rede consegue usá-lo. Isso é desejável, porque o shim repassa a sua chave. Também significa que, se o shim não estiver rodando, o Kimi Code falha com erro de conexão recusada em vez de erro da NVIDIA, e é assim que você distingue os dois problemas rapidamente.

Por que o nvidia_shim.py é necessário e o que ele faz linha a linha?

O Kimi Code 2.0 sempre envia o campo prompt_cache_key nas requisições do protocolo OpenAI, mas o endpoint da NVIDIA o rejeita com erro HTTP 400. O shim é um proxy de loopback que apaga esse campo e repassa todo o resto sem alterações.

Sem ele, a primeira mensagem já falha com a frase "Unsupported parameter(s): prompt_cache_key". O programa é pequeno porque faz uma coisa só, e vale entender cada bloco antes de rodar código que manipula sua chave.

O que cada parte do script resolve

As constantes no topo definem a escuta em 127.0.0.1:8878, o destino integrate.api.nvidia.com, um timeout de 600 segundos para respostas longas de modelos que raciocinam e o conjunto STRIP_PARAMS com o que deve ser apagado. A lista HOP_BY_HOP reúne cabeçalhos que não devem atravessar um proxy, como Host, Content-Length e Connection, para o Python recalcular os corretos.

O método _strip só mexe no corpo se o texto bruto contiver a palavra prompt_cache_key; nesse caso decodifica o JSON, remove a chave e serializa de novo. Se algo falhar, devolve o corpo original, o que evita derrubar uma requisição por causa do filtro. O método _forward abre uma conexão HTTPS, repassa método, caminho, cabeçalhos e corpo, e então copia a resposta em blocos de 4096 bytes com flush, preservando o streaming SSE. Qualquer falha de rede vira uma resposta 502 em JSON, com a mensagem "shim upstream error". Há ainda o endpoint /health, que responde "ok" e serve para testar se o processo está de pé.

"""Kimi Code <-> NVIDIA NIM shim.

Kimi Code 2.0.x always sends `prompt_cache_key` on OpenAI-protocol requests,
but NVIDIA's OpenAI-compatible endpoint rejects it with
"Validation: Unsupported parameter(s): `prompt_cache_key`" (HTTP 400).

This loopback proxy strips that field and forwards everything else untouched
(headers, streaming SSE, tools, reasoning_effort), so GLM-5.3 works in Kimi.

Run: pythonw nvidia_shim.py   (listens on 127.0.0.1:8878; exits silently if busy)
Remove: run uninstall.ps1, then restore base_url in
        ~/.kimi-code/config.toml to https://integrate.api.nvidia.com/v1
"""

import json
import socket
import ssl
import sys
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import http.client

LISTEN_HOST = "127.0.0.1"
LISTEN_PORT = 8878
UP_HOST = "integrate.api.nvidia.com"
UP_TIMEOUT_S = 600
STRIP_PARAMS = {"prompt_cache_key"}

HOP_BY_HOP = {
    "host",
    "content-length",
    "transfer-encoding",
    "connection",
    "keep-alive",
    "proxy-authenticate",
    "proxy-authorization",
    "te",
    "trailer",
    "upgrade",
    "expect",
    "accept-encoding",
}


class Shim(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"

    def log_message(self, *args):
        pass

    def log_error(self, *args):
        pass

    def _read_body(self):
        try:
            length = int(self.headers.get("Content-Length", 0))
        except ValueError:
            length = 0
        return self.rfile.read(length) if length > 0 else b""

    def _strip(self, raw):
        if not raw or b"prompt_cache_key" not in raw:
            return raw
        try:
            obj = json.loads(raw)
            if isinstance(obj, dict):
                for key in STRIP_PARAMS:
                    obj.pop(key, None)
                return json.dumps(obj, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
        except Exception:
            pass
        return raw

    def do_GET(self):
        if self.path.startswith("/health"):
            body = b"ok"
            self.send_response(200)
            self.send_header("Content-Type", "text/plain")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)
            return
        self._forward("GET", None)

    def do_POST(self):
        self._forward("POST", self._strip(self._read_body()))

    def do_DELETE(self):
        self._forward("DELETE", self._read_body())

    def do_PUT(self):
        self._forward("PUT", self._strip(self._read_body()))

    def _forward(self, method, body):
        headers = {}
        for name, value in self.headers.items():
            if name.lower() in HOP_BY_HOP:
                continue
            headers[name] = value
        if body is not None:
            headers["Content-Length"] = str(len(body))
        try:
            conn = http.client.HTTPSConnection(
                UP_HOST, timeout=UP_TIMEOUT_S, context=ssl.create_default_context()
            )
            conn.request(method, self.path, body=body, headers=headers)
            upstream = conn.getresponse()
        except Exception as exc:
            payload = json.dumps({"error": {"message": f"shim upstream error: {exc}"}}).encode()
            self.send_response(502)
            self.send_header("Content-Type", "application/json")
            self.send_header("Content-Length", str(len(payload)))
            self.send_header("Connection", "close")
            self.end_headers()
            self.wfile.write(payload)
            self.close_connection = True
            return

        self.send_response(upstream.status)
        for name, value in upstream.getheaders():
            if name.lower() in HOP_BY_HOP:
                continue
            self.send_header(name, value)
        self.send_header("Connection", "close")
        self.end_headers()
        self.close_connection = True
        try:
            while True:
                chunk = upstream.read(4096)
                if not chunk:
                    break
                self.wfile.write(chunk)
                self.wfile.flush()
        except (BrokenPipeError, ConnectionResetError, socket.timeout):
            pass
        finally:
            conn.close()


class Server(ThreadingHTTPServer):
    daemon_threads = True
    allow_reuse_address = True


def main():
    try:
        server = Server((LISTEN_HOST, LISTEN_PORT), Shim)
    except OSError:
        sys.exit(0)
    try:
        server.serve_forever(poll_interval=1.0)
    except KeyboardInterrupt:
        pass
    finally:
        server.server_close()


if __name__ == "__main__":
    main()

Repare que o script não contém nenhuma chave: ele apenas repassa o cabeçalho Authorization que o Kimi Code envia. Isso significa que você pode publicá-lo sem risco, desde que a chave continue só no config.toml. A docstring menciona um uninstall.ps1 que não faz parte deste post; para remover o shim, basta encerrar o processo e devolver o base_url original do provedor.

Como instalar e rodar o shim no Windows passo a passo?

Salve o script numa pasta fixa dentro de ~/.kimi-code/proxy, rode com pythonw para ele ficar em segundo plano e confirme com uma chamada ao endpoint /health. Quando a porta 8878 já estiver ocupada, o script encerra sozinho sem erro, o que evita duplicar o processo.

Você só precisa do Python 3 instalado, porque o shim usa apenas a biblioteca padrão: nada de pip install. Os comandos abaixo são de PowerShell, o shell nativo do Windows.

  1. Crie a pasta do proxy (1 minuto). Execute o comando abaixo no PowerShell. Ele cria o diretório se ainda não existir e não apaga nada. Essa pasta é o lugar onde o script vai morar para sempre, então escolher um caminho estável evita ter de reconfigurar atalhos depois. Se o comando funcionar, o PowerShell não imprime erro e apenas devolve o prompt.
    New-Item -ItemType Directory -Force "$HOME\.kimi-code\proxy"
    Erro comum: "acesso negado" indica que a pasta .kimi-code pertence a outro usuário; abra o PowerShell com a conta que instalou o Kimi Code.
  2. Salve o nvidia_shim.py nessa pasta (2 minutos). Copie o código completo do bloco da seção anterior para um arquivo chamado nvidia_shim.py dentro de .kimi-code\proxy. Use um editor de texto simples e salve em UTF-8. O motivo da pasta fixa é que o comando de inicialização do próximo passo aponta para esse caminho exato. Para conferir, liste a pasta e veja o arquivo com cerca de 4 KB.
    Get-ChildItem "$HOME\.kimi-code\proxy"
    Erro comum: o Bloco de Notas pode salvar como nvidia_shim.py.txt; ative a exibição de extensões para conferir.
  3. Inicie o shim em segundo plano (10 segundos). O pythonw executa o script sem abrir janela de console. O programa começa a escutar em 127.0.0.1:8878 e, se a porta já estiver em uso por outra instância, sai em silêncio, o que é intencional. Você não verá nenhuma saída, e a ausência de mensagem é o comportamento esperado quando tudo deu certo.
    Start-Process pythonw -ArgumentList "$HOME\.kimi-code\proxy\nvidia_shim.py" -WindowStyle Hidden
    Erro comum: "pythonw não é reconhecido" significa que o Python não está no PATH; reinstale marcando a opção Add python.exe to PATH.
  4. Confirme que o proxy está vivo (5 segundos). Chame o endpoint /health. O resultado esperado é a palavra ok. Esse teste valida a metade local do caminho, ainda sem tocar na NVIDIA nem usar sua chave. Se aparecer ok, o resto é configuração; se der falha de conexão, o shim não subiu.
    Invoke-RestMethod http://127.0.0.1:8878/health
    Erro comum: antivírus corporativo bloqueando a porta; teste outra porta alterando LISTEN_PORT e o base_url juntos.
  5. Faça o shim subir junto com o Windows (opcional, 3 minutos). Coloque um atalho do comando do passo 3 na pasta de inicialização, que você abre com o atalho shell:startup no Executar. Sem isso, toda vez que reiniciar o computador você precisa repetir o passo 3, e o Kimi Code vai falhar com conexão recusada até lá. Erro comum: criar o atalho para python em vez de pythonw, o que abre uma janela preta que fecha o processo ao ser encerrada.

Como montar o config.toml com provedores e modelos da NVIDIA?

O config.toml tem três tipos de bloco: o modelo padrão no topo, os provedores com base_url e chave, e os modelos, cada um ligado a um provedor. Para a NVIDIA, o provedor usa type openai, base_url do shim e a chave nvapi- no campo api_key.

Abaixo está o arquivo real usado no canal, com as três chaves substituídas por marcadores. O que você precisa entender é a lógica: cada bloco [models."nvidia/..."] é um apelido que aparece no seletor do Kimi, enquanto o campo model é o identificador exato esperado pela NVIDIA, no formato fabricante/modelo. Errar essa segunda parte é a principal causa de 404.

# ~/.kimi-code/config.toml  (CHAVES SUBSTITUIDAS POR MARCADORES)
default_model = "nvidia/mistral-large-4"

[providers.nvidia]
# shim local remove prompt_cache_key (o NIM rejeita com HTTP 400)
type = "openai"
base_url = "http://127.0.0.1:8878/v1"
api_key = "nvapi-SUA_CHAVE_AQUI"

[providers."ollama-cloud"]
type = "openai"
base_url = "https://ollama.com/v1"
api_key = "SUA_CHAVE_OLLAMA_AQUI"
# Free tier sem cartao. O host correto e ollama.com.

# --- NVIDIA NIM (via shim 127.0.0.1:8878) ---
[models."nvidia/nemotron-3-ultra-550b"]
provider = "nvidia"
model = "nvidia/nemotron-3-ultra-550b-a55b"
max_context_size = 131072
display_name = "Nemotron 3 Ultra 550B (NVIDIA)"
capabilities = ["tool_use"]

[models."nvidia/mistral-large-4"]
provider = "nvidia"
model = "mistralai/mistral-large-4-1t-a52b"
max_context_size = 131072
display_name = "Mistral Large 4 1T (NVIDIA)"
capabilities = ["tool_use"]

[models."nvidia/nemotron-3.5-lightning-30b"]
provider = "nvidia"
model = "nvidia/nemotron-3.5-lightning-30b-a3b"
max_context_size = 131072
display_name = "Nemotron 3.5 Lightning 30B (NVIDIA)"
capabilities = ["tool_use"]

[models."nvidia/nemotron-3.5-bolt-e4b"]
provider = "nvidia"
model = "nvidia/nemotron-3.5-bolt-e4b"
max_context_size = 65536
display_name = "Nemotron 3.5 Bolt E4B (NVIDIA, leve)"
capabilities = ["tool_use"]

[models."nvidia/poolside-laguna-xs"]
provider = "nvidia"
model = "poolside/laguna-xs-2.1"
max_context_size = 131072
display_name = "Poolside Laguna XS 2.1 (NVIDIA)"
capabilities = ["tool_use"]

[models."nvidia/step-5-preview"]
provider = "nvidia"
model = "stepfun-ai/step-5-preview"
max_context_size = 131072
display_name = "Step-5 Preview (NVIDIA)"
capabilities = ["tool_use"]

[models."nvidia/nemotron-3.5-super-vl-120b-a12b"]
provider = "nvidia"
model = "nvidia/nemotron-3.5-super-vl-120b-a12b"
max_context_size = 131072
display_name = "Nemotron 3.5 Super VL 120B (NVIDIA, visao)"
capabilities = ["image_in", "tool_use"]

# --- Ollama Cloud (free tier) ---
[models."ollama-cloud/nemotron-3-super"]
provider = "ollama-cloud"
model = "nemotron-3-super"
max_context_size = 131072
display_name = "Nemotron 3 Super (Ollama)"
capabilities = ["tool_use"]

[models."ollama-cloud/gemma4-31b"]
provider = "ollama-cloud"
model = "gemma4:31b"
max_context_size = 131072
display_name = "Gemma 4 31B (Ollama)"
capabilities = ["tool_use"]

[thinking]
enabled = false
effort = "low"

Os blocos do provedor Kimi Code gerenciado (managed:kimi-code), as entradas de serviços de busca e as regras de permissão do arquivo original foram omitidos aqui porque não fazem parte do assunto e porque o bloco de busca usa autenticação OAuth própria. Mantenha esses trechos no seu arquivo como estão. Os campos capabilities informam ao Kimi o que o modelo suporta, e image_in só deve aparecer em modelos de visão, como o Super VL 120B. O valor max_context_size precisa respeitar o contexto real do modelo, senão a conversa estoura no meio.

Como descobrir quais modelos da NVIDIA realmente respondem na sua conta?

Liste o catálogo pela rota /v1/models e depois envie uma mensagem curta a cada modelo que você pretende usar. Estar listado não garante resposta: contas diferentes recebem acessos diferentes, e modelos aposentados continuam aparecendo por algum tempo em guias antigos.

Esta é a parte do tutorial em que o canal tem dado próprio. Em 03/11/2026 varremos o catálogo da chave: dos 85 modelos listados, só 15 responderam, e 60 devolveram 404 "not found for account". Em 12/11/2026 repetimos o teste com várias chaves da mesma conta e os resultados foram idênticos, o que mostra que a restrição vem da conta e não de uma chave específica. Nesse teste, responderam 200 OK sete modelos: Mistral Large 4, Nemotron 3 Ultra, Nemotron 3.5 Bolt, Nemotron 3.5 Lightning, Nemotron 3.5 Super VL, Poolside Laguna XS e Step-5 Preview.

Também registramos aposentadorias: o GLM-5.3 cheio passou a responder 410 em 28/10/2026 e o Kimi K3 hospedado na NVIDIA em 15/10/2026, motivo pelo qual o default_model permaneceu no Mistral Large 4. O script abaixo automatiza esse teste. Ele lê a chave da variável de ambiente NVIDIA_API_KEY, então não existe chave dentro do código, e imprime o código HTTP de cada modelo da sua lista. Eu o escrevi para este post e não o executei nesta sessão, por isso rode primeiro com um modelo só.

import json, os, sys, urllib.request, urllib.error

KEY = os.environ.get("NVIDIA_API_KEY")
if not KEY:
    sys.exit("Defina a variavel NVIDIA_API_KEY antes de rodar.")

URL = "https://integrate.api.nvidia.com/v1/chat/completions"
MODELOS = [
    "mistralai/mistral-large-4-1t-a52b",
    "nvidia/nemotron-3-ultra-550b-a55b",
    "nvidia/nemotron-3.5-bolt-e4b",
    "nvidia/nemotron-3.5-lightning-30b-a3b",
    "poolside/laguna-xs-2.1",
]

for modelo in MODELOS:
    corpo = json.dumps({
        "model": modelo,
        "messages": [{"role": "user", "content": "Responda apenas: ok"}],
        "max_tokens": 16,
    }).encode()
    req = urllib.request.Request(URL, data=corpo, headers={
        "Authorization": "Bearer " + KEY,
        "Content-Type": "application/json",
    })
    try:
        with urllib.request.urlopen(req, timeout=60) as r:
            print(r.status, modelo)
    except urllib.error.HTTPError as e:
        print(e.code, modelo)
    except Exception as e:
        print("ERRO", modelo, e)

Para usar, defina a variável só na sessão atual do PowerShell com $env:NVIDIA_API_KEY = "nvapi-SUA_CHAVE_AQUI" e rode python teste_modelos.py. Como o teste chama a NVIDIA direto, ele não passa pelo shim e não precisa dele. Leia os códigos assim: 200 funciona, 404 é nome errado ou sem acesso na conta, 410 foi aposentado, 429 estourou o limite e qualquer 5xx é instabilidade do lado deles. Refaça o teste de tempos em tempos, porque a lista muda.

Como proteger a chave nvapi- e evitar que ela vaze de novo?

Trate a chave como senha: não salve em repositório, não cole em chat ou print e rotacione imediatamente se ela aparecer em algum lugar visível. No config.toml ela fica em texto puro, então qualquer processo local que leia o arquivo consegue usá-la.

O próprio diagnóstico que originou este post alertou para isso: a chave nvapi- estava em texto plano dentro do ~/.kimi-code/config.toml. A primeira defesa é operacional. Revogue no painel da NVIDIA qualquer chave que tenha sido exibida em tela compartilhada, gravação de vídeo, mensagem de suporte ou conversa com assistente de IA, e gere outra. Revogar custa um minuto, e esperar para ver se alguém usou custa cota e, em planos pagos, dinheiro.

Uma variação para tirar a chave do arquivo (experimental)

Como o shim já repassa os cabeçalhos, dá para fazê-lo injetar a chave a partir de uma variável de ambiente e deixar no config.toml só um valor sem importância. Isso não está confirmado em nenhuma documentação que eu tenha lido, é uma modificação minha e não foi executada nesta sessão: teste num modelo antes de depender dela. A mudança são duas linhas: importar os no topo e, dentro de _forward, logo após montar o dicionário de cabeçalhos, substituir o Authorization.

# no topo do nvidia_shim.py
import os

# dentro de _forward, depois do laco que monta "headers"
_k = os.environ.get("NVIDIA_API_KEY")
if _k:
    headers = {n: v for n, v in headers.items() if n.lower() != "authorization"}
    headers["Authorization"] = "Bearer " + _k

Com isso, defina NVIDIA_API_KEY como variável de ambiente do usuário antes de iniciar o pythonw, e no config.toml deixe api_key = "placeholder". Se o seu repositório de dotfiles for público, inclua o config.toml no .gitignore de qualquer forma. Também confira o histórico do Git: apagar o arquivo no commit de hoje não remove a chave dos commits antigos.

Quais são os limites do plano gratuito e como lidar com 429, 404 e 410?

O acesso gratuito do build.nvidia.com tem limite de requisições por minuto, citado entre 30 e 40 por chave nas fontes que consultei, e o valor varia por modelo e por tráfego. Passou do limite, a resposta é 429, e a NVIDIA não oferece aumento oficial no plano gratuito.

Essa divergência de números é real e preciso registrá-la: um guia de abril de 2026 fala em 30 requisições por minuto, enquanto a documentação de um adaptador e um tópico do fórum de desenvolvedores da NVIDIA falam em 40. A resposta de um moderador no fórum, em julho de 2026, deixa claro que o limite do plano gratuito depende do modelo, do caso de uso e do tráfego geral, e que o único caminho para mais capacidade é contratar e implantar o modelo. Por isso, em vez de decorar um número, trate o limite como variável e meça o seu.

CódigoSignificado provávelO que fazer
400Parâmetro rejeitado (como prompt_cache_key)Conferir se o shim está ativo e o base_url aponta para a porta 8878
404Nome incompleto ou modelo sem acesso na contaUsar o formato fabricante/modelo e testar com o script
410Modelo aposentadoTrocar por um modelo vivo do catálogo atual
429Limite por minuto excedidoEsperar, reduzir chamadas paralelas ou alternar de modelo
502 do shimFalha de rede no caminho até a NVIDIATestar a internet e tentar de novo

Fluxos de agente, como o Kimi Code, disparam muitas chamadas por tarefa (planejar, ler arquivos, editar, usar ferramentas), então esbarram nesse teto mais rápido do que um chat comum. Uma estratégia prática é manter dois ou três modelos configurados e trocar de um para outro quando um começar a devolver 429. Também há o Ollama Cloud no mesmo arquivo, que no nosso teste incluiu no plano gratuito só alguns modelos, como Gemma 4 31B e Nemotron 3 Super. O nome do modelo funciona em duas camadas, o apelido que você escolhe e o identificador da NVIDIA, e essa separação deixa trocar o modelo real sem mexer nos atalhos que você já usa. Para mais conteúdo do tipo, veja o que já publicamos buscando Kimi Code no @CanalQb e as notas sobre API da NVIDIA.

Como escolher qual modelo da NVIDIA usar para cada tipo de tarefa?

Use um modelo grande como padrão para tarefas de código e raciocínio, um modelo leve para perguntas rápidas e um modelo de visão só quando precisar enviar imagens. Como o catálogo muda, a escolha deve se apoiar em teste real e não em fama do modelo.

Na configuração do canal, o Mistral Large 4 é o padrão porque foi o que respondeu com consistência em todas as rodadas de teste, com contexto de 131.072 tokens e suporte a ferramentas. O Nemotron 3 Ultra de 550 bilhões de parâmetros entra quando a tarefa pede mais capacidade, e o Nemotron 3.5 Lightning de 30 bilhões é a opção de menor latência. O Bolt E4B é o mais leve, com contexto de 65.536 tokens, bom para respostas curtas. O Super VL 120B é o único com a capacidade image_in no arquivo, então é o escolhido sempre que há captura de tela para interpretar.

Um critério que ajuda: tarefas com muitas chamadas de ferramenta se beneficiam de modelos marcados com tool_use e de respostas estáveis, enquanto um modelo que raciocina muito pode estourar o tempo limite de 600 segundos configurado no shim. A documentação do pacote de integração que consultei também avisa que o DeepSeek-R1 com ferramentas é pouco confiável e recomenda modelos Nemotron para fluxos de agente, o que bate com a nossa experiência de usar Nemotron nesses casos. Anote no próprio config.toml, em comentário, a data do último teste de cada modelo, como fizemos: daqui a um mês você agradece.

Perguntas frequentes sobre modelos NVIDIA no Kimi Code

O Kimi Code usa a placa de vídeo NVIDIA do meu computador?
Não. Quando o provedor é o NVIDIA NIM, todo o processamento acontece nas GPUs da nuvem da NVIDIA e o seu computador atua apenas como cliente e proxy. Você pode ter só gráfica integrada, como no computador usado neste teste, e ainda assim consultar modelos de centenas de bilhões de parâmetros. Para rodar modelo na máquina local, o caminho é outro, como o Ollama, assunto que você encontra buscando Ollama no blog.
Preciso pagar para usar os modelos do build.nvidia.com?
Os guias que consultei descrevem acesso gratuito por chave nvapi-, sem cartão de crédito, com limite de requisições por minuto que varia entre 30 e 40 conforme a fonte e o modelo. O gratuito não tem aumento de limite oficial, e para uso de produção a NVIDIA direciona para implantação paga do modelo. Confira sempre os termos atuais no portal antes de depender do serviço em algo importante, e veja outros guias buscando API da NVIDIA aqui.
Por que o erro prompt_cache_key aparece só com a NVIDIA?
O Kimi Code 2.0 envia esse campo em todas as requisições do protocolo OpenAI, mas o endpoint da NVIDIA valida os parâmetros de forma estrita e rejeita o desconhecido com HTTP 400. Outros provedores simplesmente ignoram o campo extra. O shim resolve isso apagando o parâmetro no caminho, sem mexer em cabeçalhos, streaming ou ferramentas. Se o erro persistir, confirme que o base_url do provedor aponta para a porta 8878 e não direto para a NVIDIA, e leia mais em Kimi Code no blog.
Posso colocar a chave em variável de ambiente em vez do config.toml?
Não confirmei se o Kimi Code expande variáveis de ambiente dentro do config.toml, então não afirmo que funcione. A alternativa testável é fazer o shim injetar o cabeçalho Authorization a partir de NVIDIA_API_KEY, como mostrado na seção de proteção da chave, deixando no arquivo apenas um valor sem importância. Essa variação é minha e não foi executada nesta sessão, portanto teste com um modelo antes de adotá-la. Mais sobre configuração em config.toml no blog.
O que faço quando um modelo some do catálogo?
Quando o modelo é aposentado, a NVIDIA passa a responder 410, como aconteceu com o GLM-5.3 em 28/10/2026 e com o Kimi K3 em 15/10/2026. Nesse caso, remova ou troque o bloco do modelo no config.toml, escolha outro que apareça na documentação atual e rode o script de teste para confirmar que responde na sua conta. Mantenha uma lista de reserva com dois ou três modelos testados, para que uma aposentadoria não pare o seu trabalho, e anote as datas dos testes em comentários. Veja outras dicas em API da NVIDIA.

{Erros e Soluções}

Estes são os erros que mais interrompem a configuração do NVIDIA NIM no Kimi Code, em ordem de frequência. Cada card traz a mensagem como ela aparece, a causa técnica, a correção e como evitar a repetição, sempre com o código HTTP ou o sintoma que você vai ver na tela.

Validation: Unsupported parameter(s): prompt_cache_key (HTTP 400)

Causa: o Kimi Code envia prompt_cache_key e o endpoint da NVIDIA não aceita esse parâmetro. Aparece quando o base_url aponta direto para integrate.api.nvidia.com ou quando o shim não está rodando.

Solução: confirme com Invoke-RestMethod http://127.0.0.1:8878/health; se não responder ok, inicie o pythonw como no passo 3. Depois verifique que o provedor nvidia tem base_url = "http://127.0.0.1:8878/v1".

Prevenção: coloque o atalho do shim na pasta de inicialização do Windows.

HTTP 410 ao chamar um modelo (EOL)

Causa: a NVIDIA aposentou o modelo e o identificador deixou de ser atendido, como ocorreu com o GLM-5.3 cheio e o Kimi K3 em outubro de 2026.

Solução: troque o campo model do bloco por um identificador vivo, consulte a lista atual em docs.api.nvidia.com e rode o teste_modelos.py para confirmar o 200.

Prevenção: mantenha um modelo reserva testado e atualize o default_model se o principal cair.

HTTP 404 "not found for account"

Causa: o nome do modelo está sem o prefixo do fabricante ou a sua conta não tem acesso àquele modelo, mesmo ele estando no catálogo.

Solução: use o formato completo, como mistralai/mistral-large-4-1t-a52b, e teste o modelo no script. Se continuar 404 com o nome certo, é restrição da conta e deve-se escolher outro.

Prevenção: só adicione ao config.toml modelos que tenham respondido 200 no teste.

HTTP 429 Too Many Requests

Causa: excesso de requisições por minuto na chave, comum em fluxos de agente que disparam várias chamadas por tarefa.

Solução: aguarde cerca de um minuto, reduza chamadas paralelas e alterne para outro modelo configurado enquanto o limite zera.

Prevenção: mantenha dois ou três modelos prontos e evite loops de ferramenta sem pausa.

Chave nvapi- exposta em print, chat ou repositório

Causa: o config.toml guarda a chave em texto puro e é fácil copiá-lo inteiro ao pedir ajuda ou publicar um tutorial.

Solução: revogue a chave no painel do build.nvidia.com, gere outra, atualize o config.toml e, se foi para o Git, limpe também o histórico.

Prevenção: mascare a chave antes de copiar qualquer arquivo e inclua o config.toml no .gitignore.

Gostou do tutorial? Veja o passo a passo em vídeo no canal @CanalQb no YouTube e continue lendo em canalqb.com.br.

Conformidade Global: As informações refletem o que foi verificado em 14/11/2026. Limites, catálogo e termos da NVIDIA mudam com frequência. Consulte sempre a documentação oficial. Este conteúdo não constitui aconselhamento jurídico. Veja o IAPP Global Privacy Directory para regras de privacidade por país.

Fontes e Referências

ID de vídeo padrão usado — substituir antes de publicar.

Marcadores: api config.toml Kimi Code LLM NVIDIA NIM Proxy Python Segurança Tutorial Windows

© novembro 14, 2026 CanalQb — Python, Scripts, Automação, Airdrops e Criptomoedas | Web3 e Tech na Prática



SEO Dashboard @CanalQb

Carregando dados...

Dados GA4 + Search Console | Atualizar | gerado via API Google