Zum Hauptinhalt springen
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.
Die Wiederverwendung Ihrer Client-Instanz kann den Netzwerk-Overhead bei aufeinanderfolgenden Anfragen um bis zu 50% reduzieren.

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

response_2 = client.chat.completions.create(
    model="MiniMax-M2.5",
    messages=[{"role": "user", "content": "Folgefrage"}]
)
Vermeiden Sie es, einen neuen Client in Schleifen oder Request-Handlern zu erstellen. Dies erzwingt einen neuen TCP+TLS-Handshake bei jedem Aufruf.
# 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

FeldBeschreibung
time_to_first_tokenServerseitige Zeit bis zum ersten Token (Sekunden)
total_latencyServerseitige Gesamtverarbeitungszeit (Sekunden)
completion_tokens_after_first_per_secAusgabe-Durchsatz nach dem ersten Token (Tokens/Sek.)
completion_tokens_per_secGesamter Ausgabe-Durchsatz inkl. TTFT (Tokens/Sek.)
total_tokens_per_secKombinierter Ein-/Ausgabe-Durchsatz (Tokens/Sek.)
prompt_tokensAnzahl verarbeiteter Eingabe-Tokens
completion_tokensAnzahl 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.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. 
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

PraxisAuswirkungDetails
Client-Instanzen wiederverwendenVermeidet wiederholten TCP/TLS-HandshakeSpart mehrere zehn ms pro Anfrage
Streaming für UI verwendenSchnellere wahrgenommene AntwortErstes Token kommt früher an
max_tokens angemessen setzenVermeidet unnötige GenerierungNicht auf Standard belassen, wenn kurze Antworten benötigt werden
Passendes Modell wählenVariiertKleinere Modelle haben niedrigere TTFT und höheren Durchsatz
Nahe am EU-Rechenzentrum deployenKürzere Netzwerk-Roundtrip-ZeitInfercom läuft in Deutschland (Equinix München)