From import shieldpi.auto to your first alert in 60 seconds.

bashpip install shieldpi                          # core only (manual integration)
pip install "shieldpi[langchain]"             # + LangChain hooks
pip install "shieldpi[langgraph]"             # + LangGraph hooks
pip install "shieldpi[openai]"                # + OpenAI Assistants hooks
pip install "shieldpi[anthropic]"             # + Anthropic SDK hooks
pip install "shieldpi[all]"                   # everything

Python 3.9+. Single required dependency (httpx). Zero impact on your agent's request latency — every event ingest is async + batched on a background worker thread.

ShieldPi uses two distinct credentials. Don't mix them up.

Rule of thumb: your deployed agent talks to ShieldPi with the SDK key (per-agent, narrow scope). You (or your dashboard / Claude Desktop / SOC) talk to ShieldPi with the API key (account-wide). Each can be rotated independently.

The minimum viable instrumentation:

pythonfrom shieldpi import Monitor

monitor = Monitor(sdk_key="shpi_live_REPLACE_ME")

session = monitor.start_session(
    agent_name="acme-support-bot",
    stated_goal="Help ACME customers with order/account questions",
)

# In your request handler — for every user turn:
session.log_user_message(user_input)

response = your_llm.chat(user_input)
session.log_final_response(response)

# Tool calls (any framework):
session.log_tool_call("lookup_order", {"order_id": "ORD-4421"})
session.log_tool_result("lookup_order", {"status": "shipped"})

session.end()

Most users should use import shieldpi.auto from the hero block above. Reach for these manual hooks when you need custom session boundaries, want to attach metadata per-run, or are building on a framework not yet covered by auto-patch.

For LangChain (manual callback):

pythonfrom shieldpi import Monitor
from shieldpi.hooks.langchain import ShieldPiCallbackHandler

monitor = Monitor(sdk_key="shpi_live_...")
callbacks = [ShieldPiCallbackHandler(monitor, agent_name="my-agent")]

agent.invoke({"input": user_input}, config={"callbacks": callbacks})

For Anthropic tool use (manual context manager):

pythonfrom anthropic import Anthropic
from shieldpi import Monitor
from shieldpi.hooks.anthropic import monitored_tool_use

anth = Anthropic()
monitor = Monitor(sdk_key="shpi_live_...")

with monitored_tool_use(monitor, agent_name="invoice-bot") as session:
    session.log_user_message(user_input)
    response = anth.messages.create(
        model="claude-opus-4-20250514",
        messages=[{"role": "user", "content": user_input}],
        tools=[...],
    )
    session.observe_anthropic_response(response)

For LangGraph, OpenAI Assistants — just use import shieldpi.auto. No manual-hook equivalent needed; the auto-patch wraps Pregel.invoke, beta.threads.runs.create, and chat.completions.create (when tools= is set) for you.

By default alerts land in the dashboard alerts queue. Add an outbound webhook so alerts also flow to your existing SOC:

bashcurl -X POST -H "X-API-Key: $SHIELDPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://hooks.slack.com/services/T0/B0/XXX","type":"slack"}' \
  https://api.shieldpi.io/api/agent-monitor/target/$TARGET_ID/webhook

Supported types: slack (block-formatted message), generic (raw JSON for PagerDuty / Splunk / Datadog / your own ingest). Every alert includes severity, alert_type, evidence, session_id, and a deep link back to the dashboard.

Install the shieldpi-mcp server once:

bashpipx install shieldpi-mcp

# Then in Claude Desktop's claude_desktop_config.json:
{
  "mcpServers": {
    "shieldpi": {
      "command": "shieldpi-mcp",
      "env": { "SHIELDPI_API_KEY": "shpi_live_…" }
    }
  }
}

Now ask Claude: “Use shieldpi to get all live alerts on my agents in the last 24 hours, group by severity, and walk me through the worst one.”

Claude calls get_live_alerts + get_alert_detail against api.shieldpi.io and renders the full forensic kill chain right in chat. Same for triage: acknowledge_alert + resolve_alert. Your SOC, queryable from the IDE.