Integrations

Meet your stack where it already runs.

The proxy is the simplest install, but it is not the only one. Runelm ships maintained adapters for the three most common ways teams already call LLMs — a gateway, a chain framework, and an agent runtime. Same nine-stage classification, same fail-closed routing, same bounded rehydration. Just wrapped in place.

Already have a stack

Drop into the gateway, the chain, or the agent.

You do not have to run the proxy. Runelm ships first-class adapters for LiteLLM, LangChain, and the OpenAI Agents SDK. Each one wraps the model in place — same pipeline, same fail-closed guarantee, zero change to the rest of your code.

Gateway guardrail

LiteLLM

Drop Runelm into an existing LiteLLM proxy as a CustomGuardrail. Every model behind the gateway is classified and pseudonymized pre-call, then rehydrated post-call — no application code changes.

# litellm proxy_config.yaml
guardrails:
  - guardrail_name: runelm
    litellm_params:
      guardrail: runelm.adapters.litellm.RunelmGuardrail
      mode: pre_and_post_call
      config_path: ./runelm.yaml

Chat-model wrapper

LangChain

Wrap any BaseChatModel. The protected model is a drop-in for the real one inside a prompt | model | parser chain — classification, pseudonymization, routing, and bounded rehydration wrap every invoke.

from langchain_openai import ChatOpenAI
from runelm.adapters.langchain import RunelmProtectedChatModel

model = RunelmProtectedChatModel(
    wrapped=ChatOpenAI(model="gpt-5"),
    config_path="runelm.yaml",
    session_id="conv-42",
)

chain = prompt | model | parser   # chain unchanged
chain.invoke({"question": user_input})

Agent model

OpenAI Agents SDK

Pass a protected Model into Agent(model=…). Every turn the agent takes is sanitized inline through the same pipeline — audit-first, block, sanitize, call, rehydrate, audit-post.

from agents import Agent, Runner
from runelm.adapters.openai_agents import RunelmProtectedAgentsModel

agent = Agent(
    name="analyst",
    model=RunelmProtectedAgentsModel(
        model="gpt-5",
        config_path="runelm.yaml",
    ),
)

Runner.run_sync(agent, user_input)  # each turn sanitized

All three adapters share one orchestrator — audit-first → block → sanitize → call wrapped model → rehydrate → audit-post — ordered so the protected path cannot be inverted to leak the original prompt.

Proxy or adapter?

The guarantee is identical either way. The choice is purely about how your code already calls the model.

Run the proxy

You want one chokepoint for everything, in any language.

The OpenAI- and Anthropic-compatible HTTP proxy is the headline install. Swap one base_url and every client — Python, TypeScript, Go, curl — flows through Runelm.

Use an adapter

You are already on LiteLLM, LangChain, or the Agents SDK.

Wrap the model in place. No extra process to run, no base_url to manage — the adapter carries the same classify → pseudonymize → route → rehydrate → audit pipeline inside your existing framework.

Integration guides

Each adapter has a full guide — configuration, streaming behavior, error handling, and how the fail-closed contract is preserved end-to-end.