---
title: Reducir la latencia
url: https://platform.claude.com/docs/es/test-and-evaluate/strengthen-guardrails/reduce-latency
description: Reduce la latencia de respuesta de Claude eligiendo un modelo más rápido como Claude Haiku 5.5, recortando los tokens del prompt y de la salida, y usando streaming en las respuestas.
---
La "latency" (latencia) se refiere al tiempo que tarda el modelo en procesar un prompt y generar una salida. La latencia puede verse influida por varios factores, como el tamaño del modelo, la complejidad del prompt y la infraestructura subyacente que soporta el modelo y el punto de interacción.
Siempre es mejor diseñar primero un prompt que funcione bien sin restricciones de modelo o de prompt, y luego probar estrategias de reducción de latencia. Intentar reducir la latencia prematuramente podría impedirte descubrir cómo se ve el máximo rendimiento.
***
## Cómo medir la latencia
Al hablar de latencia, es posible que te encuentres con varios términos y mediciones:
* **Latencia base:** Es el tiempo que tarda el modelo en procesar el prompt y generar la respuesta, sin considerar los tokens de entrada y salida por segundo. Proporciona una idea general de la velocidad del modelo.
* **"Time to first token" (tiempo hasta el primer token), o TTFT:** Esta métrica mide el tiempo que tarda el modelo en generar el primer token de la respuesta, desde el momento en que se envió el prompt. Es particularmente relevante cuando usas streaming (más sobre esto más adelante) y quieres ofrecer una experiencia ágil a tus usuarios.
Para una comprensión más profunda de estos términos, consulta el [glosario](https://platform.claude.com/docs/es/about-claude/glossary).
***
## Cómo reducir la latencia
### 1. Elige el modelo adecuado
Una de las formas más directas de reducir la latencia es seleccionar el modelo apropiado para tu caso de uso. Anthropic ofrece una [gama de modelos](https://platform.claude.com/docs/es/models/overview) con diferentes capacidades y características de rendimiento. Considera tus requisitos específicos y elige el modelo que mejor se adapte a tus necesidades en términos de velocidad y calidad de salida.
Para aplicaciones en las que la velocidad es crítica, **Claude Haiku 5.5** ofrece los tiempos de respuesta más rápidos manteniendo una alta inteligencia. El [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) es su principal control de velocidad y costo. Consulta [Usa el esfuerzo para controlar el pensamiento](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking). El siguiente ejemplo lo ejecuta con esfuerzo `low`, el nivel más económico y rápido, y deja espacio en `max_tokens` para el pensamiento:
```bash cURL
# Para aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
$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 aplicaciones sensibles al tiempo, usa Claude Haiku 5.5 con esfuerzo bajo
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 más detalles sobre las métricas de los modelos, consulta la página de [descripción general de modelos](https://platform.claude.com/docs/es/models/overview).
### 2. Optimiza la longitud del prompt y de la salida
Minimiza la cantidad de tokens tanto en tu prompt de entrada como en la salida esperada, manteniendo al mismo tiempo un alto rendimiento. Cuantos menos tokens tenga que procesar y generar el modelo, más rápida será la respuesta.
Aquí tienes algunos consejos para ayudarte a optimizar tus prompts y salidas:
* **Sé claro pero conciso:** Procura transmitir tu intención de forma clara y concisa en el prompt. Evita detalles innecesarios o información redundante, teniendo en cuenta que [Claude carece de contexto](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices#be-clear-and-direct) sobre tu caso de uso y podría no hacer los saltos lógicos previstos si las instrucciones no son claras.
* **Pide respuestas más cortas:** Pídele directamente a Claude que sea conciso. Si Claude está generando una longitud no deseada, pídele a Claude que [modere su locuacidad](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices#be-clear-and-direct).
Debido a que los LLMs cuentan
[tokens](https://platform.claude.com/docs/es/about-claude/glossary#tokens)
en lugar de palabras, pedir un número exacto de palabras o un límite de palabras no es una estrategia tan efectiva como pedir límites en la cantidad de párrafos u oraciones.
* **Establece límites de salida apropiados:** Usa el parámetro `max_tokens` para establecer un límite estricto en la longitud máxima de la respuesta generada. Esto evita que Claude genere salidas excesivamente largas.
Cuando la respuesta alcanza
`max_tokens`
tokens, la respuesta se cortará, quizás a mitad de una oración o de una palabra, por lo que esta es una técnica tosca que podría requerir posprocesamiento y suele ser más apropiada para respuestas de opción múltiple o de respuesta corta donde la respuesta aparece justo al principio.
* **Experimenta con la temperatura:** El [parámetro](https://platform.claude.com/docs/es/api/messages/create) `temperature` controla la aleatoriedad de la salida. Los valores más bajos (por ejemplo, 0.2) a veces pueden dar lugar a respuestas más enfocadas y cortas, mientras que los valores más altos (por ejemplo, 0.8) podrían producir salidas más diversas pero potencialmente más largas. Los modelos Claude 4.7 y posteriores y Claude Mythos Preview solo aceptan el valor predeterminado de `temperature` y devuelven un error 400 para cualquier otro valor, así que en esos modelos reduce el [esfuerzo](https://platform.claude.com/docs/es/build-with-claude/effort) en su lugar.
Encontrar el equilibrio adecuado entre la claridad del prompt, la calidad de la salida y la cantidad de tokens podría requerir cierta experimentación.
### 3. Usa streaming en las respuestas
El "streaming" (streaming) es una funcionalidad que permite al modelo comenzar a enviar su respuesta antes de que la salida completa esté terminada. Esto puede mejorar significativamente la capacidad de respuesta percibida de tu aplicación, ya que los usuarios pueden ver la salida del modelo en tiempo real.
Con el streaming habilitado, puedes procesar la salida del modelo a medida que llega, actualizando tu interfaz de usuario o realizando otras tareas en paralelo.
Visita [Streaming de mensajes](https://platform.claude.com/docs/es/build-with-claude/streaming) para aprender cómo puedes implementar streaming para tu caso de uso.
***
## Próximos pasos
Minimiza las alucinaciones en las salidas de Claude permitiendo la incertidumbre, fundamentando las respuestas en citas directas y verificando las afirmaciones con citas.
Recibe las respuestas de la Messages API de forma incremental mediante eventos enviados por el servidor, incluyendo deltas de texto, uso de herramientas y pensamiento extendido.