AI Engineering & GEO Glossary

A website optimization methodology targeting generative AI engines (ChatGPT, Perplexity, Claude) — the goal is to be correctly crawled, understood, and cited by AI. Unlike SEO which targets search engine spiders, GEO targets AI engines.

A deep learning model based on the Transformer architecture, trained on massive text corpora to understand and generate natural language. Notable models include GPT series, Claude series, Qwen, DeepSeek, and others.

A JSON-based structured data format for embedding machine-readable semantic information in web pages. Search engines and AI engines use JSON-LD to understand entity types (Organization, Article, FAQ, Product, etc.).

A structured data vocabulary jointly initiated by Google, Microsoft, Yahoo and Yandex, defining hundreds of entity types and properties. JSON-LD is the recommended implementation method for Schema.org.

A content structure where the core conclusion comes first, followed by supporting arguments. AI engines prioritize content at the beginning of a page — BLUF structure increases the probability of being correctly cited, making it a key GEO content strategy.

A text file placed at the website root that provides a site guide for AI agents (e.g., ChatGPT and Claude crawlers), listing core pages and crawling rules. It complements robots.txt in GEO infrastructure.

An automated program used by AI engines to crawl web content. Unlike search engine crawlers (Googlebot, Bingbot), AI crawlers (GPTBot, ClaudeBot, PerplexityBot) primarily collect data for LLM training and inference.

An AI architecture combining information retrieval with text generation. The LLM first retrieves relevant documents from an external knowledge base, then injects the results as context into the prompt — reducing hallucinations and improving timeliness and accuracy.

The basic unit of text processing in LLMs. A token can be a word, subword, or character. In Chinese, one character typically corresponds to 1-2 tokens. Tokens are also the billing unit for API calls — both input and output are charged per token.

The practice of designing input text (prompts) to guide LLMs toward desired outputs. Techniques include Few-shot (providing examples), Chain-of-Thought (guiding reasoning steps), and System Prompt (setting role and behavior boundaries).

Machine-readable data embedded in web pages in standardized formats (JSON-LD, Microdata), helping search engines and AI engines understand page content. Core types include Organization, WebPage, Article, FAQPage, BreadcrumbList, and DefinedTermSet.

A build-time approach that pre-renders all pages into static HTML files, requiring no server-side runtime at deploy time. Frameworks like Astro, Next.js (static export), Hugo, and 11ty support SSG. Static sites are most AI-crawler-friendly — content is fully readable without JavaScript.

An HTML language annotation attribute that tells search engines and AI engines the relationship between different language versions of the same content. Correct hreflang configuration prevents multilingual sites from being flagged as duplicate content.

A declaration in the HTML head (`<link rel="canonical">`) specifying the authoritative version URL of the current page. When the same content is accessible via multiple URLs, canonical tells search engines and AI engines which one is the original source.

A file (sitemap.xml) listing all important page URLs, last modification times, and update frequencies. Search engines and AI crawlers use sitemaps to discover and index site content — a standard GEO infrastructure component.

A Schema.org structured data type for FAQ pages. Each Q&A pair (Question + Answer) is independently marked, allowing AI engines to directly cite FAQ answers when answering related questions. One of the most directly effective structured data types for GEO.

A structured knowledge base organized around entities and their relationships. Search engines and AI engines use knowledge graphs to understand entity associations. Websites can output entity relationships via JSON-LD to help AI engines build more accurate knowledge connections.

A technique for mapping unstructured data (text, images) into high-dimensional vector spaces. Semantically similar texts are closer in vector space. Embeddings are the foundation of RAG, semantic search, and recommendation systems.

Further training a pre-trained LLM on domain-specific data to improve performance on specific tasks. The key difference from RAG: fine-tuning changes model parameters; RAG changes only the input context without modifying parameters.

A database specialized for storing and retrieving high-dimensional vectors (embeddings), supporting approximate nearest neighbor (ANN) search with indexes like HNSW and IVF. Mainstream choices: Qdrant (fastest adoption, simplest ops), Milvus (distributed, billion-scale), pgvector (reuse existing PostgreSQL), Elasticsearch (full-text + vector in one). The core storage component of RAG knowledge bases.

