MI-ügynökök megfigyelése

Az MI-crawlerek — a GPTBottól a ClaudeBoton át a PerplexityBotig — nap mint nap olvassák a webhelyét, és a legtöbb üzemeltető ebből semmit sem lát. A megfigyelési mód a SilentShield MI-ügynök-kontrolljának 1. szintje: rögzíti, mely MI-szolgáltatások mely oldalakat látogatják — anélkül, hogy bármit blokkolna vagy megváltoztatná a webhelye működését.

A láthatóság megelőzi a kontrollt: csak ha tudja, ki olvassa a tartalmait, tud értelmesen dönteni arról, kit enged, korlátoz vagy blokkol. Ezért minden észlelés a három kategória egyikébe kerül:

Betanítás: A crawler a tartalmait gyűjti, hogy azokból jövőbeli MI-modelleket tanítsanak (pl. GPTBot, ClaudeBot, CCBot).
MI-keresés: A szolgáltatás oldalakat olvas, hogy a felhasználók kérdéseire válaszoljon, és közben forrásként hivatkozhat a webhelyére (pl. OAI-SearchBot, PerplexityBot).
Ügynökök: Egy bot valós időben, egy konkrét személy megbízásából jár el: például egy terméket kutat fel, vagy kitölt egy űrlapot a webhelyén (pl. ChatGPT-User, Claude-User).

Beállítás platformonként

WordPress

A beépített observer a SilentShield bővítmény egy közelgő frissítésével érkezik. Addig egy kis must-use bővítménnyel aktiválhatod a megfigyelést — egyetlen fájl, konfiguráció nélkül:

Hozd létre a wp-content/mu-plugins/silentshield-observer.php fájlt ezzel a tartalommal (a mu-pluginok automatikusan betöltődnek; a fájl törlésével kikapcsolható):

wp-config.phpphp

<?php
/**
 * Plugin Name: SilentShield — AI Agent Observer
 * Description: Reports AI crawler visits to SilentShield (fire-and-forget;
 * IP/UA are hashed server-side, GDPR). Delete this file to disable.
 *
 * Install: save this file as wp-content/mu-plugins/silentshield-observer.php
 * (mu-plugins load automatically — no activation needed). To force it off
 * without deleting: define('SILENTSHIELD_OBSERVER', false) in wp-config.php.
 * An upcoming SilentShield plugin update will build this in.
 */
if (!defined('ABSPATH')) exit;
if (defined('SILENTSHIELD_OBSERVER') && !SILENTSHIELD_OBSERVER) return;

const SS_OBSERVE_URL = "https://api.silentshield.io/api/v1/agent/telemetry";
const SS_API_KEY = "YOUR_API_KEY"; // publishable site key
// For the always-fresh list, cache https://api.silentshield.io/api/v1/agent/bot-directory daily.
$ss_bots = ["GPTBot","OAI-SearchBot","ChatGPT-User","ClaudeBot","Claude-User",
  "PerplexityBot","Perplexity-User","Bingbot","Applebot","Amazonbot","CCBot",
  "Bytespider","meta-externalagent","Google-Agent"];

register_shutdown_function(function () use ($ss_bots) {
  $ua = $_SERVER["HTTP_USER_AGENT"] ?? "";
  $signed = !empty($_SERVER["HTTP_SIGNATURE"]);
  $isBot = $signed;
  foreach ($ss_bots as $b) { if (stripos($ua, $b) !== false) { $isBot = true; break; } }
  if (!$isBot) return;

  if (function_exists("fastcgi_finish_request")) { fastcgi_finish_request(); }

  wp_remote_post(SS_OBSERVE_URL, [
    "timeout"  => 3,
    "blocking" => false,
    "headers"  => ["Content-Type" => "application/json", "x-api-key" => SS_API_KEY],
    "body"     => wp_json_encode(["sightings" => [[
      "ua"     => $ua,
      "ip"     => $_SERVER["REMOTE_ADDR"] ?? "",
      "path"   => strtok($_SERVER["REQUEST_URI"] ?? "/", "?"),
      "method" => $_SERVER["REQUEST_METHOD"] ?? "GET",
    ]]]),
  ]);
});

Next.js

Önálló middleware — SDK nélkül. A megfigyelés az event.waitUntil() hívással, a válaszúton kívül fut, így soha nem késlelteti az oldalaidat:

middleware.tstypescript

// middleware.ts — self-contained observer, no SDK required.
// Sightings are reported via event.waitUntil(), off the response path,
// so your pages never wait. Best-effort and fail-open by design.

import { NextResponse, type NextRequest } from "next/server";

const OBSERVE_URL = "https://api.silentshield.io/api/v1/agent/telemetry";
const API_KEY = "YOUR_API_KEY"; // publishable site key

// Known AI-agent UA tokens. For the always-fresh list, fetch
// https://api.silentshield.io/api/v1/agent/bot-directory once a day and cache it.
const BOTS = ["GPTBot", "OAI-SearchBot", "ChatGPT-User", "ClaudeBot", "Claude-User",
  "PerplexityBot", "Perplexity-User", "Bingbot", "Applebot", "Amazonbot", "CCBot",
  "Bytespider", "meta-externalagent", "Google-Agent"];

