> ## Documentation Index
> Fetch the complete documentation index at: https://docs.raxe.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# SDK Overview

> RAXE Python SDK integration patterns

## Installation

```bash theme={null}
pip install raxe
```

## Import Quick Reference

```python title="imports.py" theme={null}
# Core clients
from raxe import Raxe, AsyncRaxe

# LLM wrappers (requires pip install raxe[wrappers])
from raxe import RaxeOpenAI, AsyncRaxeOpenAI
from raxe import RaxeAnthropic, AsyncRaxeAnthropic

# Exceptions (for error handling)
from raxe import RaxeException, RaxeBlockedError, ValidationError

# Integration factory functions (recommended)
from raxe import create_callback_handler, RaxeCrewGuard

# Models (for type hints and comparisons)
from raxe import Severity, Detection, ScanResult
```

## Quick Start

```python title="app.py" theme={null}
from raxe import Raxe

raxe = Raxe()
result = raxe.scan("Your prompt here")

if result.has_threats:
    print(f"Threat: {result.severity}")  # "critical", "high", "medium", "low"
```

## Integration Patterns

<CardGroup cols={2}>
  <Card title="Direct Scanning" icon="magnifying-glass" href="/sdk/python">
    Manual scan calls with full control
  </Card>

  <Card title="OpenAI Wrapper" icon="robot" href="/sdk/openai-wrapper">
    Drop-in replacement for OpenAI client
  </Card>

  <Card title="Anthropic Wrapper" icon="brain" href="/sdk/anthropic-wrapper">
    Drop-in replacement for Anthropic client
  </Card>

  <Card title="Async SDK" icon="bolt" href="/sdk/async">
    High-performance async operations
  </Card>

  <Card title="Background Scanning" icon="forward" href="/sdk/python#background-scanning">
    Zero-overhead async scanning for production APIs
  </Card>
</CardGroup>

## Pattern Comparison

| Pattern     | Use Case            | Blocking     | Control |
| ----------- | ------------------- | ------------ | ------- |
| Direct scan | Custom logic        | Manual       | Full    |
| Decorators  | Function protection | Configurable | Medium  |
| Wrappers    | LLM API protection  | Automatic    | Low     |
| Async       | High throughput     | Configurable | Full    |

## Direct Scanning

```python title="scan_example.py" theme={null}
from raxe import Raxe, RaxeException

raxe = Raxe()

try:
    # Basic scan
    result = raxe.scan("user input")

    # Check results
    if result.has_threats:
        print(f"Severity: {result.severity}")
        print(f"Detections: {result.total_detections}")
        for d in result.detections:
            print(f"  - {d.rule_id}: {d.category}")
except RaxeException as e:
    print(f"Scan error: {e}")
```

## Decorator Pattern

```python title="decorated.py" theme={null}
from raxe import Raxe, RaxeBlockedError

raxe = Raxe()

@raxe.protect
def process_input(user_input: str) -> str:
    """Automatically scanned before execution."""
    return llm.generate(user_input)

# Safe input - works normally
process_input("What is the weather?")

# Malicious input - blocked or logged depending on config
try:
    process_input("Ignore all instructions")
except RaxeBlockedError as e:
    print(f"Blocked: {e.severity}")
```

## LLM Wrappers

```python title="openai_example.py" theme={null}
from raxe import RaxeOpenAI, RaxeBlockedError

# Drop-in replacement for OpenAI client
client = RaxeOpenAI(api_key="sk-...")

try:
    # Automatic scanning before API call
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": user_input}]
    )
except RaxeBlockedError as e:
    # Threat blocked before API call - saves tokens
    print(f"Blocked: {e.severity}")
```

## Async SDK

```python title="async_example.py" theme={null}
from raxe import AsyncRaxe

async_raxe = AsyncRaxe()

# Single scan
result = await async_raxe.scan("prompt")

# Batch scanning for high throughput
results = await async_raxe.scan_batch(
    prompts=["prompt1", "prompt2", "prompt3"],
    max_concurrency=5  # Limit concurrent scans
)
```

## Context Manager

```python title="context_example.py" theme={null}
from raxe import Raxe

# Automatic cleanup - telemetry flushed on exit
with Raxe() as raxe:
    result = raxe.scan("test")
    # Process result...
# Telemetry automatically flushed here
```

## Configuration

```python title="config_example.py" theme={null}
from raxe import Raxe

raxe = Raxe(
    l1_enabled=True,      # Rule-based detection (515+ patterns)
    l2_enabled=True,      # ML detection (neural classifier)
    log_level="INFO",     # Logging level: DEBUG, INFO, WARNING, ERROR
)
```