The process of splitting long documents into retrieval units (chunks) along semantic boundaries. Production practice: split by heading hierarchy and paragraph boundaries, overlap adjacent chunks by 50-100 characters, keep chunks at 200-1000 characters. Chunking quality directly determines retrieval recall — hard-splitting by fixed character count cuts semantic units in half and is the most common RAG pitfall.

A retrieval strategy combining vector search (semantic similarity) with keyword search (BM25 exact match). Vector search handles "asked a different way" semantics; keyword search handles exact matches like contract clause numbers and model names. Merged results are typically reranked — the standard configuration for production RAG.

A model that re-orders initial retrieval results, typically a cross-encoder (e.g. bge-reranker) that scores each query-document pair to surface what truly matters. Small VRAM footprint (a few GB) with outsized retrieval gains — the highest-ROI investment in the RAG pipeline.

A classic keyword retrieval ranking algorithm scoring documents by term frequency (TF) and inverse document frequency (IDF). Complementary to vector search: vectors handle semantic similarity, BM25 handles exact matches (numbers, proper nouns, abbreviations). Lucene/Elasticsearch default relevance is based on improved BM25.

Rewriting the user's raw question before retrieval to fix failures caused by colloquial references and vague wording. E.g. "is that policy from last time still valid?" → "policy validity 2026". Implementable with a small model or rules; noticeably improves hit rate and is a common preprocessing step in production RAG.

An information retrieval metric measuring where the first correct answer appears in results. MRR = 1/rank — rank 1 scores 1.0, rank 5 scores 0.2. Used with recall to evaluate RAG retrieval quality: below 80% recall, optimize retrieval before touching generation.

An architecture where multiple specialized AI agents collaborate to complete complex tasks. Three signals you need it: ① independent subtasks that can run in parallel; ② different steps needing different tool sets with permission isolation; ③ adversarial generate→review loops. More flexible but with significantly higher token cost and debugging difficulty — prefer a single agent for fixed processes.

Also called Function Calling. The mechanism by which an LLM selects and invokes external functions/APIs. The model emits a structured call (function name + arguments) that the application executes and returns the result of. Design points: single-purpose tools, clear parameter descriptions (the model decides when to call from them), structured return values, and exceptions explicitly returned to the model rather than swallowed.

The standard agent execution loop: think (Reason) → call a tool (Act) → observe the result → think again until the task completes. ReAct grounds each step in tool results, correcting judgment as it goes — the foundational mechanism for reducing hallucination: answers must cite tool-call evidence, and evidence-free answers should be rejected.

Structuring multiple agents/steps into a workflow by dependency. Three mainstream patterns: linear pipeline (fixed order, most predictable), DAG graph orchestration (parallelism, branches and joins — the production default), and Planner-Executor (dynamic task decomposition, most flexible but least predictable). Order: use a pipeline when you can, a DAG when you must, planner-executor only when nothing else fits.

An agent orchestration framework by the LangChain team that describes workflows as graphs, with state persistence, checkpoint recovery, parallelism and conditional branching. Suited to engineering-capable teams building production multi-agent systems — the productionization path after Dify validation.

An open-source LLM application development platform with visual drag-and-drop orchestration for agent workflows, RAG pipelines and conversational apps, plus model integration, tooling, monitoring and publishing. Fits fast business-flow validation; deep customization (complex state, custom scheduling) hits a wall, and production multi-agent often migrates to LangGraph.

Breaking a complex goal into an executable sequence of subtasks. Granularity directly affects success rate and cost: too coarse and the model cannot execute; too fine and token overhead explodes. In multi-agent systems the planner handles decomposition and dispatch — the first quality gate in agent engineering.

The mechanism where an agent reviews its own output after generation, or has an independent reviewer agent validate it: checking whether citations are real, conclusions contradict data, or key constraints are missed — rolling back on error. Reflection cannot eliminate hallucination, but together with evidence chains and human fallback it forms the three-layer hallucination-control structure.

