> ## Documentation Index
> Fetch the complete documentation index at: https://docs.infercom.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Performance optimieren und Latenz reduzieren

> Latenz minimieren und Durchsatz maximieren auf Infercom. Connection Pooling, Streaming und Best Practices für performante Inferenz.

Diese Anleitung beschreibt Best Practices zur Minimierung der Latenz und Maximierung des Durchsatzes bei der Nutzung des Infercom Inference Service.

## Connection Pooling

Die wirkungsvollste Optimierung ist die Wiederverwendung Ihrer Client-Instanz über mehrere Anfragen hinweg. Dies ermöglicht HTTP-Connection-Pooling, das den TCP- und TLS-Handshake bei nachfolgenden Aufrufen überspringt.

<Tip>
  Die Wiederverwendung Ihrer Client-Instanz kann den Netzwerk-Overhead bei aufeinanderfolgenden Anfragen um bis zu 50% reduzieren.
</Tip>

### Funktionsweise

Wenn Sie für jede Anfrage einen neuen Client erstellen, muss jeder Aufruf eine neue TCP-Verbindung aufbauen und TLS aushandeln — das verursacht je nach Standort und Netzwerkbedingungen mehrere zehn Millisekunden zusätzlichen Overhead. Bei Wiederverwendung des Clients bleibt die bestehende Verbindung offen und nachfolgende Anfragen überspringen diesen Aufbau.

### Empfohlenes Muster

<CodeGroup>
  ```python Python (SambaNova SDK) theme={null}
  from sambanova import SambaNova

  # Client einmalig erstellen
  client = SambaNova(
      base_url="https://api.infercom.ai/v1",
      api_key="your-infercom-api-key"
  )

  # Für alle Anfragen wiederverwenden
  response_1 = client.chat.completions.create(
      model="MiniMax-M2.5",
      messages=[{"role": "user", "content": "Hallo"}]
  )

  response_2 = client.chat.completions.create(
      model="MiniMax-M2.5",
      messages=[{"role": "user", "content": "Folgefrage"}]
  )
  ```

  ```python Python (OpenAI) theme={null}
  from openai import OpenAI

  # Client einmalig erstellen
  client = OpenAI(
      base_url="https://api.infercom.ai/v1",
      api_key="your-infercom-api-key"
  )

  # Für alle Anfragen wiederverwenden
  response_1 = client.chat.completions.create(
      model="MiniMax-M2.5",
      messages=[{"role": "user", "content": "Hallo"}]
  )

  response_2 = client.chat.completions.create(
      model="MiniMax-M2.5",
      messages=[{"role": "user", "content": "Folgefrage"}]
  )
  ```

  ```javascript Javascript (SambaNova SDK) theme={null}
  import SambaNova from "sambanova";

  // Client einmalig erstellen
  const client = new SambaNova({
    baseURL: "https://api.infercom.ai/v1",
    apiKey: "your-infercom-api-key",
  });

  // Für alle Anfragen wiederverwenden
  const response1 = await client.chat.completions.create({
    model: "MiniMax-M2.5",
    messages: [{ role: "user", content: "Hallo" }],
  });

  const response2 = await client.chat.completions.create({
    model: "MiniMax-M2.5",
    messages: [{ role: "user", content: "Folgefrage" }],
  });
  ```
</CodeGroup>

<Warning>
  Vermeiden Sie es, einen neuen Client in Schleifen oder Request-Handlern zu erstellen. Dies erzwingt einen neuen TCP+TLS-Handshake bei jedem Aufruf.
</Warning>

```python theme={null}
# Dieses Muster vermeiden
for message in messages:
    client = SambaNova(base_url="https://api.infercom.ai/v1", api_key="...")
    response = client.chat.completions.create(...)  # Neue Verbindung bei jedem Aufruf
```

