EgisAI

Production guardrails for Python AI applications. Install the SDK, call egisai.init(), and continue using OpenAI, Anthropic, Google Gemini, or plain HTTP clients as you do today — policy evaluation and audit logging wrap those calls automatically. This site is the canonical SDK guide for the egisai package on PyPI.

Prefer enforcement on the network path — or can’t install a Python SDK at all (Node service, low-code platform, vendor tool)? The same policies apply through the inline Gateway. In Python, egisai.Client sends governed chat completions with a single import; every other stack points any OpenAI-compatible client (or plain HTTP) at https://app.egisai.co/v1/agent. One policy set, one audit trail, two integration paths.

Quickstart

Install, initialize, and make your first governed call in five minutes.

How it works

Understand how policy evaluation slots into your model call path.

Gateway

Govern on the network path — egisai.Client in Python, plain HTTP everywhere else.

API reference

Detailed reference for init(), Client, set_context(), and policy types.

Troubleshooting

Common symptoms, what they mean, and how to fix them.

Overview

Capability	What it means for you
Central policies	Operators configure rules in the EgisAI dashboard. The SDK loads them at runtime and refreshes them continuously — no redeploy to tighten controls.
Transparent integration	No mandatory proxy and no wrapper objects you must remember to use. `egisai.init()` patches every supported library that is importable in the current environment; calls through their normal API go through governance without further wiring. Orgs that prefer network-path enforcement use the optional inline Gateway instead.
Broad framework coverage	Direct provider SDKs (OpenAI, Anthropic, Google Gemini, AWS Bedrock Converse) plus the major agent frameworks (LangChain, LangGraph, OpenAI Agents, CrewAI, AutoGen, Agno, Strands, smolagents, LlamaIndex, Pydantic AI, Google ADK, Claude Agent SDK) are governed transparently.
Audit trail	Governed calls emit structured events to your org so teams can review verdicts, latency, tool calls, and usage in one place.
Local-first sensitive checks	Pattern-based PII handling and other deterministic rules run entirely inside your process before traffic leaves your environment.
Automatic agent identity	Distinct logical agents in the same process are auto-detected and registered with the dashboard. Sub-agents fingerprinted by system prompt, framework hook, or explicit name show up as separate rows for attribution.

What you need

Python 3.11+
An EgisAI account and an SDK API key (dashboard → API Keys → create). Keys look like egis_live_….
The AI SDK(s) you already use (openai, anthropic, google-genai, …).

Installation

pip install "egisai[all]"

Optional extras (smaller installs):

pip install "egisai[openai]"
pip install "egisai[anthropic]"
pip install "egisai[google]"

Only frameworks present in your environment are activated at runtime. See the installation guide for more options.

Getting started

Initialize once per process

Call egisai.init() as early as possible in your application lifecycle — for example, right after loading configuration. Use your SDK API key from the dashboard.

import egisai

egisai.init(
    api_key="egis_live_…",   # or set EGISAI_API_KEY in the environment
    app="customer-support-bot",
    env="production",
)

Use your LLM client normally

No changes to your calling convention — the SDK intercepts supported APIs after initialization.

from openai import OpenAI

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

import anthropic

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)

from google import genai

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

Review activity

Open Dashboard → Requests to see governed calls, verdicts, and supporting metadata for your organization.

How governance fits your call path

Evaluation — Before the upstream model runs, the SDK applies your organization’s active policies (cached locally). Rules such as PII detection, regex denylists, model allowlists, and intent-oriented policies are evaluated in a fixed order defined by the product.
Outcomes — A call may be allowed, sanitized (payload adjusted per policy, then forwarded), or blocked. Blocked calls never reach the provider when enforcement raises or returns a stub, depending on configuration.
Telemetry — Non-blocking delivery of audit metadata to EgisAI so your dashboard stays current without slowing customer-facing inference.