An open protocol proposed by Anthropic that defines a standardized interaction method between AI models and external tools/data sources. MCP enables LLMs to safely call APIs, query databases, and read/write files — infrastructure for AI agents.

An automated software delivery practice. CI means frequently merging code changes into the main branch with automated testing; CD means deploying verified code to production through an automated pipeline. GitHub Actions and GitLab CI are mainstream CI/CD tools.

A containerization platform that packages applications and their dependencies into lightweight, portable containers, ensuring consistent operation across different environments. Docker Compose orchestrates multi-container applications (e.g., web service + database + cache) and is the mainstream choice for small-to-medium project deployment.

A specification standard for describing RESTful APIs (formerly the Swagger specification). OpenAPI spec files enable auto-generation of API documentation, client SDKs, and mock servers — the core tool for contract-first API development.

An architectural pattern that decomposes an application into multiple independently deployable services, each corresponding to a business subdomain, communicating via lightweight protocols (REST/gRPC/message queues). Microservices enable independent deployment, scaling, and teams, but introduce distributed transactions and service governance complexity.

An intermediary layer between clients and backend services, handling cross-cutting concerns such as request routing, authentication, rate limiting, circuit breaking, and protocol translation. In multi-provider Token aggregation scenarios, the API gateway also handles routing decisions (distributing requests by price/latency) and fault tolerance (circuit breaking and degradation).

An open-source automated tool by Google for auditing web page quality across five dimensions: Performance, Accessibility, SEO, Best Practices, and PWA. Lighthouse scores serve as a key reference metric for measuring frontend performance optimization effectiveness.

A set of core web performance metrics defined by Google, including LCP (Largest Contentful Paint, measuring loading performance), CLS (Cumulative Layout Shift, measuring visual stability), and TBT (Total Blocking Time, measuring interactivity). These metrics directly impact search rankings and user experience scores.

A next-generation image format developed by Google, supporting both lossy and lossless compression, transparency, and animation. Compared to PNG, WebP lossless compression averages 26% smaller; compared to JPEG, lossy compression averages 25-34% smaller. All images on this site have been converted from PNG to WebP, achieving 89% total size reduction.

A rendering pattern where pages are rendered into complete HTML on the server before being sent to the client. The key difference from SSG (Static Site Generation): SSR generates HTML dynamically on each request, suitable for pages needing real-time data; SSG pre-generates HTML at build time, suitable for relatively static content. Next.js supports both SSR and SSG modes.

A high-performance web server and reverse proxy server, also commonly used for load balancing, HTTP caching, SSL termination, and static file serving. This site uses Nginx as the front-end server, handling HTTPS termination, static asset serving, security header injection, and reverse proxy configuration.

An open standard (RFC 7519) for securely transmitting information between parties as a JSON object. JWT consists of three parts: Header, Payload, and Signature. It is commonly used for API authentication and authorization. Stateless (no server-side session storage needed), but cannot be actively revoked — suitable for short-lived token scenarios.

An open standard for access delegation, allowing users to grant third-party applications access to specific resources without sharing their passwords. OAuth 2.0 defines four authorization flows: Authorization Code (most common, for third-party apps), Client Credentials (service-to-service), Password (first-party apps, not recommended), and Implicit (deprecated, replaced by PKCE).

An HTTP-header-based mechanism that allows a server to declare which origins (domain, protocol, port) are permitted to access its resources. Browsers block cross-origin requests by default; CORS safely relaxes this restriction by setting Access-Control-Allow-Origin headers. Production environments should configure CORS as a whitelist, allowing only trusted origins.

A protocol enabling full-duplex communication over a single TCP connection. Unlike HTTP's request-response model, WebSocket allows both client and server to push data at any time after the connection is established. Suitable for chat, real-time collaboration, and gaming scenarios requiring low-latency bidirectional communication. Higher implementation complexity — requires connection management, heartbeats, and horizontal scaling.

