Guard Core MCP

https://github.com/guard-core/guard-core-mcp
Admin
Guard Core MCP is a Model Context Protocol server that provides config validation, documentation...
Tokens:564,645
Snippets:4,180
Trust Score:7.1
License:MIT
Update:21 hours ago
Show doc for...
Tokens:
Raw
### get_doc example call

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/tools.md

An example of calling get_doc to retrieve a specific installation guide.

```python
get_doc("fastapi-guard", "installation.md")
```

--------------------------------

### Verify installation with versions tool

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/installation.md

Example output from the versions tool showing installed library versions versus bundled documentation versions.

```json
{
  "guard_core_mcp": "0.1.12",
  "installed": {
    "guard-core": "3.17.0",
    "fastapi-guard": "7.8.2",
    "guard-agent": "2.10.0"
  },
  "docs_bundled_for": {
    "fastapi-guard": "7.8.2",
    "guard-agent": "2.10.0",
    "guard-core": "3.17.0"
  }
}
```

--------------------------------

### Run Example App with Docker Compose

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/index.md

Clone the repository and start the example application along with the required Redis service.

```bash
# Clone the repository
git clone https://github.com/Guard-Core/fastapi-guard.git
cd fastapi-guard/examples

# Start the app with Redis
docker compose up
```

--------------------------------

### Install and start Redis server

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/installation.md

Commands to install Redis on Ubuntu/Debian or macOS and start the server.

```bash
# Ubuntu/Debian
sudo apt-get install redis-server

# macOS with Homebrew
brew install redis

# Start Redis
redis-server
```

--------------------------------

### Run examples without Docker

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/getting-started/examples.md

Commands to start a local Redis instance, install dependencies, build the project, and run the Express example using tsx.

```bash
docker run -d -p 6379:6379 redis:7-alpine   # needed by every example except Hono
pnpm install
pnpm build
cd examples/express
npx tsx app.ts
```

--------------------------------

### Run Express example with Docker Compose

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/getting-started/examples.md

Commands to navigate to the Express example directory and start the application stack using Docker Compose.

```bash
cd examples/express
docker compose up --build
```

--------------------------------

### Run simple_app with Docker Compose

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/examples/example-app.md

Starts the simple_app example from its directory using docker compose up.

```bash
cd examples/simple_app
docker compose up
```

--------------------------------

### Full Express Integration Example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/adapters/express.md

A complete example showing configuration, middleware setup, and route-specific security decorators.

```typescript
import express from 'express';
import {
  createSecurityMiddleware,
  guardBodyParser,
  configureCors,
  SecurityDecorator,
  SecurityConfigSchema,
} from '@guardcore/express';

const app = express();

const config = SecurityConfigSchema.parse({
  enableRedis: false,
  rateLimit: 100,
  rateLimitWindow: 60,
  enablePenetrationDetection: true,
  enableCors: true,
  corsAllowOrigins: ['https://app.example.com'],
  blockedUserAgents: ['sqlmap', 'nikto'],
  excludePaths: ['/health'],
});

const guard = new SecurityDecorator(config);

app.use(guardBodyParser());
configureCors(app, config);

app.use(createSecurityMiddleware({
  config,
  guardDecorator: guard,
}));

const loginHandler = guard.rateLimit(5, 300)(async (req, res) => {
  res.json({ token: 'abc123' });
});

app.get('/health', (_req, res) => res.json({ status: 'ok' }));
app.post('/api/login', (req, res, next) => {
  loginHandler(req, res).catch(next);
});

app.listen(3000, () => {
  console.log('Server running on :3000');
});
```

--------------------------------

### Setup manual virtual environment with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/installation.md

Create and activate a manual virtual environment before installing the package.

```bash
python -m venv .venv
source .venv/bin/activate
pip install guard-agent
```

--------------------------------

### Complete SecurityConfig Setup

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/security/detection-engine/configuration.md

A comprehensive example demonstrating all available settings for the detection engine, including core security, optimization, performance monitoring, Redis integration, agent integration, and logging.

```python
from fastapi import FastAPI
from guard import SecurityMiddleware, SecurityConfig

app = FastAPI()

# Full detection engine configuration
config = SecurityConfig(
    # Core security settings
    enable_penetration_detection=True,
    auto_ban_threshold=5,
    auto_ban_duration=3600,
    passive_mode=False,  # Set to True for monitoring without blocking
    # Detection engine optimization
    detection_compiler_timeout=2.0,
    detection_max_content_length=10000,
    detection_preserve_attack_patterns=True,
    detection_semantic_threshold=0.7,
    # Performance monitoring
    detection_anomaly_threshold=3.0,
    detection_slow_pattern_threshold=0.1,
    detection_monitor_history_size=1000,
    detection_max_tracked_patterns=1000,
    # Redis integration (optional)
    use_redis=True,
    redis_host="localhost",
    redis_port=6379,
    redis_db=0,
    # Agent integration (optional)
    enable_agent=True,
    agent_api_key="your-api-key",
    agent_enable_events=True,
    agent_enable_metrics=True,
    # Logging
    custom_log_file="security.log",
    log_level="WARNING",
)

app.add_middleware(SecurityMiddleware, config=config)
```

--------------------------------

### Minimal Flask integration example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/flask.md

A basic setup showing how to configure SecurityConfig and initialize FlaskAPIGuard with a standard Flask app.