export function middleware(req: NextRequest, event: { waitUntil(p: Promise<unknown>): void }) {
  const ua = req.headers.get("user-agent") ?? "";
  const signed = !!req.headers.get("signature");
  if (signed || BOTS.some((b) => ua.toLowerCase().includes(b.toLowerCase()))) {
    const sighting = {
      ua,
      path: req.nextUrl.pathname,
      method: req.method,
      ip: req.headers.get("x-forwarded-for")?.split(",")[0]?.trim(),
      ...(signed && {
        signature: req.headers.get("signature"),
        signature_input: req.headers.get("signature-input"),
        signature_agent: req.headers.get("signature-agent"),
        authority: req.nextUrl.host,
        scheme: req.nextUrl.protocol.replace(":", ""),
      }),
    };
    event.waitUntil(
      fetch(OBSERVE_URL, {
        method: "POST",
        headers: { "Content-Type": "application/json", "x-api-key": API_KEY },
        body: JSON.stringify({ sightings: [sighting] }),
      }).catch(() => {}) // best-effort, fail-open
    );
  }
  return NextResponse.next();
}

Node.js (Express)

Expresshez (vagy bármely más Node-szerverhez) adjon hozzá egy fire-and-forget middleware-t. Csak azokat a kéréseket jelenti, amelyek User-Agentje ismert MI-ügynökre illik, vagy amelyek Web Bot Auth aláírást hordoznak — és soha nem blokkolja a választ:

server.jsjavascript

import express from "express";
const app = express();

const OBSERVE_URL = "https://api.silentshield.io/api/v1/agent/telemetry";
const API_KEY = "YOUR_API_KEY";

// Known AI-agent UA tokens. For the always-fresh list, fetch
// https://api.silentshield.io/api/v1/agent/bot-directory once a day and cache it.
const BOTS = ["GPTBot", "OAI-SearchBot", "ChatGPT-User", "ClaudeBot", "Claude-User",
  "PerplexityBot", "Perplexity-User", "Bingbot", "Applebot", "Amazonbot", "CCBot",
  "Bytespider", "meta-externalagent", "Google-Agent"];

// Fire-and-forget observer — never blocks the response.
app.use((req, res, next) => {
  const ua = req.headers["user-agent"] || "";
  const signed = !!req.headers["signature"];
  if (signed || BOTS.some((b) => ua.toLowerCase().includes(b.toLowerCase()))) {
    const sighting = {
      ua, ip: req.ip, path: req.path, method: req.method,
      ...(signed && {
        signature: req.headers["signature"],
        signature_input: req.headers["signature-input"],
        signature_agent: req.headers["signature-agent"],
        authority: req.headers["host"], scheme: req.protocol,
      }),
    };
    fetch(OBSERVE_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json", "x-api-key": API_KEY },
      body: JSON.stringify({ sightings: [sighting] }),
    }).catch(() => {}); // best-effort, fail-open
  }
  next();
});

PHP

Sima PHP esetén illessze be ezt a megfigyelőt a front controller legelejére. Az észlelést csak a válasz kiszállítása után küldi el (fastcgi_finish_request), így az oldal soha nem lassul:

observer.phpphp

<?php
// Drop-in observer: include at the very top of your front controller.
// It runs after the response is sent (fastcgi_finish_request) so it never
// slows down the page. Reuses the same publishable key.

const SS_OBSERVE_URL = "https://api.silentshield.io/api/v1/agent/telemetry";
const SS_API_KEY = "YOUR_API_KEY";
// For the always-fresh list, cache https://api.silentshield.io/api/v1/agent/bot-directory daily.
$ss_bots = ["GPTBot","OAI-SearchBot","ChatGPT-User","ClaudeBot","Claude-User",
  "PerplexityBot","Perplexity-User","Bingbot","Applebot","Amazonbot","CCBot",
  "Bytespider","meta-externalagent","Google-Agent"];

register_shutdown_function(function () use ($ss_bots) {
  $ua = $_SERVER["HTTP_USER_AGENT"] ?? "";
  $signed = !empty($_SERVER["HTTP_SIGNATURE"]);
  $isBot = $signed;
  foreach ($ss_bots as $b) { if (stripos($ua, $b) !== false) { $isBot = true; break; } }
  if (!$isBot) return;

  if (function_exists("fastcgi_finish_request")) { fastcgi_finish_request(); }

  $sighting = [
    "ua" => $ua,
    "ip" => $_SERVER["REMOTE_ADDR"] ?? "",
    "path" => strtok($_SERVER["REQUEST_URI"] ?? "/", "?"),
    "method" => $_SERVER["REQUEST_METHOD"] ?? "GET",
  ];
  $ch = curl_init(SS_OBSERVE_URL);
  curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 3,
    CURLOPT_HTTPHEADER => ["Content-Type: application/json", "x-api-key: " . SS_API_KEY],
    CURLOPT_POSTFIELDS => json_encode(["sightings" => [$sighting]]),
  ]);
  curl_exec($ch); // best-effort, fail-open
  curl_close($ch);
});