A lightweight real-time communication protocol based on HTTP, allowing servers to push data to clients over a long-lived connection. Clients use the EventSource API to receive pushes. Compared to WebSocket, SSE is simpler to implement, has native browser auto-reconnection, but only supports unidirectional communication (server to client). Suitable for notifications, data push, and log streams.

An event-driven callback mechanism where a server sends an HTTP POST request to a pre-registered URL when a specific event occurs. Unlike long-lived connections, Webhooks are short-lived callbacks that require no persistent connection and scale horizontally by nature. Commonly used for payment callbacks, CI/CD notifications, and third-party event subscriptions. Requires retry logic and signature verification for reliability.

An open-source programming language developed by Microsoft that extends JavaScript with a static type system. TypeScript performs type checking at compile time, catching type errors early and improving code maintainability and refactoring safety. The frontend of this site is written in TypeScript with Astro and Tailwind CSS.

An open-source in-memory data structure store supporting strings, hashes, lists, sets, and sorted sets. Commonly used for caching, session management, message queues, and real-time leaderboards. Known for sub-millisecond read/write latency and rich data structures — the most popular caching layer solution in web applications.

A powerful open-source relational database management system known for ACID transaction support, extensibility, and SQL standard compliance. Supports JSON data types, full-text search, geospatial data (PostGIS), and window functions. The primary database choice for this site's backend services.

An API query language and runtime developed by Facebook, allowing clients to precisely specify the data structure they need, avoiding over-fetching and under-fetching. Unlike REST, GraphQL serves through a single endpoint with the client declaring required fields in the query. Suitable for multi-client aggregation and fast-iterating frontend scenarios.

A high-performance remote procedure call (RPC) framework developed by Google, based on HTTP/2 and Protocol Buffers serialization. Unlike REST's JSON text transport, gRPC uses binary serialization for higher performance, suitable for high-frequency internal service-to-service calls. Supports bidirectional streaming — a mainstream communication protocol in microservice architectures.

The secure version of HTTP, adding a TLS/SSL encryption layer underneath HTTP to ensure data confidentiality, integrity, and server identity verification. HTTPS prevents man-in-the-middle attacks, data tampering, and eavesdropping. Every production website and API should enforce HTTPS. This site uses Let's Encrypt certificates with automatic renewal.

The process of improving the internal structure of code without changing its external behavior. The core principle is small steps — one refactoring operation at a time, running tests after each step to ensure behavior is unchanged.

The strategy for identifying and managing different versions of an API. Common strategies include URL path versioning (/v1/users), header versioning, and parameter versioning. URL path versioning is recommended for its transparency.

The practice of transforming data into visual formats (charts, graphs) to make patterns and trends immediately understandable. Key principles include choosing the right chart type, maintaining a high data-ink ratio, and using colorblind-friendly palettes.

A powerful open-source JavaScript charting library by Baidu, offering 60+ chart types. Uses Canvas rendering for large dataset performance. The most popular data visualization library in the Chinese ecosystem.

A JavaScript library for producing dynamic, interactive data visualizations by binding data to the DOM. Offers maximum flexibility with a steep learning curve. Best suited for highly customized visualizations.

The ability of a newer API version to work correctly with older clients. Compatible changes include adding fields and optional parameters; incompatible changes include removing fields and changing field types. Good API design maximizes backward compatibility.

A lightweight documentation method for recording architecture decisions — context, alternatives, final choice, and consequences. ADRs are version-controlled alongside the codebase under docs/adr/, numbered sequentially. The core value is helping future team members understand "why was this chosen" months later.

A software development process with a "red-green-refactor" cycle: write a failing test (red), write the minimum code to pass the test (green), then refactor for optimization. The value of TDD is not "write tests first" — it is "think about expected behavior before writing code."

A network of geographically distributed edge servers that cache content closer to end users, accelerating content delivery. CDNs significantly reduce user latency, reduce origin server load, and provide DDoS protection. Popular CDN providers include Cloudflare, Alibaba Cloud CDN, and AWS CloudFront.