```python
import os

from flask import Flask
from flaskapi_guard import FlaskAPIGuard, SecurityConfig, SecurityDecorator

api_key = os.environ.get("GUARD_API_KEY", "")
project_id = os.environ.get("GUARD_PROJECT_ID", "")
core_url = os.environ.get("GUARD_CORE_URL", "https://api.guard-core.com")

security_config = SecurityConfig(
    # Security settings
    auto_ban_threshold=5,
    auto_ban_duration=300,
    enable_rate_limiting=True,
    rate_limit=100,
    rate_limit_window=60,

    # Agent telemetry
    enable_agent=bool(api_key),
    agent_api_key=api_key,
    agent_endpoint=core_url,
    agent_project_id=project_id,
)

app = Flask(__name__)
guard_decorator = SecurityDecorator(security_config)
guard = FlaskAPIGuard(app, config=security_config)
guard.set_decorator_handler(guard_decorator)


@app.route("/")
def root() -> dict[str, str]:
    return {"message": "Hello, Guard!"}
```

--------------------------------

### Install guard-agent-go

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_knowledge/guard-agent-go/index.md

Use the go get command to install the specific version of the guard-agent-go module.

```sh
go get github.com/rennf93/guard-agent-go/v3@v3.1.0
```

--------------------------------

### adapter_setup(language, framework)

Source: https://github.com/guard-core/guard-core-mcp/blob/master/AGENTS.md

Install command plus a verified minimal middleware integration for one adapter, with its engine's install and conformance status.

```APIDOC
## adapter_setup(language, framework)

### Description
Install command plus a verified minimal middleware integration for one adapter, with its engine's install and conformance status.

### Method
MCP Tool

### Endpoint
adapter_setup

### Parameters
#### Request Body
- **language** (string) - Required - The programming language
- **framework** (string) - Required - The framework name

### Response
#### Success Response
- **error** (string) - Error message if setup fails
- **hint** (string) - Hint for fixing the error

#### Response Example
{
  "error": "",
  "hint": ""
}
```

--------------------------------

### adapter_setup

Source: https://github.com/guard-core/guard-core-mcp/blob/master/CLAUDE.md

Provides install command and verified minimal middleware integration for one adapter, with its engine's install and conformance status.

```APIDOC
## adapter_setup

### Description
Provides install command plus a verified minimal middleware integration for one adapter, with its engine's install and conformance status.

### Method
MCP Tool

### Endpoint
adapter_setup

### Parameters
- **language** (string) - Required - The programming language.
- **framework** (string) - Required - The framework name.

### Response
Returns a dictionary with install command, integration snippet, and conformance status.
```

--------------------------------

### Install @guardcore/fastify

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/adapters/fastify.md

Install the package using pnpm.

```bash
pnpm add @guardcore/fastify
```

--------------------------------

### Run advanced_app with Docker Compose

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/examples/example-app.md

Starts the advanced_app example (nginx, gunicorn, modular routers) from its directory with a build.

```bash
cd examples/advanced_app
docker compose up --build
```

--------------------------------

### Install dependencies via uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/integration.md

Install the required packages using uv.

```bash
uv add fastapi-guard guard-agent
```

--------------------------------

### Run Example App with Docker Container

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/index.md

Run the example container with default settings or with custom environment variables for Redis and IPInfo.

```bash
# Run with default settings
docker run --host 0.0.0.0 -p 8000:8000 ghcr.io/guard-core/fastapi-guard-example:latest

# Run with custom Redis connection
docker run --host 0.0.0.0 -p 8000:8000 \
 -e REDIS_URL=redis://your-redis-host:your-redis-port \
 -e REDIS_PREFIX=your-redis-prefix \
 -e IPINFO_TOKEN=your-ipinfo-token \
 ghcr.io/guard-core/fastapi-guard-example:latest
```

--------------------------------

### Complete example with whitelist, blacklist, and blocked countries

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/first-steps.md

Full example combining app creation, SecurityConfig with whitelist, blacklist, blocked countries, rate limiting, and middleware registration, plus a root endpoint.

```python
from fastapi import FastAPI
from guard import SecurityMiddleware, SecurityConfig, IPInfoManager

app = FastAPI()

config = SecurityConfig(
    geo_ip_handler=IPInfoManager("your_ipinfo_token_here"),
    enable_redis=True,  # Redis enabled
    redis_url="redis://localhost:6379",
    whitelist=["192.168.1.1", "2001:db8::1"],
    blacklist=["10.0.0.1", "2001:db8::2"],
    blocked_countries=["AR", "IT"],
    rate_limit=100,
    custom_log_file="security.log",
)

app.add_middleware(SecurityMiddleware, config=config)


@app.get("/")
async def root():
    return {"message": "Hello World"}
```

--------------------------------

### Install fastapi-guard with uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/installation.md

Recommended installation method using the uv package manager.

```bash
uv add fastapi-guard
```

--------------------------------

### Install tornadoapi-guard with uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/tornado.md

Install the pre-release version of the adapter and the guard-agent package using uv.

```bash
uv pip install "git+https://github.com/Guard-Core/tornadoapi-guard.git"
uv add guard-agent
```

--------------------------------

### Install optional dependency extras with uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/installation.md

Install guard-core with redis, cloud, and geo extras using uv.

```bash
uv add "guard-core[redis,cloud,geo]"
```

--------------------------------

### Full Fastify Integration Example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/adapters/fastify.md

A complete example showing configuration, plugin registration, and per-route rate limiting.

