--- title: Reduzindo a latência url: https://platform.claude.com/docs/pt-BR/test-and-evaluate/strengthen-guardrails/reduce-latency description: Reduza a latência de resposta do Claude escolhendo um modelo mais rápido como o Claude Haiku 5.5, reduzindo os tokens de prompt e de saída e usando streaming de respostas. --- "Latency" (latência) refere-se ao tempo que o modelo leva para processar um prompt e gerar uma saída. A latência pode ser influenciada por vários fatores, como o tamanho do modelo, a complexidade do prompt e a infraestrutura subjacente que dá suporte ao modelo e ao ponto de interação. É sempre melhor primeiro elaborar um prompt que funcione bem sem restrições de modelo ou de prompt e, depois, experimentar estratégias de redução de latência. Tentar reduzir a latência prematuramente pode impedir que você descubra como é o desempenho máximo. *** ## Como medir a latência Ao discutir latência, você pode se deparar com vários termos e medidas: * **Latência de base (baseline latency):** É o tempo que o modelo leva para processar o prompt e gerar a resposta, sem considerar os tokens de entrada e saída por segundo. Fornece uma ideia geral da velocidade do modelo. * **"Time to first token" (tempo até o primeiro token), ou TTFT:** Essa métrica mede o tempo que o modelo leva para gerar o primeiro token da resposta, a partir do momento em que o prompt foi enviado. É particularmente relevante quando você está usando streaming (mais sobre isso adiante) e deseja oferecer uma experiência responsiva aos seus usuários. Para uma compreensão mais aprofundada desses termos, confira o [glossário](https://platform.claude.com/docs/pt-BR/about-claude/glossary). *** ## Como reduzir a latência ### 1. Escolha o modelo certo Uma das formas mais diretas de reduzir a latência é selecionar o modelo apropriado para o seu caso de uso. A Anthropic oferece uma [variedade de modelos](https://platform.claude.com/docs/pt-BR/models/overview) com diferentes capacidades e características de desempenho. Considere seus requisitos específicos e escolha o modelo que melhor atende às suas necessidades em termos de velocidade e qualidade de saída. Para aplicações em que a velocidade é crítica, o **Claude Haiku 5.5** oferece os tempos de resposta mais rápidos, mantendo alta inteligência. O [esforço](https://platform.claude.com/docs/pt-BR/build-with-claude/effort) é o principal controle de velocidade e custo desse modelo. Consulte [Use o esforço para controlar o pensamento](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking). O exemplo a seguir o executa em `low`, o nível mais barato e mais rápido, e deixa espaço em `max_tokens` para o pensamento: ```bash cURL # Para aplicações sensíveis ao tempo, use o Claude Haiku 5.5 com esforço baixo curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-haiku-5-5", "max_tokens": 1024, "output_config": {"effort": "low"}, "messages": [{"role": "user", "content": "Summarize this customer feedback in 2 sentences: [feedback text]"}] }' ``` ```bash CLI # Para aplicações sensíveis ao tempo, use o Claude Haiku 5.5 com esforço baixo ant messages create \ --model claude-haiku-5-5 \ --max-tokens 1024 \ --output-config '{effort: low}' \ --message '{"role": "user", "content": "Summarize this customer feedback in 2 sentences: [feedback text]"}' ``` ```python Python client = anthropic.Anthropic() # Para aplicações sensíveis ao tempo, use o Claude Haiku 5.5 com esforço baixo message = client.messages.create( model="claude-haiku-5-5", max_tokens=1024, output_config={"effort": "low"}, messages=[ { "role": "user", "content": "Summarize this customer feedback in 2 sentences: [feedback text]", } ], ) print(next(block.text for block in message.content if block.type == "text")) ``` ```typescript TypeScript const client = new Anthropic(); // Para aplicações sensíveis ao tempo, use o Claude Haiku 5.5 com esforço baixo const message = await client.messages.create({ model: "claude-haiku-5-5", max_tokens: 1024, output_config: { effort: "low" }, messages: [ { role: "user", content: "Summarize this customer feedback in 2 sentences: [feedback text]" } ] }); const textBlock = message.content.find((block) => block.type === "text"); console.log(textBlock?.text); ``` ```csharp C# AnthropicClient client = new(); // Para aplicações sensíveis ao tempo, use Claude Haiku 5.5 com esforço baixo var parameters = new MessageCreateParams { Model = Model.ClaudeHaiku5_5, MaxTokens = 1024, OutputConfig = new() { Effort = Effort.Low }, Messages = [ new() { Role = Role.User, Content = "Summarize this customer feedback in 2 sentences: [feedback text]" } ] }; var message = await client.Messages.Create(parameters); foreach (var block in message.Content) { if (block.TryPickText(out var textBlock)) { Console.WriteLine(textBlock.Text); break; } } ``` ```go Go client := anthropic.NewClient() // Para aplicações sensíveis ao tempo, use o Claude Haiku 5.5 com esforço baixo message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeHaiku5_5, MaxTokens: 1024, OutputConfig: anthropic.OutputConfigParam{ Effort: anthropic.OutputConfigEffortLow, }, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize this customer feedback in 2 sentences: [feedback text]")), }, }) if err != nil { log.Fatal(err) } for _, block := range message.Content { if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok { fmt.Println(textBlock.Text) break } } ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); // Para aplicações sensíveis ao tempo, use Claude Haiku 5.5 com esforço baixo MessageCreateParams params = MessageCreateParams.builder() .model(Model.CLAUDE_HAIKU_5_5) .maxTokens(1024L) .outputConfig(OutputConfig.builder() .effort(OutputConfig.Effort.LOW) .build()) .addUserMessage("Summarize this customer feedback in 2 sentences: [feedback text]") .build(); Message message = client.messages().create(params); IO.println(message.content().stream() .flatMap(block -> block.text().stream()) .map(TextBlock::text) .findFirst() .orElse("")); ``` ```php PHP $client = new Client(); // Para aplicações sensíveis ao tempo, use o Claude Haiku 5.5 com esforço baixo $message = $client->messages->create( maxTokens: 1024, messages: [['role' => 'user', 'content' => 'Summarize this customer feedback in 2 sentences: [feedback text]']], model: 'claude-haiku-5-5', outputConfig: ['effort' => 'low'], ); foreach ($message->content as $block) { if ($block->type === 'text') { echo $block->text; break; } } ``` ```ruby Ruby client = Anthropic::Client.new # Para aplicações sensíveis ao tempo, use o Claude Haiku 5.5 com esforço baixo message = client.messages.create( model: "claude-haiku-5-5", max_tokens: 1024, output_config: { effort: :low }, messages: [{ role: "user", content: "Summarize this customer feedback in 2 sentences: [feedback text]" }] ) puts message.content.find { |block| block.type == :text }&.text ``` Para mais detalhes sobre as métricas dos modelos, consulte a página de [visão geral dos modelos](https://platform.claude.com/docs/pt-BR/models/overview). ### 2. Otimize o comprimento do prompt e da saída Minimize o número de tokens tanto no seu prompt de entrada quanto na saída esperada, mantendo ainda um alto desempenho. Quanto menos tokens o modelo tiver que processar e gerar, mais rápida será a resposta. Aqui estão algumas dicas para ajudar você a otimizar seus prompts e saídas: * **Seja claro, mas conciso:** Procure transmitir sua intenção de forma clara e concisa no prompt. Evite detalhes desnecessários ou informações redundantes, tendo em mente que o [Claude não tem contexto](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/claude-prompting-best-practices#be-clear-and-direct) sobre o seu caso de uso e pode não fazer os saltos lógicos pretendidos se as instruções não forem claras. * **Peça respostas mais curtas:** Peça diretamente ao Claude que seja conciso. Se o Claude estiver gerando saídas mais longas do que o desejado, peça ao Claude para [conter sua prolixidade](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-engineering/claude-prompting-best-practices#be-clear-and-direct). Devido à forma como os "large language models" (modelos de linguagem grandes), ou LLMs, contam [tokens](https://platform.claude.com/docs/pt-BR/about-claude/glossary#tokens) em vez de palavras, pedir uma contagem exata de palavras ou um limite de contagem de palavras não é uma estratégia tão eficaz quanto pedir limites de contagem de parágrafos ou frases. * **Defina limites de saída apropriados:** Use o parâmetro `max_tokens` para definir um limite rígido para o comprimento máximo da resposta gerada. Isso impede que o Claude gere saídas excessivamente longas. Quando a resposta atinge `max_tokens` tokens, ela será cortada, talvez no meio de uma frase ou de uma palavra; portanto, essa é uma técnica grosseira que pode exigir pós-processamento e geralmente é mais apropriada para respostas de múltipla escolha ou respostas curtas em que a resposta vem logo no início. * **Experimente com a temperatura:** O [parâmetro](https://platform.claude.com/docs/pt-BR/api/messages/create) `temperature` controla a aleatoriedade da saída. Valores mais baixos (por exemplo, 0,2) às vezes podem levar a respostas mais focadas e mais curtas, enquanto valores mais altos (por exemplo, 0,8) podem resultar em saídas mais diversas, mas potencialmente mais longas. Os modelos Claude 4.7 e posteriores e o Claude Mythos Preview aceitam apenas o valor padrão de `temperature` e retornam um erro 400 para qualquer outro valor; portanto, nesses modelos, reduza o [esforço](https://platform.claude.com/docs/pt-BR/build-with-claude/effort) em vez disso. Encontrar o equilíbrio certo entre clareza do prompt, qualidade da saída e contagem de tokens pode exigir alguma experimentação. ### 3. Use streaming de respostas O "streaming" (envio contínuo) é um recurso que permite que o modelo comece a enviar sua resposta antes que a saída completa esteja concluída. Isso pode melhorar significativamente a responsividade percebida da sua aplicação, pois os usuários podem ver a saída do modelo em tempo real. Com o streaming ativado, você pode processar a saída do modelo à medida que ela chega, atualizando sua interface de usuário ou executando outras tarefas em paralelo. Visite [Streaming de mensagens](https://platform.claude.com/docs/pt-BR/build-with-claude/streaming) para saber como você pode implementar streaming para o seu caso de uso. *** ## Próximos passos Minimize alucinações nas saídas do Claude permitindo incerteza, fundamentando respostas em citações diretas e verificando afirmações com citações. Faça streaming das respostas da Messages API de forma incremental com server-sent events, incluindo deltas de texto, uso de ferramentas e pensamento estendido.