The practice of designing products, devices, services, or environments to be usable by as many people as possible, with particular focus on users with disabilities. Core frontend a11y practices include: semantic HTML, ARIA labels, keyboard navigation, color contrast (WCAG 2.1 AA requires text ≥ 4.5:1), and screen reader support.

An open-source log management solution. Elasticsearch handles log storage and full-text search, Logstash handles log collection and transformation, Kibana handles log visualization and querying. ELK indexes log content for full-text search — flexible queries but higher storage cost. Suitable for scenarios requiring full-text search and complex aggregation analysis.

An asynchronous communication mechanism for passing messages between services. Core model: producers send messages to a queue, consumers receive messages from the queue. Mainstream message queues include RabbitMQ (queue model, best for task distribution), Kafka (log model, best for event streams), and Redis Streams (lightweight, best for simple scenarios).

The process of migrating database schemas or data from one structure to another. The key to zero-downtime migration is "dual-running" — having old and new structures coexist while the application layer is compatible with both. Popular tools: gh-ost (MySQL), pgroll (PostgreSQL).

A technique for modifying table structures without stopping database service. Works by creating a shadow table, syncing incremental changes (via trigger or binlog), then atomically swapping table names. gh-ost uses binlog streaming without triggers, putting less load on the primary.

A measurable goal for system service quality, defined from the user perspective. Common SLOs include API availability (≥ 99.9%), response time P99 (≤ 500ms), and data freshness (≤ 5 min). SLOs are the foundation of a monitoring and alerting system — alert only on SLO violations.

A state where operators become desensitized due to receiving too many irrelevant alerts, eventually missing critical ones. Mitigation strategies: SLO-driven alerting (alert only on user-perceivable anomalies), dependency inhibition (auto-suppress dependent alerts), and group aggregation (merge similar alerts into one notification).

The daily quota of pages a search engine crawler will crawl for a specific site. If a site has many low-value pages (duplicate content, parameterized URLs), the crawler wastes budget on those. Management: use robots.txt and noindex to block low-value pages, focusing crawler attention on core content.

Google Quality Rater Guidelines framework. While not a direct ranking algorithm factor, content quality signals affect rankings. Improve by: attributing articles to real authors, citing authoritative sources, displaying team credentials, keeping content update dates visible, and maintaining complete contact and About pages.

A build optimization that automatically removes unused code during bundling. Relies on ES Module static analysis — at bundle time, the tool identifies and eliminates code that was imported but never called. All major 2026 build tools (Vite, Webpack, Turbopack) support Tree Shaking by default.

A technique that splits application code into multiple independent chunks for on-demand loading. The most common granularity is route-level splitting — code for each route is loaded only when the user visits that route. Vite and Webpack both automatically split dynamic imports (import()) into separate files.

A software architecture pattern where events serve as the core communication mechanism. Components do not call each other directly but communicate asynchronously by publishing and subscribing to events. EDA's core advantage is loose coupling — the sender does not need to know who consumes the event or whether consumption succeeds. Typical implementations include message queues (RabbitMQ) and event streams (Kafka).

An asynchronous communication mechanism for passing messages between services. Core model: producers send messages to a queue, consumers receive messages from the queue. Mainstream message queues include RabbitMQ (queue model, best for task distribution), Kafka (log model, best for event streams), and Redis Streams (lightweight, best for simple scenarios).

A message model where events are durably stored in a log. Unlike message queues, events in a stream are not deleted after consumption but retained until expiry, allowing consumers to replay at any point. Apache Kafka is the representative implementation, known for high throughput and persistence.

A data persistence pattern that records state changes as a sequence of events rather than storing the current state. To get the current state, all historical events must be replayed. Advantages include a complete audit log, time travel (reconstructing any historical state), and event-driven architecture support. Drawbacks include consistency latency and event schema version management complexity.

A pattern for managing distributed transactions in microservice architectures. A Saga splits a large transaction into multiple local transactions, each publishing an event to trigger the next step. If a step fails, the Saga executes compensating transactions to roll back completed steps. Two orchestration approaches: choreography (event-driven) and orchestration (central coordinator).