```typescript
import Fastify from 'fastify';
import {
  guardPlugin,
  configureCors,
  SecurityDecorator,
  SecurityConfigSchema,
} from '@guardcore/fastify';

const app = Fastify({ logger: true });

const config = SecurityConfigSchema.parse({
  enableRedis: true,
  redisUrl: 'redis://localhost:6379',
  rateLimit: 100,
  rateLimitWindow: 60,
  enablePenetrationDetection: true,
  enableCors: true,
  corsAllowOrigins: ['https://app.example.com'],
  blockedUserAgents: ['sqlmap', 'nikto'],
  excludePaths: ['/health'],
});

const guard = new SecurityDecorator(config);

await configureCors(app, config);
await app.register(guardPlugin, {
  config,
  guardDecorator: guard,
});

app.get('/health', async () => ({ status: 'ok' }));

const searchHandler = guard.rateLimit(20, 60)(async (request, reply) => {
  return { results: [] };
});

app.get('/api/search', searchHandler);

await app.listen({ port: 3000 });
```

--------------------------------

### Clone and install development environment

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/installation.md

Commands to clone the repository and install development dependencies.

```bash
git clone https://github.com/Guard-Core/guard-core.git
cd guard-core
make install-dev
```

--------------------------------

### versions tool call and response

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/tools.md

Example of invoking the versions tool and the resulting JSON response containing installed and bundled library versions.

```python
versions()
```

```json
{
  "guard_core_mcp": "1.3.0",
  "installed": {
    "guard-core": "4.2.0",
    "fastapi-guard": "8.0.2",
    "guard-agent": "3.1.0"
  },
  "docs_bundled_for": {
    "fastapi-guard": "8.0.2",
    "guard-agent": "3.1.0",
    "guard-core": "4.2.0",
    "guard-core-ts": "4.2.0"
  },
  "knowledge_bundled_for": {
    "guard-core-app": "2026.09.24",
    "guard-core-go": "4.2.0",
    "guard-core-php": "4.2.0",
    "guard-core-rs": "4.2.0",
    "guard-agent-go": "3.1.0",
    "guard-agent-php": "3.1.0",
    "guard-agent-rs": "3.1.0",
    "guard-agent-ts": "3.1.0"
  }
}
```

--------------------------------

### start()

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/api/core/src/interfaces/AgentHandlerProtocol.md

Starts the agent handler asynchronously. Returns a Promise that resolves when the agent has started.

```APIDOC
## start()

### Description
Starts the agent handler asynchronously.

### Method
start

### Signature
start(): Promise<void>

### Parameters
None

### Returns
Promise<void>
```

--------------------------------

### Initialize and start GuardAgent

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_knowledge/guard-agent-php/index.md

Configure the agent using AgentConfigResolver and start it to begin telemetry collection.

```php
$agent = new GuardAgent(AgentConfigResolver::resolve([
    'apiKey' => $_ENV['GUARD_API_KEY'],
    'endpoint' => 'https://api.guard-core.com',
    'projectId' => 'my-project',
    'payloadSigningSecret' => $_ENV['GUARD_SIGNING_SECRET'] ?? null,
]));

$agent->start();
```

--------------------------------

### Install fastapi-guard with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/installation.md

Standard installation method using pip.

```bash
pip install fastapi-guard
```

--------------------------------

### Run with uv and make

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/chatgpt-plugin.md

Sets up the environment with the hosted extra and required environment variables, then starts the server with make run-http.

```bash
uv sync --extra hosted
export GUARD_CORE_MCP_PUBLIC_URL=https://mcp.guard-core.com
export GUARD_CORE_MCP_OAUTH_ISSUER=https://api.guard-core.com
export GUARD_CORE_MCP_OAUTH_JWKS_URL=https://api.guard-core.com/.well-known/jwks.json
make run-http
```

--------------------------------

### Install guard-core-mcp with uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/installation.md

Install the package as a development dependency using uv.

```bash
uv add --dev guard-core-mcp
```

--------------------------------

### Install @guardcore/express

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/adapters/express.md

Install the package using pnpm.

```bash
pnpm add @guardcore/express
```

--------------------------------

### Install tornadoapi-guard with poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/tornado.md

Install the pre-release version of the adapter and the guard-agent package using poetry.

```bash
poetry add "git+https://github.com/Guard-Core/tornadoapi-guard.git"
poetry add guard-agent
```

--------------------------------

### Install flaskapi-guard with uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/flask.md

Use uv to install the required packages.

```bash
uv add flaskapi-guard guard-agent
```

--------------------------------

### Single Reverse Proxy Configuration

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/security/proxy-security.md

Example configuration for a single reverse proxy setup like Nginx or HAProxy.

```python
config = SecurityConfig(
    trusted_proxies=["10.0.0.1"],  # Your Nginx/HAProxy IP
    trusted_proxy_depth=1,  # One proxy
    trust_x_forwarded_proto=True,  # Trust HTTPS status from proxy
)
```

--------------------------------

### Install @guardcore/hono

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/adapters/hono.md

Install the package using pnpm.

```bash
pnpm add @guardcore/hono
```

--------------------------------

### Run Installation Test via CLI

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/installation.md

Execute the installation verification script using the python command.

```bash
python test_installation.py
```

--------------------------------

### Install guard-core-mcp with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/installation.md

Install the package using pip.

```bash
pip install guard-core-mcp
```

--------------------------------

### Install fastapi-guard with poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/installation.md

Installation method using the poetry package manager.

```bash
poetry add fastapi-guard
```

--------------------------------

### Install @guardcore/fastify adapter

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/getting-started/installation.md

Install the Fastify adapter package using your preferred package manager.

```bash
npm install @guardcore/fastify
pnpm add @guardcore/fastify
yarn add @guardcore/fastify
bun add @guardcore/fastify
```

--------------------------------

### Install guard-core-go v4.2.0 with go get

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_knowledge/guard-core-go/index.md

