Integrations

The Flint AI Python SDK supports five LLM integrations. Standard LLM clients use flintai.wrap(), while Google ADK uses a dedicated plugin.

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

OpenAI

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

import openai
import flintai

client = openai.OpenAI(api_key="your-openai-api-key")
client = flintai.wrap(
    client,
    gateway_url="https://app.flintai.dev",
    api_key="your-flintai-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 flintai

client = anthropic.Anthropic(api_key="your-anthropic-api-key")
client = flintai.wrap(
    client,
    gateway_url="https://app.flintai.dev",
    api_key="your-flintai-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. Pass it explicitly if you want to forward your key, or omit it to let the proxy use its own upstream credentials:

import google.genai
import flintai

client = google.genai.Client(api_key="your-gemini-api-key")
client = flintai.wrap(
    client,
    gateway_url="https://app.flintai.dev",
    api_key="your-flintai-api-key",
    llm_api_key="your-gemini-api-key",  # optional; omit to use proxy's own credentials
)

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

flintai.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 flintai

llm = ChatOpenAI(model="gpt-4o", api_key="your-openai-api-key")
llm = flintai.wrap(
    llm,
    gateway_url="https://app.flintai.dev",
    api_key="your-flintai-api-key",
)

response = llm.invoke("Hello")

ChatAnthropic
ChatGoogleGenerativeAI

from langchain_anthropic import ChatAnthropic
import flintai

llm = ChatAnthropic(model="claude-sonnet-4-20250514", api_key="your-anthropic-api-key")
llm = flintai.wrap(
    llm,
    gateway_url="https://app.flintai.dev",
    api_key="your-flintai-api-key",
)

response = llm.invoke("Hello")

from langchain_google_genai import ChatGoogleGenerativeAI
import flintai

llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash", google_api_key="your-gemini-api-key")
llm = flintai.wrap(
    llm,
    gateway_url="https://app.flintai.dev",
    api_key="your-flintai-api-key",
)

response = llm.invoke("Hello")

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

from flintai.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 flintai.wrap() cannot be used. Use ADKGuardrailsPlugin to configure guardrails routing at the agent level:

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

plugin = ADKGuardrailsPlugin(
    gateway_url="https://app.flintai.dev",
    api_key="your-flintai-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 FLINTAI_GATEWAY_URL, FLINTAI_API_KEY, and FLINTAI_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 — flintai.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 llm_api_key can’t be auto-extracted. Pass it explicitly to forward your key, or omit it to use the proxy’s own credentials.
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 flintai.init().

Overview

Getting Started

Python SDK

Rules Reference

Resources

OpenAI

Anthropic

Google GenAI

LangChain

Google ADK

Version compatibility

Known limitations

Next steps

Usage

Configuration

​OpenAI

​Anthropic

​Google GenAI

​LangChain

​Google ADK

​Version compatibility

​Known limitations

​Next steps

Usage

Configuration

OpenAI

Anthropic

Google GenAI

LangChain

Google ADK

Version compatibility

Known limitations

Next steps