A design pattern that protects distributed systems from cascading failures. The circuit breaker monitors downstream call failure rates — when the rate exceeds a threshold, it "opens" the circuit, and subsequent requests return errors immediately without actually calling the downstream service, giving it time to recover. Three states: closed (normal), open (fast-fail), half-open (probing recovery).

A fault isolation design pattern named after a ship's bulkhead compartments — one leaking compartment does not sink the entire ship. In systems, Bulkhead isolates failures by allocating independent thread pools or connection pools to different components. When one component exhausts its resources, only that component is affected.

The property of an operation producing the same result whether executed once or multiple times. In distributed systems, network glitches and retries may cause duplicate message delivery, so consumers must be idempotent. Common implementations: naturally idempotent operations (SET key = value), dedup tables (event ID unique constraint), optimistic locking (version checking), and state machines.

A flow control mechanism where consumers actively signal back to producers when processing speed cannot keep up with production rate, causing producers to slow down or pause. Backpressure is a core mechanism in Reactive Systems, preventing consumers from being overwhelmed by data floods. In Kafka, consumers control backpressure via max.poll.records and fetch.max.bytes parameters.

A technique for tracking the complete path of a request across microservices. Each request receives a unique Trace ID at the entry point, propagated via headers across service boundaries. A Trace ID chains all service calls a request passes through, enabling rapid identification of performance bottlenecks and failure points. Jaeger and Zipkin are mainstream distributed tracing systems.

A zero-downtime deployment strategy maintaining two identical production environments (Blue and Green). Only one environment serves production traffic at any time. The new version is deployed to the idle environment; once verified, the traffic gateway instantaneously switches (updating routes/load balancer), with the old environment retained as rollback capacity. The switch is instantaneous with no gradual rollout window.

A gradual rollout strategy that first deploys the new version to a small subset of instances (e.g., 5%), monitors health and error rates for a period, then gradually increases the traffic percentage to 100% if no anomalies are detected. If issues are found, traffic can be immediately redirected back to the old version. More granular but has a longer rollout cycle compared to Blue-Green Deployment.

A technique for controlling feature visibility at runtime without requiring code redeployment. Common use cases include: canary launches (enabling new features for specific users or regions), A/B testing (random group testing), and operational toggles (emergency feature disable). LaunchDarkly and Unleash are dedicated feature flag management platforms.

A system design strategy where, when some components or dependencies become unavailable, the system continues serving at a reduced functionality level rather than crashing outright. Examples: fall back to popular rankings when recommendation service is down, show placeholder images when image loading fails, postpone feature activation when payment is unavailable. Degradation strategies should be predefined during architecture design, not improvised during an outage.

A system protection mechanism that limits the number of requests allowed within a specified time window. Common algorithms: Token Bucket (allows bursts), Leaky Bucket (processes requests at a constant rate), and Sliding Window (precise counting). Rate limiting dimensions include IP, user ID, and API Key. API gateways (Kong, APISIX) typically have built-in rate limiting plugins.

A mechanism for detecting whether a service instance is functioning properly. Two types: Liveness Probe (whether the service process is still running) and Readiness Probe (whether the service can handle requests). Kubernetes uses Pod health checks to decide whether to restart containers or remove traffic. Health check endpoints typically return 200 OK or JSON-formatted status details.

An architectural pattern where auxiliary functions (logging, monitoring, proxy, configuration) are extracted from the main application into separate companion containers. The sidecar shares the same network and storage volumes as the main application but is deployed and updated independently. Service Mesh (Istio) Envoy proxies are classic sidecar implementations — application code does not need to be aware of the service mesh.

A distributed systems algorithm that selects one leader among multiple replicas to handle write operations or coordinate tasks while others remain as followers. If the leader crashes, a new election is automatically triggered. ZooKeeper, etcd, and Redis Sentinel all provide Leader Election capabilities. Algorithms include Paxos, Raft, and Bully.

