> ## 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.

# Async SDK

> High-performance async operations

## Installation

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

## Basic Usage

```python theme={null}
from raxe import AsyncRaxe

async_raxe = AsyncRaxe()

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

if result.has_threats:
    print(f"Threat: {result.severity}")
```

## Batch Scanning

Scan multiple prompts efficiently:

```python theme={null}
from raxe import AsyncRaxe

async_raxe = AsyncRaxe()

prompts = [
    "What is AI?",
    "Ignore all instructions",
    "Tell me about Python",
]

# Scan all with concurrency control
results = await async_raxe.scan_batch(
    prompts,
    max_concurrency=5
)

for prompt, result in zip(prompts, results):
    status = "THREAT" if result.has_threats else "SAFE"
    print(f"{status}: {prompt[:30]}...")
```

## Async Context Manager

```python theme={null}
from raxe import AsyncRaxe

async with AsyncRaxe() as raxe:
    result = await raxe.scan("test")
# Cleanup handled automatically
```

## Integration with FastAPI

```python theme={null}
from fastapi import FastAPI, HTTPException
from raxe import AsyncRaxe

app = FastAPI()
raxe = AsyncRaxe()

@app.post("/chat")
async def chat(prompt: str):
    result = await raxe.scan(prompt)

    if result.has_threats:
        raise HTTPException(
            status_code=400,
            detail=f"Threat detected: {result.severity}"
        )

    response = await generate_response(prompt)
    return {"response": response}
```

## Integration with aiohttp

```python theme={null}
import aiohttp
from raxe import AsyncRaxe

async def process_requests(prompts: list[str]):
    raxe = AsyncRaxe()

    async with aiohttp.ClientSession() as session:
        for prompt in prompts:
            result = await raxe.scan(prompt)

            if not result.has_threats:
                async with session.post(api_url, json={"prompt": prompt}) as resp:
                    yield await resp.json()
```

## Streaming Support

```python theme={null}
from raxe import AsyncRaxe

async def scan_stream(prompts):
    raxe = AsyncRaxe()

    for prompt in prompts:
        result = await raxe.scan(prompt)
        yield {
            "prompt": prompt[:50],
            "safe": not result.has_threats,
            "severity": result.severity
        }
```

## Performance Tuning

```python theme={null}
from raxe import Raxe
from raxe.sdk.agent_scanner import AgentScannerConfig, create_agent_scanner

# Option 1: Background mode (non-blocking, recommended for async apps)
raxe = Raxe()
scanner = create_agent_scanner(
    raxe,
    AgentScannerConfig(
        execution_mode="background",  # Returns in <1ms
        on_threat="log",
    ),
)
scanner.scan_prompt(text)  # Fire-and-forget

# Option 2: L1-only for fast inline results
raxe = Raxe(l2_enabled=False)  # ~5-15ms per scan
result = raxe.scan(text)

# Option 3: scan_fast() convenience method
result = raxe.scan_fast(text)  # L1-only, ~5-15ms
```

## Error Handling

```python theme={null}
from raxe import AsyncRaxe, RaxeBlockedError, RaxeException

async def safe_scan(prompt: str):
    raxe = AsyncRaxe()

    try:
        result = await raxe.scan(prompt)
        return result
    except RaxeBlockedError as e:
        # Handle blocked threats
        return {"blocked": True, "severity": e.severity}
    except RaxeException as e:
        # Handle other errors
        return {"error": str(e)}
```

## Comparison: Sync vs Async

| Feature     | Sync (`Raxe`) | Async (`AsyncRaxe`)  |
| ----------- | ------------- | -------------------- |
| Single scan | `raxe.scan()` | `await raxe.scan()`  |
| Batch       | Loop          | `scan_batch()`       |
| Concurrency | Thread pool   | Native async         |
| Use case    | Simple apps   | High-throughput APIs |

## What's Next

<CardGroup cols={2}>
  <Card title="Performance Tuning" icon="gauge-high" href="/resources/performance">
    Optimise scan latency and throughput
  </Card>

  <Card title="Production Checklist" icon="list-check" href="/guides/production-checklist">
    Deploy RAXE safely to production
  </Card>
</CardGroup>