### 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 @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
```

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

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

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

### 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": ""
}
```

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

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

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

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

### 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"}
```

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

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

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

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

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

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

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

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

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

### 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
)
```

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

### 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()
```

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

### 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,
)
```

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

### 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 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]"
```

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

### 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"
  }
}
```

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

### 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 });
```

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

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

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

### 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();
```

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

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

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

### Get performance statistics with sus_patterns_handler.get_performance_stats()

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

Retrieves performance statistics for suspicious patterns. The example output shows fields for slow patterns, problematic patterns, and a summary with total executions, average time, timeout rate, and match rate.

```python
# Get performance statistics
stats = await sus_patterns_handler.get_performance_stats()

# Example output
{
    "slow_patterns": [...],  # Patterns exceeding threshold
    "problematic_patterns": [...],  # Patterns with issues
    "summary": {
        "total_executions": 10000,
        "average_time": 0.002,
        "timeout_rate": 0.001,
        "match_rate": 0.05,
    },
}
```

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

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

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

### 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 @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 @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
```