An algorithm for achieving agreement on a single value among multiple nodes in a distributed system. Consensus algorithms are the foundation of distributed reliability — used in leader election, distributed locking, and atomic broadcast. The most famous are Paxos (rigorous theory, implemented in Chubby/ZooKeeper) and Raft (easier to understand, implemented in etcd/Consul).

The fundamental theorem of distributed system design stating that a distributed system can satisfy at most two of three properties simultaneously: Consistency, Availability, and Partition Tolerance. In practice, Partition Tolerance is mandatory, so the trade-off is between Consistency and Availability.

A process that moves data from source through extraction, transformation, and loading stages to a destination. Data pipelines typically involve source extraction → cleaning → transformation → loading into a data warehouse, running on batch schedules or real-time stream processing. Apache Kafka, Apache Flink, and Apache Airflow are common data pipeline tooling.

A distributed system consistency model where replicas may temporarily hold different data values, but given enough time without new updates, all replicas will eventually converge to the same state. Eventual consistency contrasts with strong consistency and is the core of BASE theory. In event-driven architectures, read models typically lag behind write models by seconds to minutes.

An architectural style oriented toward elasticity and responsiveness, following four core principles: Responsive (responding in a timely manner), Resilient (remaining available under failure), Elastic (automatically scaling with load), and Message Driven (async message passing for loose coupling and backpressure). The Reactive Manifesto defines the core philosophy of reactive systems.

In Saga patterns, an operation that undoes previously completed steps when a step fails. A compensating transaction does not "restore to original state" — other operations may have occurred in between — but rather "counteracts" the effects of the previous operations. Example: issuing a refund after a failed debit (not "reverse-debiting"), restoring inventory after order cancellation (not "changing order status"). Compensating transactions must be idempotent.

A core metric for measuring system throughput. Capacity planning typically distinguishes between average QPS and peak QPS. Average QPS = total daily requests / 86400, peak QPS = average QPS × peak factor (5-8 depending on business type). Load test targets are typically set at 3-5× peak QPS to allow headroom.

The latency value below which 99% of requests complete. P99 is more indicative of real user experience than averages — averages can be pulled down by the majority, masking a small percentage of slow requests. P99 exceeding 1000ms at more than 5% frequency should trigger alerting. Related metrics include P50 (median) and P95 (95th percentile).

A key performance metric for AI inference, measuring the time from submitting a request to receiving the first output token. TTFT directly impacts perceived response speed. For streaming output, TTFT should be kept under 500ms. Factors affecting TTFT include model size, hardware configuration, batching strategy, and KV Cache hit rate.

A key performance metric for AI inference, measuring the average time required to generate each output token. TPOT determines generation speed — a 500-token output at 10ms TPOT takes 5 seconds. TPOT is affected by GPU compute, memory bandwidth, quantization method, and batch size.

Validating system performance under expected load by simulating real user requests. The testing pyramid: component-level (single endpoint/query) → module-level (single service) → full-chain (end-to-end). Common tools: wrk (lightweight HTTP), k6 (scenario scripting), pgbench (database), vLLM benchmark_serving.py (AI inference). Must cover baseline, limit, endurance, and burst testing scenarios.

A common database performance bottleneck where all database connections are occupied and new requests time out waiting for a connection. At 350 QPS, a connection pool of 50-80 is recommended. Causes include slow queries holding connections too long, connection leaks (incorrectly returned connections), or burst traffic exceeding pool capacity. Monitoring pool utilization and wait time is key to early bottleneck detection.

AI-generated summaries displayed at the top of Google search results, automatically composed by Google's generative AI from top-ranking web content to directly answer user queries. AI Overviews cite source pages — cited sites gain high visibility but usually no clicks (zero-click search). GEO optimization makes site content more likely to be selected for citation in AI Overviews.

A class of AI information-retrieval products that directly provide answers instead of listing links, the representative being Perplexity. Unlike traditional search engines, answer engines first retrieve relevant web pages, then an LLM synthesizes a cited answer. GEO (Generative Engine Optimization) aims to get your site crawled, understood and cited by answer engines.