Install the guard-core-go module at version v4.2.0. The module is served under the /v4 major path, and the version is carried entirely by the git tag; there is no version constant in the Go source.

```sh
go get github.com/rennf93/guard-core-go/v4@v4.2.0
```

--------------------------------

### Install fastapi-guard and guard-agent

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/fastapi.md

Installation commands for common Python package managers.

```bash
uv add fastapi-guard guard-agent
```

```bash
poetry add fastapi-guard guard-agent
```

```bash
pip install fastapi-guard guard-agent
```

--------------------------------

### Load Balancer and Proxy Configuration

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/security/proxy-security.md

Example configuration for a multi-hop setup involving a load balancer and an internal proxy subnet.

```python
config = SecurityConfig(
    trusted_proxies=[
        "10.0.0.1",  # Load balancer IP
        "192.168.1.0/24",  # Internal proxy subnet
    ],
    trusted_proxy_depth=2,  # Two proxies in chain
    trust_x_forwarded_proto=True,
)
```

--------------------------------

### Install optional dependency extras with poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/installation.md

Install guard-core with redis, cloud, and geo extras using poetry.

```bash
poetry add "guard-core[redis,cloud,geo]"
```

--------------------------------

### Install Guard Agent with Framework Adapters using uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/installation.md

Use these commands to install the Guard Agent alongside specific framework adapters.

```bash
# FastAPI
uv add fastapi-guard guard-agent

# Flask
uv add flaskapi-guard guard-agent

# Django
uv add djapi-guard guard-agent

# Tornado
uv add tornadoapi-guard guard-agent
```

--------------------------------

### Install tornadoapi-guard with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/tornado.md

Install the pre-release version of the adapter and the guard-agent package using pip.

```bash
pip install "git+https://github.com/Guard-Core/tornadoapi-guard.git"
pip install guard-agent
```

--------------------------------

### Install @guardcore/express adapter

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/getting-started/installation.md

Install the Express adapter package using your preferred package manager.

```bash
npm install @guardcore/express
pnpm add @guardcore/express
yarn add @guardcore/express
bun add @guardcore/express
```

--------------------------------

### Full NestJS application with GuardModule and SecurityDecorator

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/adapters/nestjs.md

Complete example showing a NestJS application with a controller, module setup using GuardModule.forRoot with a parsed SecurityConfigSchema, and a bootstrap function.

```typescript
import { Module, Controller, Get, Post, Body } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import {
  GuardModule,
  SecurityDecorator,
  SecurityConfigSchema,
} from '@guardcore/nestjs';

const config = SecurityConfigSchema.parse({
  enableRedis: false,
  rateLimit: 100,
  rateLimitWindow: 60,
  enablePenetrationDetection: true,
  excludePaths: ['/health'],
});

const guard = new SecurityDecorator(config);

@Controller()
class AppController {
  @Get('/health')
  health() {
    return { status: 'ok' };
  }

  @Post('/api/data')
  createData(@Body() body: unknown) {
    return { received: true };
  }
}

@Module({
  imports: [
    GuardModule.forRoot({
      config,
      guardDecorator: guard,
    }),
  ],
  controllers: [AppController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}

bootstrap();
```

--------------------------------

### Full SecurityConfig initialization

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/configuration/security-config.md

Complete configuration example covering detection engine, security headers, Redis, agent, logging, and cloud refresh settings.

```python
# Full configuration
config = SecurityConfig(
    # Core settings
    passive_mode=False,
    # Detection engine
    enable_penetration_detection=True,
    detection_compiler_timeout=2.0,
    detection_max_content_length=10000,
    detection_preserve_attack_patterns=True,
    detection_semantic_threshold=0.7,
    detection_anomaly_threshold=3.0,
    detection_slow_pattern_threshold=0.1,
    detection_monitor_history_size=1000,
    detection_max_tracked_patterns=1000,
    # Security headers
    security_headers={
        "enabled": True,
        "hsts": {
            "max_age": 31536000,  # 1 year
            "include_subdomains": True,
            "preload": False,
        },
        "csp": {
            "default-src": ["'self'"],
            "script-src": ["'self'", "https://cdn.example.com"],
            "style-src": ["'self'", "'unsafe-inline'"],
            "img-src": ["'self'", "data:", "https:"],
            "connect-src": ["'self'", "https://api.example.com"],
            "frame-ancestors": ["'none'"],
            "base-uri": ["'self'"],
            "form-action": ["'self'"],
        },
        "frame_options": "DENY",
        "content_type_options": "nosniff",
        "xss_protection": "1; mode=block",
        "referrer_policy": "no-referrer",
        "permissions_policy": "geolocation=(), microphone=(), camera=()",
        "custom": {"X-Custom-Header": "CustomValue"},
    },
    # Redis
    enable_redis=True,
    redis_url="redis://localhost:6379",
    redis_prefix="guard_core:",
    # Agent
    enable_agent=True,
    agent_api_key="your-api-key",
    # Logging
    custom_log_file="security.log",
    log_suspicious_level="WARNING",
    log_format="json",
    # Cloud provider refresh
    cloud_ip_refresh_interval=1800,
)
```

--------------------------------

### Install flaskapi-guard with poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/flask.md

Use poetry to install the required packages.

```bash
poetry add flaskapi-guard guard-agent
```

--------------------------------

### Install FastAPI Guard with OTel support using uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/configuration/telemetry.md

Install fastapi-guard and guard-core with the otel extra using the uv package manager.

```bash
uv add fastapi-guard "guard-core[otel]"
```

--------------------------------

### Install guard-core-mcp with poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/installation.md

Install the package as a development dependency using poetry.

```bash
poetry add --group dev guard-core-mcp
```

