Middleware

Middleware ist das Muster, jede KI-Antwort abzufangen und einen RAIL-Score anzuhängen, bevor sie den Rest Ihrer Anwendung erreicht. Sie ersetzen Ihren Modell-Client durch einen RAIL-Wrapper. Der Wrapper ruft das Modell auf, bewertet die Antwort und gibt sowohl den Inhalt als auch die Scores in einem einzigen Objekt zurück.

Python SDK: Integrationsreferenz | API: Bewertungs-Endpunkt

Das Problem, das es löst

Ohne Middleware bedeutet das Hinzufügen von Prüfungen für verantwortungsvolle KI zu jedem Modellaufruf, dass Sie Bewertungscode an jeder Stelle schreiben, an der Sie das Modell aufrufen, Logik duplizieren, Abdeckungslücken riskieren und Ihren Anwendungscode überfrachten:

# Eval code scattered everywhere
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

    # Must remember to eval in every function
    score = rail_client.eval(content=content, mode="basic")
    if score.rail_score.score < 7.0:
        raise ValueError("Response below quality threshold")

    return content

# Scoring is automatic - set up once, forget about it
from rail_score_sdk.integrations import RAILOpenAI

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="YOUR_RAIL_API_KEY",
    eval_mode="basic",
    threshold=7.0,
)

async def get_response(user_message):
    response = await client.chat(messages=[{"role": "user", "content": user_message}])
    return response.content  # .rail_score and .threshold_met are also available

Funktionsweise

Wenn Sie eine Methode auf dem RAIL-Wrapper aufrufen, geschehen drei Dinge transparent:

Ihre Nachrichten werden als normaler API-Aufruf an die zugrunde liegende Modell-API weitergeleitet.
Die Antwort des Modells wird im konfigurierten Modus an den RAIL-Bewertungs-Endpunkt übermittelt.
Ein umhülltes 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 einzigen Rückgabewert.

Unterstützte Anbieter

Wrapper	Umhüllt	Python	JavaScript
`RAILOpenAI`	OpenAI Chat Completions	Ja	Ja
`RAILGemini`	Google Gemini	Ja	Ja
`RAILAnthropic`	Anthropic Claude	Ja	Ja
`RAILLangChain`	Jedes LangChain-Modell	Ja	—
Custom wrapper	Jedes HTTP-basierte Modell	Ja	Ja

Beobachtungsmodus vs. Durchsetzungsmodus

Nur beobachten
Schwellenwert durchsetzen
Automatisch neu generieren

Bewerten Sie jede Antwort, blockieren Sie nie. Verwenden Sie dies, um Qualität zu messen, ohne den Antwortfluss zu unterbrechen.

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="...",
    eval_mode="basic",
    # No threshold — always returns response
)

response = await client.chat(messages=[...])
print(response.content)        # The model's response
print(response.rail_score)     # RAIL score (always present)
print(response.threshold_met)  # None — no threshold configured

Lösen Sie ThresholdError aus, wenn eine Antwort die Vorgabe nicht erfüllt.

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="...",
    eval_mode="basic",
    threshold=7.0,
)

try:
    response = await client.chat(messages=[...])
    return response.content
except ThresholdError as e:
    # e.rail_score and e.failed_dimensions are available
    return fallback_response()

Lösen Sie automatisch die sichere Regeneration aus, wenn eine Antwort unter den Schwellenwert fällt.

client = RAILOpenAI(
    openai_api_key="...",
    rail_api_key="...",
    eval_mode="basic",
    threshold=7.0,
    on_fail="regenerate",
    max_iterations=3,
)

# Returns the best content — original or regenerated
response = await client.chat(messages=[...])
print(response.content)
print(response.iterations_taken)  # 1 if original passed

Eigene Middleware schreiben

Wenn Sie einen Modellanbieter ohne integrierten Wrapper verwenden, bauen Sie Ihre eigene Middleware mit dem zentralen eval()-Aufruf:

from rail_score_sdk import RailScoreClient

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

async def rail_middleware(llm_call, messages, threshold=7.0):
    """Generic RAIL middleware for any async LLM call."""
    content = await llm_call(messages)

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

    if result.rail_score.score < threshold:
        raise ValueError(
            f"Response scored {result.rail_score.score:.1f} — below threshold {threshold}. "
            f"Failed: {[d for d, s in result.dimension_scores.items() if s.score < threshold]}"
        )

    return content, result

# Use with any LLM:
content, score = await rail_middleware(my_llm_call, messages, threshold=7.5)

Wie geht es weiter

Konzepte: Richtlinien-Engine

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

Python: Integrationen

Vollständige Dokumentation und Optionen der Anbieter-Wrapper.

JavaScript: Anbieter

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

Python: Middleware SDK

RAILMiddleware - jede Modellfunktion umhüllen.

Erste Schritte

Kernkonzepte

Governance

Spezialisierte Prüfungen

Das Problem, das es löst

Funktionsweise

Unterstützte Anbieter

Beobachtungsmodus vs. Durchsetzungsmodus

Eigene Middleware schreiben

Wie geht es weiter

Konzepte: Richtlinien-Engine

Python: Integrationen

JavaScript: Anbieter

Python: Middleware SDK

​Das Problem, das es löst

​Funktionsweise

​Unterstützte Anbieter

​Beobachtungsmodus vs. Durchsetzungsmodus

​Eigene Middleware schreiben

​Wie geht es weiter

Konzepte: Richtlinien-Engine

Python: Integrationen

JavaScript: Anbieter

Python: Middleware SDK

Das Problem, das es löst

Funktionsweise

Unterstützte Anbieter

Beobachtungsmodus vs. Durchsetzungsmodus

Eigene Middleware schreiben

Wie geht es weiter