Go

Önálló observer néhány sorban — csak a standard könyvtár, SDK nélkül. Az észlelések fire-and-forget módon kerülnek elküldésre, így egyetlen kérés sem lassul:

main.gogo

// Self-contained observer — stdlib only, no SDK required.
// Reports AI-agent sightings fire-and-forget: never blocks a request,
// fail-open on any error. For the always-fresh bot list, cache
// https://api.silentshield.io/api/v1/agent/bot-directory daily.

const observeURL = "https://api.silentshield.io/api/v1/agent/telemetry"
const siteKey = "YOUR_API_KEY" // publishable — or os.Getenv("SILENTSHIELD_SITE_KEY")

var bots = []string{"GPTBot", "OAI-SearchBot", "ChatGPT-User", "ClaudeBot",
    "Claude-User", "PerplexityBot", "Perplexity-User", "Bingbot", "Applebot",
    "Amazonbot", "CCBot", "Bytespider", "meta-externalagent", "Google-Agent"}

func observe(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ua, signed := r.UserAgent(), r.Header.Get("Signature") != ""
        hit := signed
        for _, b := range bots {
            if strings.Contains(strings.ToLower(ua), strings.ToLower(b)) {
                hit = true
                break
            }
        }
        if hit {
            ip, _, _ := net.SplitHostPort(r.RemoteAddr)
            s := map[string]any{"ua": ua, "ip": ip, "path": r.URL.Path, "method": r.Method}
            if signed { // Web Bot Auth (RFC 9421) — forward for verification
                s["signature"] = r.Header.Get("Signature")
                s["signature_input"] = r.Header.Get("Signature-Input")
                s["signature_agent"] = r.Header.Get("Signature-Agent")
                s["authority"] = r.Host
            }
            body, _ := json.Marshal(map[string]any{"sightings": []any{s}})
            go func() { // best-effort, fail-open
                req, _ := http.NewRequest("POST", observeURL, bytes.NewReader(body))
                req.Header.Set("Content-Type", "application/json")
                req.Header.Set("x-api-key", siteKey)
                if resp, err := (&http.Client{Timeout: 3 * time.Second}).Do(req); err == nil {
                    resp.Body.Close()
                }
            }()
        }
        next.ServeHTTP(w, r)
    })
}

// net/http:  http.ListenAndServe(":8080", observe(mux))
// Gin:       srv := &http.Server{Addr: ":8080", Handler: observe(r)}
//            srv.ListenAndServe()

Kapcsolat tesztelése

Nem kell megvárnia az első valódi MI-crawlert ahhoz, hogy megbizonyosodjon az integráció működéséről. Küldjön egy üres köteget — ez heartbeatet regisztrál a kulcsához anélkül, hogy hamis észleléseket írna:

Terminalbash

curl -X POST https://api.silentshield.io/api/v1/agent/telemetry \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  --data '{"sightings":[]}'

Az API-kulcsa ügynökközpontja (API-kulcsok → kulcs kiválasztása → Ügynök) ezután „nincs csatlakoztatva” állapotról „csatlakoztatva — figyel” állapotra vált. A jelentése addig üres marad, amíg egy valódi ügynök nem látogat el: a SilentShield soha nem talál ki adatokat.

GDPR

A megfigyelés jogalapja a jogos érdek (GDPR 6. cikk (1) bek. f) pont). Az IP-címeket szerveroldalon, naponta cserélődő salttal hasheljük — nyers IP-cím soha nem kerül tárolásra. Az észleléseket 14 napig őrizzük meg, és egyáltalán csak az ismert MI-ügynökök kérései kerülnek tárolásra: a normál látogatói forgalmat soha nem rögzítjük.

GYIK

Lassítja ez a webhelyemet?

Nem. Minden integráció fire-and-forget: a Next.js az event.waitUntil()-t használja, a PHP csak a válasz kiszállítása után jelent, a Node és a Go a háttérben küld. És ha a SilentShield API egyszer nem lenne elérhető, a webhelye zavartalanul működik tovább — minden fail-open elven dolgozik.

Mi számít MI-ügynöknek?

Csak azok a kérések, amelyek illeszkednek a SilentShield ismert MI-crawlereket és -ügynököket tartalmazó botjegyzékére (GPTBot, ClaudeBot, PerplexityBot, …), vagy Web Bot Auth aláírást hordoznak. A mindig aktuális lista itt érhető el: https://api.silentshield.io/api/v1/agent/bot-directory.

Miért nem látok még adatokat?

Az MI-crawlerek a saját ütemezésük szerint érkeznek. A legtöbb webhelyen az első észlelések 24–72 órán belül megjelennek; kisebb webhelyeknél tovább tarthat. Addig is az ügynökközpontban látható heartbeat igazolja, hogy maga az integráció működik.

Következő: ügynökszabályok kikényszerítése (2. szint) →