--------------------------------

### Install djapi-guard with uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/django.md

Install the required packages using the uv package manager.

```bash
uv add djapi-guard guard-agent
```

--------------------------------

### Clone and Sync Development Environment

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/installation.md

Setup for contributors requiring source access.

```bash
git clone https://github.com/Guard-Core/guard-agent.git
cd guard-agent
uv sync --extra dev
```

--------------------------------

### Install optional dependency extras with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/installation.md

Install guard-core with redis, cloud, and geo extras using pip.

```bash
pip install "guard-core[redis,cloud,geo]"
```

--------------------------------

### Install dependencies via poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/integration.md

Install the required packages using poetry.

```bash
poetry add fastapi-guard guard-agent
```

--------------------------------

### Install @guardcore/hono adapter

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/getting-started/installation.md

Install the Hono adapter package using your preferred package manager.

```bash
npm install @guardcore/hono
pnpm add @guardcore/hono
yarn add @guardcore/hono
bun add @guardcore/hono
```

--------------------------------

### Install djapi-guard with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/django.md

Install the required packages using pip.

```bash
pip install djapi-guard guard-agent
```

--------------------------------

### SecurityDecorator Integration Example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/api/decorators.md

Example showing how to create a SecurityDecorator instance, apply decorators to routes, and integrate with SecurityMiddleware.

```APIDOC
## Integration with SecurityMiddleware

### Description
Shows how to create a SecurityDecorator instance, apply decorators to routes, and integrate with SecurityMiddleware.

### Example
```python
from fastapi import FastAPI
from guard import SecurityMiddleware, SecurityConfig
from guard import SecurityDecorator

app = FastAPI()
config = SecurityConfig(
    enable_ip_banning=True,
    enable_rate_limiting=True,
    rate_limit=100,
    rate_limit_window=3600,
)

# Create decorator instance
guard_deco = SecurityDecorator(config)


# Apply decorators to routes
@guard_deco.rate_limit(requests=10, window=300)  # Override: 10 requests/5min
@app.get("/api/limited")
def limited_endpoint():
    # Uses decorator-specific rate limiting
    return {"data": "limited"}


@app.get("/api/public")
def public_endpoint():
    # Uses global rate limiting (100 requests/hour)
    return {"data": "public"}


# Add global middleware
app.add_middleware(SecurityMiddleware, config=config)

# Set decorator handler on app state (required for integration)
app.state.guard_decorator = guard_deco
```
```

--------------------------------

### Install flaskapi-guard with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/flask.md

Use pip to install the required packages.

```bash
pip install flaskapi-guard guard-agent
```

--------------------------------

### Install @guardcore/nestjs with pnpm

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/adapters/nestjs.md

Install the NestJS adapter package using pnpm.

```bash
pnpm add @guardcore/nestjs
```

--------------------------------

### Install fastapi-guard and guard-core

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/release-notes.md

Commands to install or update the package and its required dependency.

```bash
uv add fastapi-guard
pip install -U fastapi-guard guard-core
```

--------------------------------

### Install djapi-guard with poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/django.md

Install the required packages using the poetry package manager.

```bash
poetry add djapi-guard guard-agent
```

--------------------------------

### NiceGUI app setup with guard_startup and SecurityMiddleware

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/first-steps.md

Use this snippet to integrate guard with a NiceGUI app. It adds the SecurityMiddleware with a SecurityConfig, registers a startup handler that calls guard_startup, and runs the UI. Note that app.on_startup takes a handler argument, not a decorator, and runs once at boot before connections are accepted.

```python
from nicegui import app, ui
from guard.lifespan import guard_startup
from guard.middleware import SecurityMiddleware
from guard_core.models import SecurityConfig

config = SecurityConfig(enable_redis=True, redis_url="redis://localhost:6379")
app.add_middleware(SecurityMiddleware, config=config)


async def _warm_up_guard() -> None:
    await guard_startup(app)


app.on_startup(_warm_up_guard)

ui.run()
```

--------------------------------

### Configure and start GuardAgent

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_knowledge/guard-agent-rs/index.md

Creates an AgentConfig with an API key (minimum 10 characters), sets endpoint, project ID, and payload signing secret, then creates a GuardAgent and starts it. The agent must be stopped at shutdown for the final flush.

```rust
let mut config = AgentConfig::new("your-api-key-at-least-10-chars");
config.endpoint = "https://api.guard-core.com".to_owned();
config.project_id = Some("proj_your-project".to_owned());
config.payload_signing_secret = Some("server-provided-signing-secret".to_owned());

let agent = GuardAgent::new(config).expect("valid configuration");
agent.start().await;
```

--------------------------------

### Install dependencies via pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/integration.md

Install the required packages using pip.

```bash
pip install fastapi-guard guard-agent
```

--------------------------------

### wire_agent(language, framework=None)

Source: https://github.com/guard-core/guard-core-mcp/blob/master/AGENTS.md

Telemetry agent setup for a language: install, snippet, buffer/flush/overflow/retry semantics, the ingestion contract, and a per-adapter integration note.

```APIDOC
## wire_agent(language, framework=None)

### Description
Telemetry agent setup for a language: install, snippet, buffer/flush/overflow/retry semantics, the ingestion contract, and a per-adapter integration note.

### Method
MCP Tool

### Endpoint
wire_agent

### Parameters
#### Request Body
- **language** (string) - Required - The programming language
- **framework** (string) - Optional - The framework name, defaults to None

### Response
#### Success Response
- **error** (string) - Error message if setup fails
- **hint** (string) - Hint for fixing the error

#### Response Example
{
  "error": "",
  "hint": ""
}
```

