Zum Hauptinhalt springen
Middleware ist das Muster, jede LLM-Antwort abzufangen und einen RAIL-Score anzuhängen, bevor sie den Rest Ihrer Anwendung erreicht. Sie ersetzen Ihren LLM-Client durch einen RAIL-Wrapper. Der Wrapper ruft das LLM auf, bewertet die Antwort und gibt sowohl den Inhalt als auch die Scores in einem einzigen Objekt zurück.
Python SDK: Integrationsreferenz | API: Evaluierungsendpunkt

​
Das Problem, das es löst

Ohne Middleware bedeutet das Hinzufügen von verantwortungsbewussten KI-Überprüfungen zu jedem LLM-Aufruf, dass Sie Evaluierungscode an jedem Ort schreiben müssen, an dem Sie das LLM aufrufen, was zu doppelter Logik, Risiken von Abdeckungsproblemen und einer Unordnung in Ihrem Anwendungscode führt: 
# Eval-Code überall verstreut
async def get_response(user_message):
    response = await openai_client.chat.completions.create(
        model="gpt-4o", messages=[{"role": "user", "content": user_message}]
    )
    content = response.choices[0].message.content

    # Muss sich erinnern, in jeder Funktion zu evaluieren
    score = rail_client.eval(content=content, mode="basic")
    if score.rail_score.score < 7.0:
        raise ValueError("Antwort unterhalb der Qualitätsgrenze")

    return content

​
Wie es funktioniert

Wenn Sie eine Methode auf dem RAIL-Wrapper aufrufen, passieren drei Dinge transparent:
  1. Ihre Nachrichten werden als normaler API-Aufruf an die zugrunde liegende LLM-API weitergeleitet.
  2. Die LLM-Antwort wird im von Ihnen konfigurierten Modus an den RAIL-Evaluierungsendpunkt übermittelt.
  3. Ein umschlossenes Antwortobjekt wird zurückgegeben, das den ursprünglichen Inhalt, den RAIL-Score, die Scores pro Dimension und einen threshold_met-Boolean enthält, alles in einem Rückgabewert.

​
Unterstützte Anbieter

WrapperWrapsPythonJavaScript
RAILOpenAIOpenAI-Chat-VervollständigungenJaJa
RAILGeminiGoogle GeminiJaJa
RAILAnthropicAnthropic ClaudeJaJa
RAILLangChainJedes LangChain LLMJa—
Benutzerdefinierter WrapperJedes HTTP-basiertes LLMJaJa

​
Beobachtungsmodus vs. Durchsetzungsmodus

Bewerten Sie jede Antwort, blockieren Sie niemals. Verwenden Sie dies, um die Qualität zu messen, ohne den Antwortfluss zu unterbrechen.
client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="...",
    eval_mode="basic",
    # Kein Schwellenwert — gibt immer die Antwort zurück
)

response = await client.chat(messages=[...])
print(response.content)        # Die Antwort des LLM
print(response.rail_score)     # RAIL-Score (immer vorhanden)
print(response.threshold_met)  # None — kein Schwellenwert konfiguriert

​
Schreiben von benutzerdefinierter Middleware

Wenn Sie einen LLM-Anbieter ohne integrierten Wrapper verwenden, erstellen Sie Ihre eigene Middleware mit dem Kernaufruf eval(): 
from rail_score_sdk import RailScoreClient

rail = RailScoreClient(api_key="...")

async def rail_middleware(llm_call, messages, threshold=7.0):
    """Generische RAIL-Middleware für jeden asynchronen LLM-Aufruf."""
    content = await llm_call(messages)

    result = rail.eval(content=content, mode="basic")

    if result.rail_score.score < threshold:
        raise ValueError(
            f"Antwort bewertet mit {result.rail_score.score:.1f} — unterhalb des Schwellenwerts {threshold}. "
            f"Fehlgeschlagen: {[d for d, s in result.dimension_scores.items() if s.score < threshold]}"
        )

    return content, result

# Verwenden mit jedem LLM:
content, score = await rail_middleware(my_llm_call, messages, threshold=7.5)

​
Was kommt als Nächstes

Konzepte: Policy Engine

Deklarative Regeln, um auf Scores über eine Sitzung zu reagieren.

Python: Integrationen

Vollständige Dokumentation und Optionen für Anbieter-Wrapper.

JavaScript: Anbieter

TypeScript-Wrapper für OpenAI, Gemini, Anthropic.

Python: Middleware SDK

RAILMiddleware - umschließen Sie jede LLM-Funktion.