Sensitive pattern detection intended to catch regulated data is performed locally so raw values are not sent to third-party models as part of governance. Intent-oriented policies operate only after applicable local checks have run on the text that will be judged. Read How it works for the full call-path diagram.

When a call is blocked

`on_block`	Behavior
`"raise"` (default)	Raises `PermissionError` if a policy blocks the call.
`"stub"`	Returns a framework-shaped refusal object so applications that cannot tolerate exceptions keep running; the refusal is clearly identifiable in your logs and on the dashboard.

Configure at init:

egisai.init(..., on_block="stub")

See Blocking behavior for guidance on when to choose each mode.

Configuration at a glance

Initialization parameters

Parameter	Default	Description
`api_key`	—	Required unless `EGISAI_API_KEY` is set. Your EgisAI SDK key (`egis_live_…`).
`app`	`"default"`	Logical application name; appears as an Agent in the dashboard for attribution.
`env`	`"production"`	Environment label (for example `staging`, `prod`). Free-form string for your own segmentation.
`base_url`	Hosted control plane	Override only when directed by EgisAI (for example dedicated regions or enterprise deployments).
`on_block`	`"raise"`	`"raise"` or `"stub"` — see above.
`semantic_on_outage`	`"allow"`	Behavior of `semantic_guard` rules when the intent judge is unreachable: `"allow"` (fail-open) or `"block"` (fail-closed).
`refresh_interval_seconds`	`10`	How often to poll for policy updates if live streaming is unavailable.
`enable_sse`	`True`	Subscribe to live policy and configuration updates when supported.
`enable_http_fallback`	`True`	Optional patching of `httpx` / `requests` for broader HTTP visibility where enabled.
`auto_stack_hints`	`"loose"`	Controls the stack-frame inspector used by the agent identity resolver. `"loose"` / `"strict"` / `"off"`.
`quiet`	`False`	Set `True` to suppress the one-line startup banner on stderr.

Environment variables

Variable	Purpose
`EGISAI_API_KEY`	SDK API key if not passed as `api_key=`.
`EGISAI_BASE_URL`	Control plane base URL override when supplied by EgisAI.

Treat API keys as secrets — use environment variables or a secrets manager, never commit them to source control.

The full reference lives in Configuration and the init API reference.

Policies (operator concepts)

Organizations configure policies in the dashboard. Typical categories include:

Category	Purpose (high level)
PII & secrets	Detect and block or mask categories such as government identifiers, payment data, and credential-shaped strings before model calls.
Content patterns	Allow or deny prompts or outputs matching operator-defined patterns.
Models & size	Restrict which model names may be called or cap prompt size.
Intent	Block requests that match dangerous or out-of-scope intent even when phrased obliquely or in another language.
Tools & connectors	Restrict tool, shell, or integration use when the model returns structured tool or command requests.

Exact rule shape and ordering are managed in the product; the SDK consumes the published configuration and does not require you to embed policy documents in your repository. See Policies for the SDK-side picture.

Advanced: explicit context (optional)

For multi-tenant or test scenarios, you may override auto-detected context (for example agent identity) with egisai.set_context(**kwargs) as described in the set_context reference. This is optional — the default path fingerprints agents from your application’s behavior. See Multi-agent context for patterns.

Performance and availability

Steady-state overhead is designed to stay on the order of a fraction of a millisecond for policy lookup per call after initialization and cache warm-up.
Control plane connectivity — If the SDK cannot reach EgisAI at startup, your process can still run; policy enforcement may be limited until a successful connection and policy fetch. Local checks remain in force where the engine can evaluate them. For your specific deployment’s behavior, refer to your contract and SECURITY.md.
Audit delivery is asynchronous so network latency does not sit on the critical path of every model call.

Privacy and security

Do not embed secrets in repository copies of this README.
For vulnerability reporting, see SECURITY.md — please use the disclosed channel rather than public issues for security-sensitive matters.

A short summary suitable for architecture reviews:

Governance evaluates prompts with respect to your organization’s policies before upstream invocation where applicable.
Sensitive-content handling is architected so that raw regulated values are not sent to third-party LLMs as part of policy enforcement workflows described here.

Supported Python libraries

Category	Library	Notes
Direct provider SDK	`openai` ≥ 1.40	Chat Completions, Responses API, sync + async, streaming, tool calls.
	`anthropic` ≥ 0.40	Messages API, sync + async, streaming, tool use.
	`google-genai` ≥ 1.0	`client.models.generate_content`, async, streaming, function calls.
	`google-generativeai` ≥ 0.8	`GenerativeModel.generate_content`, streaming.
	`boto3` (AWS Bedrock)	`bedrock-runtime` Converse / ConverseStream and `bedrock-agent-runtime` `InvokeAgent`.
Agent framework	`openai-agents`	`Runner.run`, identity wrap; tool gating cascades to the OpenAI patch.
	`claude-agent-sdk`	`ClaudeSDKClient` and `query()`; `PreToolUse` + `PostToolUse` hooks gate tool dispatch and tool results in-process.
	`langchain` / `langchain-classic`	Classic `AgentExecutor` and modern `create_agent`.
	`langgraph`	`Pregel.invoke` / `.stream` and `CompiledStateGraph`.
	`crewai`, `autogen`, `agno`, `strands-agents`, `smolagents`, `llama-index`, `pydantic-ai`, `google-adk`	Identity wraps; tool gating cascades to the inner provider patch.
HTTP fallback	`httpx` / `requests`	Optional broad HTTP capture for code that bypasses the official provider SDKs. Matches on known LLM-provider hosts AND known model-call path tokens to avoid logging unrelated traffic.

Minimum versions are guidance; pin in your own requirements.txt for reproducible builds. Only frameworks actually importable in your environment are patched at runtime — uninstalled frameworks are silently skipped. Per-library walkthroughs:

OpenAI

Anthropic

Google Gemini

AWS Bedrock

Claude Agent SDK

Agent frameworks

httpx / requests

For the full per-framework enforcement matrix — what’s blocked before a tool runs vs. what’s recorded after the fact — see Enforcement matrix in the SDK README.

Resources

Resource	URL
Website	egisai.co
Documentation	docs.egisai.co
Dashboard	app.egisai.co
PyPI	pypi.org/project/egisai
Repository & issues	github.com/EgisLabs/egisai-sdk
Changelog	CHANGELOG.md on GitHub
Security	SECURITY.md on GitHub

License

Apache License 2.0 — see the LICENSE file in the source repository.

EgisAI — runtime governance for AI agents.

Get started

Core concepts

Integrations

Gateway

Coverage

Guides

Operations

Quickstart

How it works

Gateway

API reference

Troubleshooting

Overview

What you need

Installation

Getting started

How governance fits your call path

When a call is blocked

Configuration at a glance

Policies (operator concepts)

Advanced: explicit context (optional)

Performance and availability

Privacy and security

Supported Python libraries

OpenAI

Anthropic

Google Gemini

AWS Bedrock

Claude Agent SDK

Agent frameworks

httpx / requests

Resources

License

Quickstart

How it works

Gateway

API reference

Troubleshooting

​Overview

​What you need

​Installation

​Getting started

​How governance fits your call path

​When a call is blocked

​Configuration at a glance

​Policies (operator concepts)

​Advanced: explicit context (optional)

​Performance and availability

​Privacy and security

​Supported Python libraries

OpenAI

Anthropic

Google Gemini

AWS Bedrock

Claude Agent SDK

Agent frameworks

httpx / requests

​Resources

​License

Overview

What you need

Installation

Getting started

How governance fits your call path

When a call is blocked

Configuration at a glance

Policies (operator concepts)

Advanced: explicit context (optional)

Performance and availability

Privacy and security

Supported Python libraries

Resources

License