--------------------------------

### Install published tornadoapi-guard

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/tornado.md

Install the adapter and guard-agent using uv once the package is published to PyPI.

```bash
uv add tornadoapi-guard guard-agent
```

--------------------------------

### Install guard-agent with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/index.md

Use pip to install the guard-agent package.

```bash
pip install guard-agent
```

--------------------------------

### IPInfoManager Usage Example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/api/ipinfo-manager.md

A complete workflow showing initialization, country lookup, cleanup, and singleton behavior.

```python
from guard import IPInfoManager
from pathlib import Path

# Initialize with custom database location
ipinfo_db = IPInfoManager(
    token="your_token",
    db_path=Path("/custom/path/ipinfo.db"),  # default is ./data/ipinfo/country_asn.mmdb
)
await ipinfo_db.initialize()

# Get country for IP
country = ipinfo_db.get_country("8.8.8.8")
print(f"Country: {country}")  # Output: "US"

# Clean up
ipinfo_db.close()

# Get the same instance
same_db = IPInfoManager(token="your_token")  # Same instance returned
```

--------------------------------

### Install package with user scope

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/installation.md

Perform a user-scoped installation as a fallback for permission errors.

```bash
pip install --user guard-agent
```

--------------------------------

### Install FastAPI Guard with OTel support using poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/configuration/telemetry.md

Install fastapi-guard and guard-core with the otel extra using the poetry package manager.

```bash
poetry add fastapi-guard "guard-core[otel]"
```

--------------------------------

### Decorator Usage Examples

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/api/decorators.md

Examples showing best practices for decorator ordering, combining behavioral analysis, geographic controls, and content filtering.

```APIDOC
## Decorator Order Example

### Description
Shows the recommended order for applying multiple decorators to a single endpoint.

### Example
```python
@app.post("/api/admin/sensitive")
@guard_deco.require_https()  # Security requirement
@guard_deco.require_auth(type="bearer")  # Authentication
@guard_deco.require_ip(whitelist=["10.0.0.0/8"])  # Access control
@guard_deco.rate_limit(requests=5, window=3600)  # Rate limiting
@guard_deco.suspicious_detection(enabled=True)  # Monitoring
def admin_endpoint():
    return {"status": "admin action"}
```

## Combining Behavioral Analysis Example

### Description
Shows how to use multiple behavioral decorators for comprehensive monitoring.

### Example
```python
@app.get("/api/rewards")
@guard_deco.usage_monitor(max_calls=50, window=3600, action="ban")
@guard_deco.return_monitor("rare_item", max_occurrences=3, window=86400, action="ban")
@guard_deco.suspicious_frequency(max_frequency=0.1, window=300, action="alert")
def rewards_endpoint():
    return {"reward": "rare_item", "value": 1000}
```

## Geographic and Cloud Controls Example

### Description
Shows how to combine geographic and cloud provider controls.

### Example
```python
@app.get("/api/restricted")
@guard_deco.allow_countries(["US", "CA", "GB"])  # Allow specific countries
@guard_deco.block_clouds(["AWS", "GCP"])  # Block cloud providers
def restricted_endpoint():
    return {"data": "geo-restricted"}
```

## Content Filtering Example

### Description
Shows how to apply content filtering for upload endpoints.

### Example
```python
@app.post("/api/upload")
@guard_deco.content_type_filter(["image/jpeg", "image/png"])
@guard_deco.max_request_size(5 * 1024 * 1024)  # 5MB limit
@guard_deco.require_referrer(["myapp.com"])
def upload_endpoint():
    return {"status": "uploaded"}
```
```

--------------------------------

### Serve documentation locally

Source: https://github.com/guard-core/guard-core-mcp/blob/master/CONTRIBUTING.md

Build and view the project documentation using MkDocs.

```bash
make serve-docs
```

--------------------------------

### HandlerInitializer setup and initialization

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/api/security-middleware.md

Shows the initialization of the HandlerInitializer with required handlers and the subsequent call to initialize Redis and agent integrations.

```python
# In __init__
self.handler_initializer = HandlerInitializer(
    config=self.config,
    redis_handler=self.redis_handler,
    agent_handler=self.agent_handler,
    geo_ip_handler=self.geo_ip_handler,
    rate_limit_handler=self.rate_limit_handler,
    guard_decorator=self.guard_decorator,
)

# In initialize()
await self.handler_initializer.initialize_redis_handlers()
await self.handler_initializer.initialize_agent_integrations()
```

--------------------------------

### Authentication Flow Examples

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/decorators/authentication.md

Examples of login, token refresh, and logout endpoints using the authentication decorators.

```APIDOC
## Authentication Flow Examples

### Description
Examples of login, token refresh, and logout endpoints using the authentication decorators.

### Usage
#### Login Endpoint
```python
@app.post("/auth/login")
@guard_deco.require_https()
@guard_deco.require_headers(
    {"Content-Type": "application/json", "X-CSRF-Token": "required"}
)
def login(credentials: dict):
    # Validate credentials
    return {"token": "jwt_token", "expires": "3600"}
```

#### Token Refresh
```python
@app.post("/auth/refresh")
@guard_deco.require_https()
@guard_deco.require_auth(type="bearer")
@guard_deco.require_headers({"X-Refresh-Token": "required"})
def refresh_token():
    return {"token": "new_jwt_token", "expires": "3600"}
```

#### Logout
```python
# Logout endpoint not shown in source, but the pattern would be similar.
```
```

--------------------------------

### Install guard-core with OpenTelemetry extra using uv, poetry, or pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/architecture/telemetry.md

