Integrations

Admina integrates with the most popular AI agent frameworks and orchestration tools. Every integration routes governance through the Admina proxy — no code changes required in your existing agents.

OpenClaw

Admina ships with a ready-to-use OpenClaw skill that routes all MCP tool calls from your agent through the Admina governance proxy. The setup steps below install the skill and route the agent's traffic via Admina.

How it works

The admina-governance SKILL.md routes all agent actions through /api/v1/validate and /api/v1/audit. Governed action types include:

• llm_call — LLM prompt and completion governance
• shell_exec — Shell command execution
• file_write — File system write operations
• http_request — Outbound HTTP requests
• message_send — Agent-to-agent or agent-to-user messages

Skill install

The setup.sh script rewrites ~/.openclaw/mcp.json to route all MCP traffic through Admina:

# Install the Admina skill
cd openclaw-skill
chmod +x setup.sh
./setup.sh

# Restart OpenClaw gateway
openclaw gateway restart

Adapter (manual)

For fine-grained control, use the python adapter.py to rewrite and restore your MCP config:

# Rewrite mcp.json to use Admina as proxy
python adapter.py rewrite --config ~/.openclaw/mcp.json

# Restore original mcp.json
python adapter.py restore --config ~/.openclaw/mcp.json

Stdio bridge

For MCP servers that use the stdio transport (filesystem, npx-based servers), Admina provides a stdio bridge that wraps the server process and intercepts all JSON-RPC messages on stdin/stdout.

# In mcp.json, wrap stdio servers with the bridge
{
  "mcpServers": {
    "filesystem": {
      "command": "python",
      "args": [
        "/path/to/admina/openclaw-adapter/stdio_bridge.py",
        "--",
        "npx", "-y", "@modelcontextprotocol/server-filesystem", "/home"
      ]
    }
  }
}

LangChain

The AdminaCallbackHandler is a drop-in callback for ChatOpenAI and any other LangChain model. It governs all LLM and tool events through Admina without changing your existing chain logic.

Governed events

• on_llm_start — Validates prompts before they reach the model
• on_llm_end — Scans completions for PII, toxicity, compliance
• on_tool_start — Firewall check before tool execution
• on_tool_end — Audit trail of tool results

Configuration

The handler accepts the following parameters:

• admina_url — Admina proxy URL (default: http://localhost:8080)
• api_key — API key for authentication
• session_id — Session identifier for tracking
• pii_redaction — Enable PII redaction (Data Sovereignty domain)
• firewall — Enable firewall (Agent Security domain)
• loop_detection — Enable loop breaker (Agent Security domain)
• on_block — Behavior when a request is blocked (raise or warn)

Example

pip install "admina-framework[langchain]"

from admina.integrations.langchain import AdminaCallbackHandler
from langchain_openai import ChatOpenAI

handler = AdminaCallbackHandler(
    admina_url="http://localhost:8080",
    api_key="your-key",
    pii_redaction=True,
    firewall=True,
)
llm = ChatOpenAI(callbacks=[handler])

# Every call to llm.invoke() is now governed
response = llm.invoke("Summarize this document")

CrewAI

Admina provides two callbacks for CrewAI: AdminaStepCallback fires after each agent step, and AdminaTaskCallback fires after task completion. Both support per-agent configuration.

Callbacks

• AdminaStepCallback — Governs each agent step (tool calls, LLM calls, reasoning)
• AdminaTaskCallback — Audits completed tasks with full context (inputs, outputs, agent info)

Example

pip install "admina-framework[crewai]"

from admina.integrations.crewai import AdminaStepCallback, AdminaTaskCallback
from crewai import Crew, Agent, Task

researcher = Agent(name="Researcher", ...)
writer = Agent(name="Writer", ...)

crew = Crew(
    agents=[researcher, writer],
    tasks=[...],
    step_callback=AdminaStepCallback(
        admina_url="http://localhost:8080",
    ),
    task_callback=AdminaTaskCallback(
        admina_url="http://localhost:8080",
    ),
)

# Kick off — every step and task is governed
result = crew.kickoff()

n8n

The n8n-nodes-admina package adds three governance nodes to your n8n workflows:

Install

npm install n8n-nodes-admina

Nodes

• AdminaGovern — Inline governance node. Place it before any AI node in your workflow. Validates inputs, blocks non-compliant requests, and adds governance metadata to the output.
• AdminaAudit — Passive logging node. Place it after any AI node to log all requests and responses to the Admina audit trail without blocking.
• AdminaDashboard — WebSocket trigger node. Streams real-time governance events from Admina into n8n, enabling reactive workflows (alerts, Slack notifications, compliance reports).

Cheshire Cat AI

Admina integrates with Cheshire Cat AI as a Python plugin. The plugin hooks into the Cat's event system to govern agent actions at three critical points.

Governed hooks

• agent_fast_reply — Intercepts the agent's reply before it is sent to the user. Enables PII redaction, toxicity filtering, and compliance checks on outputs.
• before_cat_sends_message — Final checkpoint before the message leaves the Cat. Applied after all other plugins have processed the response.
• before_cat_recalls_memories — Governs memory recall to prevent leaking sensitive data from the vector store.

Install

Install the Admina plugin from the Cheshire Cat plugin registry or manually:

# Copy the plugin into your Cat's plugins directory
cp -r admina-cheshire-cat-plugin/ cat/plugins/admina-governance/

# Set the Admina proxy URL in the plugin settings
# via the Cat admin UI or in the plugin's settings.json:
{
  "admina_url": "http://localhost:8080",
  "api_key": "your-key"
}

GuardrailsAI

Admina provides a GuardrailsAI Guard plugin that wraps popular validators with Admina's governance layer. All inference runs locally by default — no data leaves your infrastructure.

Install

# Install guardrails-ai directly; Admina auto-detects it on startup
pip install guardrails-ai

Wrapped validators

• toxic_language — Detects and blocks toxic or harmful language in prompts and completions
• detect_pii — Identifies and redacts personally identifiable information
• detect_jailbreak — Catches prompt injection and jailbreak attempts

Example

from admina.integrations.guardrailsai import AdminaGuard

guard = AdminaGuard(
    admina_url="http://localhost:8080",
    validators=["toxic_language", "detect_pii", "detect_jailbreak"],
)

# Validate a prompt before sending to the LLM
result = guard.validate(
    "Tell me the SSN of John Smith"
)

# result.outcome → "fail"
# result.validated_output → "[PII REDACTED]"

Model provider adapters

Where the framework integrations above govern agent traffic, model adapters let the SDK govern direct calls to an LLM provider: wrap a provider in GovernedModel and every prompt and completion runs the full pipeline (loop → firewall → PII → guards). Each adapter is a built-in plugin that lazy-imports its provider SDK, so the dependency is only required when the adapter is actually used. Since v0.10.0 there are seven, installed via per-provider extras:

Two roll-up extras bundle them: [adapters] pulls every provider, and [all] is [proxy,nlp,telemetry,adapters] for a complete install.

pip install "admina-framework[anthropic]"

from admina.sdk import GovernedModel

# The Anthropic call now runs through the full governance pipeline
model = GovernedModel(adapter="anthropic")
resp = await model.ask("Summarise this contract clause…")
# resp.action → "ALLOW" | "BLOCK"   (firewall + guards run by default since v0.10.0)