Optimization aimed at answer engines (such as Perplexity), targeting citations of your site in AI answers. Highly overlapping with GEO: both require structured data, bottom-line-up-front (BLUF) content, crawlable content and clear entity relationships. AEO is GEO applied to the specific channel of answer engines.

The AI crawler used by the Perplexity search engine to fetch web content as citation sources for its AI answers. Like GPTBot (OpenAI) and ClaudeBot (Anthropic), it is a crawler dedicated to AI engines. Your robots.txt should explicitly allow PerplexityBot, or your site will be completely invisible in Perplexity answers.

Enhanced fragments shown in search results, driven by structured data (JSON-LD), displaying ratings, prices, FAQ Q&A, breadcrumbs and more. Rich snippets significantly improve click-through rates, and FAQPage-type snippets are also more likely to be cited directly by AI engines — a win-win infrastructure for both SEO and GEO.

Building page structure with meaningful semantic tags (article, section, nav, header, h1-h6, time, etc.) rather than div/span everywhere. Semantic HTML helps search engines and AI engines understand content hierarchy and meaning, and is part of GEO infrastructure — AI crawlers rely on semantic tags to judge content importance even more than browsers do.

An information box in search engine result pages (Google, Baidu) summarizing an entity (brand, person, organization), sourced from the knowledge graph. Knowledge panels enhance brand authority and are usually tied to Wikipedia, Organization Schema on the official site, and authoritative media citations — part of E-E-A-T signals.

A search where users obtain the complete answer directly on the results page or from an AI answer, without clicking through to any website. AI Overviews and answer engines amplify this trend — many informational queries no longer generate traffic. For websites, the counter-strategy is getting brand names and core value propositions cited in AI answers, turning "zero clicks" into brand exposure.

OpenAI's AI crawler for fetching web content, used for training and inference. Its User-Agent contains "GPTBot" and can be allowed or blocked independently via robots.txt. ChatGPT's browsing feature also uses OAI-SearchBot to fetch real-time content. Monitoring GPTBot crawl volume is the first-layer signal for measuring GEO effectiveness on the OpenAI side.

The crawler used by OpenAI's search engine (ChatGPT Search) to fetch real-time web content as citation sources for answers. Unlike the training-oriented GPTBot, OAI-SearchBot serves retrieval during inference — its GEO value is more direct, since being crawled by it means a chance to appear in ChatGPT's cited answers.

The crawler used by Anthropic's Claude AI assistants to fetch web content for training and inference. Claude's search products (Claude-SearchBot, Claude-User) also fetch real-time content. User-Agent contains "ClaudeBot"; along with GPTBot and PerplexityBot, it belongs on the AI crawler whitelist that should be explicitly allowed.

A dedicated crawler identifier Google uses to train generative AI models such as Gemini, independent of regular Googlebot. Site owners can control Google-Extended access separately in robots.txt. Observing Google-Extended crawl data in Search Console provides a proxy for how much of your content is being read by Google's AI side.

The crawler protocol file at a site root, declaring which User-Agents may crawl which paths. A common GEO pitfall is reusing old block rules that accidentally block AI crawlers (e.g., blocking the User-Agent segment containing GPTBot/PerplexityBot). GEO infrastructure requires explicitly allowing all major AI crawlers while keeping the sitemap reference.

Google's official tool for monitoring site indexing and search performance. In GEO scenarios: filter the performance report by Googlebot and Google-Extended to see which URLs are crawled and their status codes, providing a proxy for the scale and quality of content being read by the AI side.

Tracking parameters appended to URLs (e.g., ?utm_source=perplexity&utm_medium=organic) that label traffic sources in analytics tools. The standard GEO attribution practice: add UTM parameters to landing-page links appearing in AI answers, then measure visits and conversions from AI channels like ChatGPT and Perplexity.

The overall degree to which a website is crawled, understood and cited in AI engine answers. The GEO counterpart to SEO "keyword rankings". AI visibility is measured through a four-layer pipeline: crawler volume (server logs) → index coverage (Search Console) → citation (brand tests and business-term tests) → attribution (AI-source traffic and leads).