Install the guard-core package with the otel extra using your preferred package manager. The commands are equivalent alternatives for uv, poetry, and pip.

```bash
uv add "guard-core[otel]"
```

```bash
poetry add "guard-core[otel]"
```

```bash
pip install "guard-core[otel]"
```

--------------------------------

### Integration with SecurityMiddleware

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/api/decorators.md

Example showing how to initialize SecurityDecorator, apply route-specific overrides, and integrate with the global SecurityMiddleware.

```python
from fastapi import FastAPI
from guard import SecurityMiddleware, SecurityConfig
from guard import SecurityDecorator

app = FastAPI()
config = SecurityConfig(
    enable_ip_banning=True,
    enable_rate_limiting=True,
    rate_limit=100,
    rate_limit_window=3600,
)

# Create decorator instance
guard_deco = SecurityDecorator(config)


# Apply decorators to routes
@guard_deco.rate_limit(requests=10, window=300)  # Override: 10 requests/5min
@app.get("/api/limited")
def limited_endpoint():
    # Uses decorator-specific rate limiting
    return {"data": "limited"}


@app.get("/api/public")
def public_endpoint():
    # Uses global rate limiting (100 requests/hour)
    return {"data": "public"}


# Add global middleware
app.add_middleware(SecurityMiddleware, config=config)

# Set decorator handler on app state (required for integration)
app.state.guard_decorator = guard_deco
```

--------------------------------

### Install guard-core with uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/index.md

Use the uv package manager to add guard-core to your project.

```bash
uv add guard-core
```

--------------------------------

### Install @guardcore/nestjs adapter

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/getting-started/installation.md

Install the NestJS adapter package using your preferred package manager.

```bash
npm install @guardcore/nestjs
pnpm add @guardcore/nestjs
yarn add @guardcore/nestjs
bun add @guardcore/nestjs
```

--------------------------------

### Middleware integration example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/api/decorators.md

Example of integrating decorators with SecurityMiddleware, configuring SecurityConfig and applying decorators to routes.

```python
from guard_core import SecurityConfig
from guard_core.decorators import SecurityDecorator

config = SecurityConfig(
    enable_ip_banning=True,
    enable_rate_limiting=True,
    rate_limit=100,
    rate_limit_window=3600,
)

guard_deco = SecurityDecorator(config)


@guard_deco.rate_limit(requests=10, window=300)
@app.get("/api/limited")
def limited_endpoint():
    return {"data": "limited"}


@app.get("/api/public")
def public_endpoint():
    return {"data": "public"}


app.state.guard_decorator = guard_deco
```

--------------------------------

### Install FastAPI Guard with Logfire support using uv

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/configuration/telemetry.md

Install fastapi-guard and guard-core with the logfire extra using the uv package manager.

```bash
uv add fastapi-guard "guard-core[logfire]"
```

--------------------------------

### Start Restrictive, Then Open Up

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/decorators/access-control.md

Demonstrates the iterative process of adding security layers to an endpoint.

```python
# Start with company network only
@guard_deco.require_ip(whitelist=["10.0.0.0/8"])

# Then add specific external IPs
@guard_deco.require_ip(whitelist=["10.0.0.0/8", "203.0.113.100"])

# Finally add geographic controls
@guard_deco.allow_countries(["US", "CA"])
```

--------------------------------

### Install FastAPI Guard with OTel support using pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/configuration/telemetry.md

Install fastapi-guard and guard-core with the otel extra using pip.

```bash
pip install fastapi-guard "guard-core[otel]"
```

--------------------------------

### Install pre-commit hooks

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/installation.md

Installs hooks that run ruff format, ruff check, and mypy before every commit.

```bash
uv run pre-commit install
```

--------------------------------

### search_docs example call

Source: https://github.com/guard-core/guard-core-mcp/blob/master/docs/tools.md

An example of calling search_docs to find information about rate limiting.

```python
search_docs("rate limiting", "fastapi-guard", limit=3)
```

--------------------------------

### ContentPreprocessor Usage Example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/security/detection-engine/components.md

Demonstrates how to instantiate the ContentPreprocessor and process content to obtain a truncated string with attack patterns preserved.

```python
preprocessor = ContentPreprocessor(config)
processed = preprocessor.preprocess(long_content)
# Result: Truncated content with attack patterns preserved
```

--------------------------------

### wire_agent

Source: https://github.com/guard-core/guard-core-mcp/blob/master/CLAUDE.md

Provides telemetry agent setup for a language: install, snippet, buffer/flush/overflow/retry semantics, ingestion contract, and per-adapter integration note.

```APIDOC
## wire_agent

### Description
Provides telemetry agent setup for a language: install, snippet, buffer/flush/overflow/retry semantics, the ingestion contract, and a per-adapter integration note.

### Method
MCP Tool

### Endpoint
wire_agent

### Parameters
- **language** (string) - Required - The programming language.
- **framework** (string) - Optional - The framework name.

### Response
Returns a dictionary with agent setup instructions.
```

--------------------------------

### Install guardagent and optional dependencies

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_knowledge/guard-agent-ts/index.md

Use pnpm to install the guardagent package and the optional ioredis dependency for crash-recovery persistence.

```sh
pnpm add guardagent
pnpm add ioredis   # optional: crash-recovery persistence
```

--------------------------------

### HTTPS enforcement example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/decorators/authentication.md

Example of enforcing HTTPS for authentication endpoints.

```APIDOC
## HTTPS enforcement example

### Description
Example of enforcing HTTPS for authentication endpoints.

### Usage
@guard_deco.require_https()
@guard_deco.require_auth(type="bearer")

### Parameters
- **type** (string) - Required - Authentication type (e.g., "bearer")
```

