Integrations

The Switch Trust Python SDK supports five LLM integrations. Standard LLM clients use switch_trust.wrap(), while Google ADK uses a dedicated plugin.

Integration	Method
OpenAI	`switch_trust.wrap()`
Anthropic	`switch_trust.wrap()`
Google GenAI	`switch_trust.wrap()` (requires `llm_api_key`)
LangChain (`ChatOpenAI`, `ChatAnthropic`, `ChatGoogleGenerativeAI`)	`switch_trust.wrap()`
Google ADK	`ADKGuardrailsPlugin`

OpenAI

Wrap an openai.OpenAI() client to route completions through the guardrails proxy.

import openai
import switch_trust

client = openai.OpenAI(api_key="your-openai-api-key")
client = switch_trust.wrap(
    client,
    gateway_url="https://api.switchagents.ai",
    api_key="your-switch-trust-api-key",
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)

After wrapping, use the client exactly as before — the SDK redirects traffic transparently.

Anthropic

Wrap an anthropic.Anthropic() client the same way.

import anthropic
import switch_trust

client = anthropic.Anthropic(api_key="your-anthropic-api-key")
client = switch_trust.wrap(
    client,
    gateway_url="https://api.switchagents.ai",
    api_key="your-switch-trust-api-key",
)

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)

Google GenAI

Google GenAI clients don’t expose api_key as an attribute, so llm_api_key can’t be auto-extracted. To forward a key, pass it explicitly:

import google.genai
import switch_trust

client = google.genai.Client(api_key="your-gemini-api-key")
client = switch_trust.wrap(
    client,
    gateway_url="https://api.switchagents.ai",
    api_key="your-switch-trust-api-key",
    llm_api_key="your-gemini-api-key",  # optional: forwarded in place of the client's key
)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Hello",
)

The SDK automatically normalizes the gateway URL with a trailing slash for Google GenAI — do not add one yourself.

LangChain

switch_trust.wrap() auto-detects LangChain chat models, extracts the underlying SDK client, and applies guardrails routing. Supported models:

ChatOpenAI (from langchain-openai)
ChatAnthropic (from langchain-anthropic)
ChatGoogleGenerativeAI (from langchain-google-genai)

from langchain_openai import ChatOpenAI
import switch_trust

llm = ChatOpenAI(model="gpt-4o", api_key="your-openai-api-key")
llm = switch_trust.wrap(
    llm,
    gateway_url="https://api.switchagents.ai",
    api_key="your-switch-trust-api-key",
)

response = llm.invoke("Hello")

ChatAnthropic
ChatGoogleGenerativeAI

from langchain_anthropic import ChatAnthropic
import switch_trust

llm = ChatAnthropic(model="claude-sonnet-4-20250514", api_key="your-anthropic-api-key")
llm = switch_trust.wrap(
    llm,
    gateway_url="https://api.switchagents.ai",
    api_key="your-switch-trust-api-key",
)

response = llm.invoke("Hello")

from langchain_google_genai import ChatGoogleGenerativeAI
import switch_trust

llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash", google_api_key="your-gemini-api-key")
llm = switch_trust.wrap(
    llm,
    gateway_url="https://api.switchagents.ai",
    api_key="your-switch-trust-api-key",
)

response = llm.invoke("Hello")

For LangChain agents with deeper lifecycle integration (session tracking, agent identity headers), use LangChainGuardrailsMiddleware instead:

from switch_trust.plugins.langchain import LangChainGuardrailsMiddleware
from langchain.agents import create_agent

middleware = LangChainGuardrailsMiddleware()

agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[middleware],
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "Hello!"}]},
    config={"configurable": {"thread_id": "session-456"}},
)

See Usage for more details.

Google ADK

ADK agents lazily create their GenAI client at runtime, so switch_trust.wrap() cannot be used. Use ADKGuardrailsPlugin to configure guardrails routing at the agent level:

from switch_trust.plugins.adk import ADKGuardrailsPlugin
from google.adk.agents import LlmAgent

plugin = ADKGuardrailsPlugin(
    gateway_url="https://api.switchagents.ai",
    api_key="your-switch-trust-api-key",
    llm_api_key="your-gemini-api-key",
)

agent = LlmAgent(
    name="my_agent",
    model="gemini-2.5-flash",
    instruction="You are a helpful assistant.",
    tools=[...],
    generate_content_config=plugin.content_config,
    before_model_callback=plugin.before_model_callback,
    on_model_error_callback=plugin.on_model_error,
)

Set SWITCH_TRUST_GATEWAY_URL, SWITCH_TRUST_API_KEY, and SWITCH_TRUST_LLM_API_KEY as environment variables (or in a .env file), then create the plugin with no arguments: ADKGuardrailsPlugin().

The plugin handles three concerns:

Routing — content_config directs LLM traffic through the guardrails proxy
Identity — before_model_callback injects agent name, agent ID, and session ID headers on each call
Error handling — on_model_error converts guardrails blocks into an LlmResponse the agent can handle gracefully

See Usage for more details on the plugin’s behavior and configuration.

Version compatibility

Pin your provider SDK to the tested ranges to avoid breakage from private API changes:

Provider SDK	Supported versions
`openai`	`>=2.40.0, <3`
`anthropic`	`>=0.105.2, <1`
`google-genai`	`>=2.7, <3`
`google-adk`	`>=2.1, <3`
`langchain-openai`	`>=1.2, <2`
`langchain-anthropic`	`>=1.4, <2`
`langchain-google-genai`	`>=4.2, <5`

The SDK logs a warning if your installed provider version is outside these ranges.

Known limitations

Private attribute mutation — switch_trust.wrap() modifies internal attributes of LLM SDK clients (_base_url, _custom_headers, _api_client._http_options) to redirect traffic. These are not part of the providers’ public APIs and may change without notice.
Async clients — AsyncOpenAI and AsyncAnthropic are not supported. Use sync clients only.
Google GenAI api_key — Google GenAI clients don’t expose api_key as an attribute, so forward_llm_key=True can’t take the key from the client. To forward a key, pass llm_api_key or set SWITCH_TRUST_LLM_API_KEY. Otherwise, the request uses the client’s own key.
Multiple provider keys in environment — If multiple provider API keys are set (OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY), auto-detection fails. Pass provider explicitly to switch_trust.init().

Overview

Get started

Agents and assets

Discovery

Evaluation

Monitor your agents

Set guardrails

Switch ROI

Optimize with the MCP server

Manage your organization

SDK

Rules

Resources

OpenAI

Anthropic

Google GenAI

LangChain

Google ADK

Version compatibility

Known limitations

Next steps

Usage

Configuration