shieldcortex

Official Python SDK for the ShieldCortex API — AI memory security scanning.

How It Works

AI agents store memories (user inputs, tool outputs, conversation history) to improve over time. But those memories are an attack surface — prompt injection, credential leaks, and encoding attacks can all be smuggled into memory stores.

ShieldCortex scans content before it reaches your agent's memory through a 6-layer defence pipeline:

Agent receives content
        │
        ▼
  ShieldCortex scan ──→ BLOCK   → reject, log threat
        │
        ▼
      ALLOW ──→ safe to store in memory

The SDK sends content to the ShieldCortex cloud API and returns a verdict: ALLOW, BLOCK, or QUARANTINE — along with trust scores, threat indicators, and sensitivity classification.

Get an API key at shieldcortex.ai (free tier: 500 scans/month).

Installation

pip install shieldcortex

With framework integrations:

pip install shieldcortex[crewai]     # CrewAI memory guard
pip install shieldcortex[langchain]  # LangChain callback handler

Quick Start

from shieldcortex import ShieldCortex

client = ShieldCortex(api_key="sc_live_...")

# Scan content before storing in your agent's memory
result = client.scan("user input to remember")

if result.allowed:
    save_to_memory(result)  # safe — store it
else:
    print(f"Blocked: {result.firewall.reason}")
    print(f"Threats: {result.firewall.threat_indicators}")
    # don't store — content failed security checks

Async Support

from shieldcortex import AsyncShieldCortex

async with AsyncShieldCortex(api_key="sc_live_...") as client:
    result = await client.scan("user input here")

Batch Scanning

Scan up to 100 items in a single request — useful for bulk-importing memory entries:

from shieldcortex import BatchItem

result = client.scan_batch([
    BatchItem(content="memory entry 1"),
    BatchItem(content="memory entry 2"),
])
print(f"Scanned: {result.total_scanned}, Threats: {result.threats}")

CrewAI Integration

Add a security gate between your CrewAI agent and its memory store. The guard scans all content before it's saved — blocking prompt injection and credential leaks:

from shieldcortex import ShieldCortex
from shieldcortex.integrations.crewai import ShieldCortexMemoryGuard, MemoryBlockedError

client = ShieldCortex(api_key="sc_live_...")
guard = ShieldCortexMemoryGuard(client, mode="strict")

try:
    guard.check("content to remember")
    # Safe — save to memory store
except MemoryBlockedError as e:
    print(f"Blocked: {e.result.firewall.reason}")

LangChain Integration

Automatically scan all LLM inputs and outputs as they flow through your chain — no changes to your existing code:

from shieldcortex import AsyncShieldCortex
from shieldcortex.integrations.langchain import ShieldCortexCallbackHandler

client = AsyncShieldCortex(api_key="sc_live_...")
handler = ShieldCortexCallbackHandler(client, raise_on_block=True)

# Scans inputs on chain start, outputs on LLM end, and tool I/O
llm = ChatOpenAI(callbacks=[handler])

Audit Logs

Every scan is logged. Query your history, export for compliance, or auto-paginate through all entries:

from shieldcortex import AuditQuery

# Query with filters
logs = client.get_audit_logs(AuditQuery(level="BLOCK", limit=10))

# Auto-paginate through all entries
for entry in client.iter_audit_logs():
    print(entry.id, entry.firewall_result)

# Export as CSV — returns the raw body plus integrity headers
export = client.export_audit_logs(format="csv")
print(export.content)
print(export.headers.sha256)  # None ⇒ export unverifiable

Error Handling

from shieldcortex.errors import AuthError, RateLimitError, ValidationError

try:
    result = client.scan("content")
except AuthError:
    print("Invalid API key")
except RateLimitError as e:
    print(f"Rate limited, retry after {e.retry_after}s")
except ValidationError:
    print("Invalid request")

API Coverage

The SDK covers the full customer surface documented in the SDK lockstep contract:

Deferred endpoints

The audit verification-export download chain (GET .../verifications/export, GET .../verification-exports, GET .../verification-exports/{id} and its /download) is deliberately deferred — it serves CLI tooling rather than SDK consumers. See tests/endpoint_manifest.py for the canonical list.

Out of scope

• /v1/platform/* — platform-owner operations
• /v1/auth/* — magic-link login flows (browser/dashboard, not API-key auth)
• /v1/customizer/* — retired 2026-07

Additional dashboard/session-scoped /v1 routes exist server-side; they sit outside the SDK's API-key surface.

Cross-SDK policy notes

The Python and TypeScript SDKs cover the same endpoint manifest, with two deliberate differences:

1. Deletes — the TypeScript SDK returns void from every delete method; the Python SDK returns the typed response body where the server sends one (per-language internal consistency).
2. Audit export — both SDKs return the raw file content together with the parsed X-ShieldCortex-Export-* integrity headers. An absent sha256 or signature header means the export is unverifiable.

Documentation

• ShieldCortex Docs
• API Reference
• Examples

License

MIT