> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rotavision.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Integrations Overview
> Wrap your provider client with a Sakshi middleware, add one line, and every model call your agent makes lands on the same tamper-evident chain.
Sakshi witnesses the AI agents you already run. You do not rewrite the agent. You
wrap the client it calls, and every model call is recorded on the chain, with the
served model identity, tokenized inputs, and outcome. Sakshi never sees a raw
identifier: PII is tokenized at ingest, before anything is stored or hashed.
export const wwGrid = {
display: 'flex',
flexWrap: 'wrap',
gap: '10px',
justifyContent: 'center',
margin: '26px 0 6px'
};
export const wwChip = {
display: 'inline-flex',
alignItems: 'center',
gap: '7px',
padding: '8px 14px',
border: '1px solid rgba(128,128,128,0.28)',
borderRadius: '9px',
fontSize: '14px',
fontWeight: 600,
lineHeight: 1
};
export const wwMark = {
width: 16,
height: 16,
fill: 'currentColor',
opacity: 0.85,
flexShrink: 0
};
Product names and marks are trademarks of their respective owners, shown to indicate compatibility, not endorsement.
## The integration doctrine
There are three ways in, and every one lands on the same chain.
A few lines. You open a witness session and record the steps of a decision
yourself. Full control over what becomes evidence.
One line. Wrap the provider client once and every model call inside a witness
session is recorded automatically, with no rewrite of the agent.
Govern any agent that speaks the Model Context Protocol, including agents you
cannot instrument, through a client session wrapper or a proxy.
The middlewares are the shortest path. They are duck-typed, so the Sakshi SDK
carries no dependency on any provider SDK: a middleware wraps any object with the
right shape, attaches to the active witness session, and auto-fills the served
model identity from the provider's response (the RBI draft para-56 evidence, per
decision).
## Supported providers
The OpenAI client, plus Ollama, vLLM, TGI, and LM Studio through a base URL.
The sovereign, self-hosted path.
The Anthropic Messages API shape.
The google-genai SDK shape.
The bedrock-runtime Converse API. Residency-compliant in AWS Mumbai.
The same provider middlewares underneath, plus the LangGraph path for graph
apps.
Bracket a compiled graph and witness individual nodes.
Register one plugin on the Runner to witness the whole agent tree, and
optionally enforce in the tool path.
Register one event listener to witness a crew's model and tool calls.
One hook provider to witness tool and model calls, and cancel a tool through
the envelope.
Govern at the tool boundary and the model client. The honest paths that work.
| Runtime | Function | Wraps |
| ------------------------------------ | --------------------------------- | --------------------------------------------------------- |
| OpenAI, Ollama, vLLM, TGI, LM Studio | `watch_openai_compatible` | `chat.completions.create` |
| Anthropic | `watch_anthropic` | `messages.create` |
| Google Gemini | `watch_gemini` | `models.generate_content` |
| AWS Bedrock | `watch_bedrock` | `converse` |
| LangGraph | `watch_langgraph`, `witness_node` | a compiled graph, a node callable |
| Google ADK | `SakshiAdkPlugin` | a Runner plugin (witness the tree, enforce the tool path) |
| CrewAI | `SakshiCrewListener` | an event listener (witness the crew's model + tool calls) |
| AWS Strands | `SakshiStrandsHooks` | a hook provider (witness + enforce the tool path) |
| AutoGen | (tool-boundary pattern) | witness + enforce inside your tools |
| MCP | `watch_mcp` | an MCP client session |
Every function lives in `sakshi.middleware`:
```python theme={null}
from sakshi.middleware import (
watch_openai_compatible,
watch_anthropic,
watch_gemini,
watch_bedrock,
watch_langgraph,
witness_node,
watch_mcp,
SakshiAdkPlugin,
SakshiCrewListener,
SakshiStrandsHooks,
)
```
## The shared shape
Every integration follows the same four steps: point the SDK at your deployment,
register the agent, wrap the provider client once, then make calls inside a
witness session.
```python theme={null}
from sakshi import SakshiClient
from sakshi.middleware import watch_openai_compatible
from openai import OpenAI
# 1. Point the SDK at your Sakshi deployment.
sakshi = SakshiClient(
base_url="https://sakshi.your-company.internal",
api_key="sks_...",
)
# 2. Register the agent. Idempotent by name, so safe on every startup.
agent_id = sakshi.register(
"loan-decision-agent",
owner_name="Priya Sharma",
owner_email="priya@your-company.com",
autonomy_tier="L1",
)
# 3. Wrap the provider client once. This is the one line.
llm = watch_openai_compatible(OpenAI())
# 4. Calls made inside a witness session are recorded automatically.
with sakshi.witness(agent_id, client_ref="APP-2026-04471") as decision:
reply = llm.chat.completions.create(
model="gpt-5.2",
messages=[{"role": "user", "content": "Assess this applicant."}],
)
decision.action(outcome="approved", amount=1_500_000, mode="auto")
```
You do not pass the model to `witness` when a middleware is in play. The
middleware fills the served model identity from the provider's response, so the
record reflects what actually answered, not what you intended to call.
Evidence belongs to decisions. A model call made outside a witness session
passes through untouched and is not recorded. Recording is also fail-open: a
problem writing evidence never breaks or delays the host agent's call.
## Where to go next
The client, the witness session, enforcement, and the exception model.
The MCP server and the interception proxy for zero-code governance.
How steps become a tamper-evident record anyone can recompute.
Register, witness, and verify the chain in a few minutes.