Funktionen

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.

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

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.7",
    messages=[{"role": "user", "content": "Hallo"}]
)

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

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.7",
    messages=[{"role": "user", "content": "Hallo"}]
)

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

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.7",
  messages: [{ role: "user", content: "Hallo" }],
});

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

# 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 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

{
  "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:

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.7",
    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.

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.7",
    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
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)