Sowohl das SambaNova SDK als auch das OpenAI SDK verwenden [httpx](https://www.python-httpx.org/advanced/clients/) unter der Haube, das automatisch einen Connection Pool verwaltet, wenn Sie den Client wiederverwenden. Der Standard-Pool hält bis zu 20 Keep-Alive-Verbindungen.

## Performance-Metadaten in der Antwort

Jede API-Antwort enthält detaillierte Performance-Metriken im `usage`-Objekt. Nutzen Sie diese, um Ihre Anwendung zu messen und zu optimieren.

### Verfügbare Metriken

| Feld                                    | Beschreibung                                          |
| --------------------------------------- | ----------------------------------------------------- |
| `time_to_first_token`                   | Serverseitige Zeit bis zum ersten Token (Sekunden)    |
| `total_latency`                         | Serverseitige Gesamtverarbeitungszeit (Sekunden)      |
| `completion_tokens_after_first_per_sec` | Ausgabe-Durchsatz nach dem ersten Token (Tokens/Sek.) |
| `completion_tokens_per_sec`             | Gesamter Ausgabe-Durchsatz inkl. TTFT (Tokens/Sek.)   |
| `total_tokens_per_sec`                  | Kombinierter Ein-/Ausgabe-Durchsatz (Tokens/Sek.)     |
| `prompt_tokens`                         | Anzahl verarbeiteter Eingabe-Tokens                   |
| `completion_tokens`                     | Anzahl generierter Ausgabe-Tokens                     |

### Beispielantwort

```json theme={null}
{
  "usage": {
    "prompt_tokens": 37,
    "completion_tokens": 9,
    "total_tokens": 46,
    "time_to_first_token": 0.092,
    "total_latency": 0.126,
    "completion_tokens_after_first_per_sec": 232.25,
    "completion_tokens_per_sec": 71.16,
    "total_tokens_per_sec": 363.71
  }
}
```

### Client- vs. Server-Latenz messen

Um zu verstehen, wie viel Zeit im Netzwerk vs. bei der Inferenz verbracht wird, vergleichen Sie Ihre clientseitige Gesamtzeit mit der serverseitig gemeldeten `total_latency`:

```python theme={null}
import time
from openai import OpenAI

client = OpenAI(
    base_url="https://api.infercom.ai/v1",
    api_key="your-infercom-api-key"
)

start = time.perf_counter()
response = client.chat.completions.create(
    model="MiniMax-M2.5",
    messages=[{"role": "user", "content": "Hallo"}],
    max_tokens=50
)
client_elapsed = time.perf_counter() - start

server_latency = response.usage.total_latency  # Sekunden
network_overhead = client_elapsed - server_latency

print(f"Server-Inferenz:  {server_latency*1000:.0f}ms")
print(f"Client-Gesamt:    {client_elapsed*1000:.0f}ms")
print(f"Netzwerk-Overhead: {network_overhead*1000:.0f}ms")
```

Ein typischer Netzwerk-Overhead innerhalb der EU beträgt 50–150ms, abhängig von Ihrer Nähe zum Rechenzentrum und ob Connection Pooling aktiv ist.

## Streaming für interaktive Anwendungen

Für Chatbots und interaktive Anwendungsfälle liefert Streaming das erste Token schneller an den Benutzer und sorgt für ein reaktionsschnelleres Erlebnis.

```python theme={null}
from sambanova import SambaNova

client = SambaNova(
    base_url="https://api.infercom.ai/v1",
    api_key="your-infercom-api-key"
)

stream = client.chat.completions.create(
    model="MiniMax-M2.5",
    messages=[{"role": "user", "content": "Erkläre Quantencomputing"}],
    stream=True
)

for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
```

Streaming reduziert nicht die gesamte Verarbeitungszeit, verbessert aber die wahrgenommene Latenz erheblich, da die Ausgabe während der Generierung geliefert wird.

## Best Practices für Performance

| Praxis                            | Auswirkung                                    | Details                                                                                                                               |
| --------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| Client-Instanzen wiederverwenden  | Vermeidet wiederholten TCP/TLS-Handshake      | Spart mehrere zehn ms pro Anfrage                                                                                                     |
| Streaming für UI verwenden        | Schnellere wahrgenommene Antwort              | Erstes Token kommt früher an                                                                                                          |
| `max_tokens` angemessen setzen    | Vermeidet unnötige Generierung                | Nicht auf Standard belassen, wenn kurze Antworten benötigt werden                                                                     |
| Reasoning-Modell im Einsatz?      | Vermeidet abgeschnittene oder leere Antworten | Budgetieren Sie `max_tokens` für die Gedankenkette - siehe [Reasoning-Leitfaden](/de/build/reasoning#token-budget-f%C3%BCr-reasoning) |
| Passendes Modell wählen           | Variiert                                      | Kleinere Modelle haben niedrigere TTFT und höheren Durchsatz                                                                          |
| Nahe am EU-Rechenzentrum deployen | Kürzere Netzwerk-Roundtrip-Zeit               | Infercom läuft in Deutschland (Equinix München)                                                                                       |