--------------------------------

### Install FastAPI Guard with Logfire support using poetry

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/configuration/telemetry.md

Install fastapi-guard and guard-core with the logfire extra using the poetry package manager.

```bash
poetry add fastapi-guard "guard-core[logfire]"
```

--------------------------------

### Minimal Tornado application with Guard Agent

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/adapters/tornado.md

A complete example showing how to configure SecurityMiddleware, initialize the agent, and integrate it into a Tornado application.

```python
import asyncio
import os

import tornado.httpserver
import tornado.web
from tornadoapi_guard import SecurityConfig, SecurityDecorator, SecurityMiddleware


class RootHandler(tornado.web.RequestHandler):
    async def get(self) -> None:
        self.write({"message": "Hello, Guard!"})


def build_application(
    middleware: SecurityMiddleware, decorator: SecurityDecorator
) -> tornado.web.Application:
    return tornado.web.Application(
        [(r"/", RootHandler)],
        security_middleware=middleware,
        guard_decorator=decorator,
    )


async def main() -> None:
    api_key = os.environ.get("GUARD_API_KEY", "")
    project_id = os.environ.get("GUARD_PROJECT_ID", "")
    core_url = os.environ.get("GUARD_CORE_URL", "https://api.guard-core.com")

    security_config = SecurityConfig(
        # Security settings
        auto_ban_threshold=5,
        auto_ban_duration=300,
        enable_rate_limiting=True,
        rate_limit=100,
        rate_limit_window=60,

        # Agent telemetry
        enable_agent=bool(api_key),
        agent_api_key=api_key,
        agent_endpoint=core_url,
        agent_project_id=project_id,
    )

    security_middleware = SecurityMiddleware(config=security_config)
    guard_decorator = SecurityDecorator(security_config)
    security_middleware.set_decorator_handler(guard_decorator)

    # initialize() starts the agent (and everything else) on the current event loop.
    await security_middleware.initialize()

    app = build_application(security_middleware, guard_decorator)
    server = tornado.httpserver.HTTPServer(app)
    server.listen(8000, address="127.0.0.1")

    try:
        await asyncio.Event().wait()  # Run forever
    finally:
        await security_middleware.reset()


if __name__ == "__main__":
    asyncio.run(main())
```

--------------------------------

### Manual Logger Setup

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/tutorial/configuration/logging.md

Initialize the logger manually using setup_custom_logging, which is typically handled automatically by the middleware.

```python
from guard_core.utils import setup_custom_logging

# Manual setup (if needed outside of middleware)
# Console only (no file)
logger = setup_custom_logging(None)

# Console + file logging
logger = setup_custom_logging("security.log")

# The logger uses the "guard_core" namespace
# Individual handlers use sub-namespaces like:
# - "guard_core.handlers.redis"
# - "guard_core.handlers.cloud"
# - "guard_core.handlers.ipban"
```

--------------------------------

### CloudManager Usage Example

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/api/cloud-manager.md

Demonstrates how to use the cloud_handler singleton to check IP addresses and manage refreshes.

```python
from guard import cloud_handler

# The singleton instance is already created

# Check if IP is from AWS
is_aws = cloud_handler.is_cloud_ip("54.239.28.85", {"AWS"})

# Check multiple providers
is_cloud = cloud_handler.is_cloud_ip("35.186.224.25", {"AWS", "GCP", "Azure"})

# Refresh IP ranges manually if needed
await cloud_handler.refresh()  # Raises RuntimeError when Redis is enabled
await cloud_handler.refresh_async()  # Asynchronous with Redis

# Check when a provider was last refreshed
aws_updated = cloud_handler.last_updated["AWS"]
if aws_updated:
    print(f"AWS ranges last refreshed: {aws_updated.isoformat()}")
```

--------------------------------

### IPInfoManager initialize Method

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/fastapi-guard/api/ipinfo-manager.md

Initializes and downloads the database if required.

```python
async def initialize(self):
    """
    Initialize and download the database if needed.
    """
```

--------------------------------

### Custom check example: GeoFencingCheck

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core-ts/architecture/security-pipeline.md

Extends SecurityCheck to implement a geo-fencing check. Uses middleware.geoIpHandler to get the client's country and blocks requests from sanctioned countries with a 403 response. Demonstrates using this.sendEvent and this.createErrorResponse.

```typescript
import type { GuardRequest } from '@guardcore/core';
import type { GuardResponse } from '@guardcore/core';

class GeoFencingCheck extends SecurityCheck {
  get checkName(): string {
    return 'geo_fencing';
  }

  async check(request: GuardRequest): Promise<GuardResponse | null> {
    const geoIp = this.middleware.geoIpHandler;
    if (!geoIp) return null;

    const clientIp = resolvedClientIp(request);
    if (!clientIp) return null;

    const country = geoIp.getCountry(clientIp);
    if (country === 'SANCTIONED_COUNTRY') {
      await this.sendEvent(
        'geo_fence_blocked', request, 'request_blocked',
        `Blocked country: ${country}`,
      );
      return this.createErrorResponse(403, 'Access denied');
    }

    return null;
  }
}
```

--------------------------------

### Install guard-core with pip

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-core/index.md

Use this command to install guard-core using pip. Requires Python 3.10 or higher.

```bash
pip install guard-core
```

--------------------------------

### Install Pre-commit Hooks

Source: https://github.com/guard-core/guard-core-mcp/blob/master/guard_core_mcp/_docs/guard-agent/installation.md

Enable pre-commit hooks to maintain code quality.

```bash
pre-commit install
```