aeo update

docusaurus.config.js

@@ -35,7 +35,7 @@ module.exports = {
       minHeadingLevel: 2,
       maxHeadingLevel: 2,
     },
-    canonicalBase: "https://www.keploy.io/",
+    canonicalBase: "https://keploy.io/",
     metadata: [
       {
         description: "Documentation for Keploy Backend Test Generator",
@@ -71,15 +71,42 @@ module.exports = {
           type: "application/ld+json",
         },
         innerHTML: JSON.stringify({
-          "@context": "https://schema.org/",
-          "@type": "Product",
-          description:
-            "Keploy - Open source tool that generates integration tests like unit tests with mocks or stubs from API calls.",
-          keywords:
-            "API testing, incident replay, network calls, code paths, test scenarios, code coverage, stubs, junit, go-test, live environment, production incidents, open source, regression tests, ai tests",
-          name: "Keploy",
-          url: "https://keploy.io/",
-          logo: "https://keploy.io/docs/img/favicon.png",
+          "@context": "https://schema.org",
+          "@type": "SoftwareApplication",
+          "name": "Keploy",
+          "description": "Keploy is an open-source, AI-powered testing agent and sandboxing platform that automatically generates test cases, dependency mocks, and production-like sandboxes from real user traffic using eBPF. It helps developers achieve 90% test coverage in minutes with zero code changes.",
+          "applicationCategory": "DeveloperTool",
+          "applicationSubCategory": "Test Automation",
+          "operatingSystem": ["Linux", "macOS", "Windows"],
+          "license": "https://www.apache.org/licenses/LICENSE-2.0",
+          "softwareHelp": "https://docs.keploy.io",
+          "codeRepository": "https://github.com/keploy/keploy",
+          "downloadUrl": "https://github.com/keploy/keploy/releases",
+          "isAccessibleForFree": true,
+          "url": "https://keploy.io",
+          "featureList": [
+            "Automatic test case generation from real user traffic",
+            "Production-like sandbox environments from captured traffic",
+            "AI-powered dependency virtualization and mock generation",
+            "Record and replay testing with eBPF kernel capture",
+            "AI noise detection for flaky test elimination",
+            "Legacy application testing without code changes",
+            "Migration regression testing against production baselines",
+            "Continuous validation in CI/CD pipelines",
+            "Multi-language support (Go, Java, TypeScript, Python)"
+          ],
+          "keywords": [
+            "test automation", "API testing", "API test generation",
+            "unit testing", "integration testing", "mock generation",
+            "dependency virtualization", "eBPF-based testing",
+            "record and replay", "production sandbox"
+          ],
+          "programmingLanguage": ["Go", "Java", "TypeScript", "JavaScript", "Python"],
+          "publisher": {
+            "@type": "Organization",
+            "name": "Keploy",
+            "url": "https://keploy.io"
+          }
         }),
       },
       {
@@ -93,6 +120,12 @@ module.exports = {
           name: "Keploy",
           url: "https://keploy.io/",
           logo: "https://keploy.io/docs/img/favicon.png",
+          sameAs: [
+            "https://github.com/keploy",
+            "https://twitter.com/Keployio",
+            "https://www.linkedin.com/company/keploy",
+            "https://www.youtube.com/@keploy"
+          ],
         }),
       },
       {
@@ -356,6 +389,7 @@ module.exports = {
           //cacheTime: 600 * 1000, // 600 sec - cache purge period
           changefreq: "weekly",
           priority: 0.5,
+          filename: "sitemap.xml",
         },
       },
     ],

plugins/docusaurus-tailwindcss-loader/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "docusaurus-tailwindcss-loader",
+  "version": "1.0.0",
+  "private": true,
+  "main": "index.js"
+}

static/llms.txt

@@ -0,0 +1,43 @@
+# Keploy Documentation
+
+> Technical documentation for Keploy, an open-source AI-powered testing agent and sandboxing platform that automatically generates test cases, dependency mocks, and production-like sandboxes from real user traffic using eBPF kernel technology. Keploy keeps testing aligned with AI-driven code velocity — achieving 90% test coverage in minutes with zero code changes.
+
+## Getting Started
+- [Installation](https://keploy.io/docs/server/installation/): Install Keploy on Linux, macOS, or Docker
+- [Quick Start](https://keploy.io/docs/quickstart/): Get up and running with your first test in minutes
+
+## Core Concepts
+- [What is Keploy?](https://keploy.io/docs/concepts/what-is-keploy/): AI-powered testing agent with eBPF-based traffic capture
+- [How Keploy Works](https://keploy.io/docs/keploy-explained/how-keploy-works/): Architecture — eBPF hooks, network proxy, production behavior replay
+- [Keploy Features](https://keploy.io/docs/concepts/what-are-keploy-features/): Dependency virtualization, noise detection, CI/CD integration
+- [eBPF-Based Testing](https://keploy.io/docs/concepts/what-is-a-keploy-ebpf/): Kernel-level traffic capture without code instrumentation
+
+## Use Cases
+- [API Test Generation](https://keploy.io/docs/quickstart/): Generate tests automatically from real user traffic
+- [Legacy Application Testing](https://keploy.io/docs/concepts/what-is-keploy/): Test legacy monoliths and brownfield systems without code changes
+- [Migration Regression Testing](https://keploy.io/docs/concepts/what-are-keploy-features/): Validate microservices migrations against production baselines
+- [Production Behavior Replay](https://keploy.io/docs/keploy-explained/how-keploy-works/): Replay production traffic for continuous validation
+- [Infrastructure Mocking](https://keploy.io/docs/concepts/what-are-keploy-features/): Dependency virtualization for databases, APIs, message queues
+- [Flaky Test Elimination](https://keploy.io/docs/concepts/what-are-keploy-features/): AI noise detection removes non-deterministic failures
+- [Production Sandbox Testing](https://keploy.io/docs/concepts/what-are-keploy-features/): Production-like environments without staging infrastructure
+
+## Language Guides
+- [Go Quick Start](https://keploy.io/docs/quickstart/go/): Gin, Echo, Fiber, Chi
+- [Java Quick Start](https://keploy.io/docs/quickstart/java/): Spring Boot, Quarkus, Micronaut
+- [Node.js Quick Start](https://keploy.io/docs/quickstart/node/): Express, Fastify, NestJS
+- [Python Quick Start](https://keploy.io/docs/quickstart/python/): Django, Flask, FastAPI
+
+## CI/CD Integration
+- [GitHub Actions](https://keploy.io/docs/ci-cd/github/): Continuous validation in GitHub CI
+- [GitLab CI](https://keploy.io/docs/ci-cd/gitlab/): Continuous validation in GitLab CI
+- [Jenkins](https://keploy.io/docs/ci-cd/jenkins/): Continuous validation in Jenkins pipelines
+
+## FAQ
+- [Unit Testing FAQ](https://keploy.io/docs/keploy-explained/unit-testing-faq/): Auto-generated unit tests, mock generation, coverage
+- [API Testing FAQ](https://keploy.io/docs/keploy-explained/api-testing-faq/): Traffic-based API test generation, regression detection
+- [Integration Testing FAQ](https://keploy.io/docs/keploy-explained/integration-testing-faq/): Dependency virtualization, production sandboxes
+
+## Related Resources
+- [Keploy Homepage](https://keploy.io): Product overview, pricing, and enterprise information
+- [Keploy Blog](https://keploy.io/blog): Technical articles on API testing, eBPF, test automation, and developer productivity
+- [Keploy Cloud](https://app.keploy.io): Managed Keploy cloud platform

static/robots.txt

@@ -1,5 +1,44 @@
-User-agent: *
-Disallow: 
-Crawl-delay: 5
-Disallow: /cgi-bin/
-Sitemap: https://keploy.io/docs/sitemap.xml
+User-agent: GPTBot
+Allow: /
+
+User-agent: OAI-SearchBot
+Allow: /
+
+User-agent: ChatGPT-User
+Allow: /
+
+User-agent: ClaudeBot
+Allow: /
+
+User-agent: anthropic-ai
+Allow: /
+
+User-agent: PerplexityBot
+Allow: /
+
+User-agent: Perplexity-User
+Allow: /
+
+User-agent: Google-Extended
+Allow: /
+
+User-agent: GoogleOther
+Allow: /
+
+User-agent: Applebot-Extended
+Allow: /
+
+User-agent: Meta-ExternalAgent
+Allow: /
+
+User-agent: CCBot
+Allow: /
+
+User-agent: Bytespider
+Disallow: /
+
+User-agent: *
+Disallow:
+Crawl-delay: 5
+Disallow: /cgi-bin/
+Sitemap: https://keploy.io/docs/sitemap.xml

versioned_docs/version-3.0.0/concepts/what-are-keploy-features.md

@@ -18,15 +18,16 @@
   - mock mutations
 ---
 
-## Key Features
+## What are Keploy's key features?
 
-Keploy is built for a wide variety of use-cases, however, to kick things off, let's dive into some key features that
-make Keploy stand out from the rest of the testing platforms out there.
+Keploy provides combined test coverage reporting in CI/CD pipelines, records complex distributed API flows as replayable test cases, automatically mocks all external dependencies including databases and third-party services, detects and filters noisy fields like timestamps from assertions, and supports multiple languages through code-less eBPF-based instrumentation that requires zero application changes.
 
-## 🧩 Combined Test Coverage in CI/CD:
+## 🧩 How does Keploy provide combined test coverage in CI/CD?
 
 #### Run Tests with Mocks Anywhere You Like
 
+Keploy integrates natively with unit-testing frameworks such as go-test, jUnit, jest, and pyTest to report combined test coverage from both recorded API tests and existing unit tests. Tests can run locally on the CLI, inside CI pipelines, or across Kubernetes clusters, giving teams a unified coverage metric without maintaining separate test infrastructure.
+
 Keploy has [native integrations](/concepts/general-glossary.md#4-interoperability) with your unit-testing libraries
 like `go-test`, `jUnit`, `jest`, `pyTest`. Keploy gives combined test-coverage and can also be integrated in existing CI
 pipelines easily within `go-test`, `jUnit`, `jest`, `pyTest` workflows.
@@ -36,10 +37,12 @@
 Run tests with mocks anywhere you like—**locally on the CLI**, in your **CI pipeline**, or even across a **Kubernetes
 cluster**. It's testing wherever you want it! 🌍
 
-## 📽️ Works for Complex API Flows
+## 📽️ How does Keploy handle complex API flows?
 
 #### Can easily record complex API flows and replay them as tests and stubs.
 
+Keploy records all API calls and their downstream network interactions, including database queries, cache lookups, and third-party service calls, then stores them as replayable YAML test cases with auto-generated dependency mocks. This allows teams to reproduce multi-service distributed flows locally or in CI without connecting to live external services.
+
 With Keploy, you can effortlessly record and replay intricate, distributed API flows as mocks and stubs. It's like
 having a time machine for your tests! ⏳
 
@@ -64,23 +67,29 @@
 
 [//]: # '<img src="/docs/img/record-api.gif?raw=true" width="80%" alt="API Tools"/>'
 
-## ♻️ Multi-Purpose Mocks
+## ♻️ What are Keploy's multi-purpose mocks?
 
 #### Re-Use Mocks for Testing Servers
 
+Keploy-generated dependency mocks serve multiple testing purposes beyond regression tests. The same recorded mocks can be reused for chaos testing, end-to-end testing, integration testing, and API contract testing, eliminating the need to create and maintain separate mock data sets for each testing strategy.
+
 Keploy generated dependency mocks can also be used as test case for the server. These tests can be used for use-cases
 like chaos testing, e2e testing, integration testing, api and regression testing. 🌟
 
-## 🌐 Code-less EBPF Instrumentation
+## 🌐 How does Keploy achieve code-less instrumentation?
 
 #### Network Layer Integration makes it Light-Weight
 
+Keploy uses eBPF (extended Berkeley Packet Filter) to attach hooks at the Linux kernel's network layer, intercepting system calls for incoming and outgoing connections. This kernel-level approach requires zero application code changes, works with any programming language or framework, and adds minimal performance overhead compared to user-space instrumentation.
+
 Keploy uses EBPF like a secret sauce to make integration code-less, language agnostic, and oh-so-lightweight. 🍲
 
-## 🔍 Accurate Noise Detection
+## 🔍 How does Keploy detect and handle noise in tests?
 
 #### Eliminates random fields for Assertion
 
+Keploy automatically identifies noisy fields in API responses, such as timestamps, UUIDs, and random values, by comparing multiple replays of the same request. Fields that change between runs are marked as noise and excluded from assertions, ensuring that generated test cases remain stable and do not produce false-positive failures.
+
 Keploy identifies [noisy fields](/concepts/general-glossary.md#3-noisy-field) in the responses accurately like (
 timestamps, random values) to ensure high quality tests.
 

versioned_docs/version-3.0.0/concepts/what-is-keploy.md

@@ -19,6 +19,10 @@ keywords:
   - AI Generated Tests
 ---
 
+## What is Keploy?
+
+Keploy is an open-source, AI-powered testing agent that generates backend API test cases and dependency mocks by recording real application network calls. Using eBPF kernel-level hooks, Keploy captures traffic without code changes, achieves up to 90% test coverage in minutes, and replays recorded interactions as automated regression tests with built-in stubs for databases, caches, and third-party services.
+
 Keploy creates backend **API tests with built-in-mocks** or stubs **by recording your application network calls** making
 your testing process not only faster than unit tests but also incredibly efficient.
 

versioned_docs/version-3.0.0/keploy-explained/how-keploy-works.md

@@ -10,7 +10,9 @@ tags:
   - record-test-case
 ---
 
-## 🌟 Keploy V2 Architecture 🌟
+## How does Keploy work?
+
+Keploy uses eBPF hooks at the Linux kernel level to intercept incoming and outgoing network traffic from an application without requiring any code changes. In record mode, it captures API calls and their downstream dependency interactions, storing them as YAML test cases and stubs. In test mode, Keploy replays those recorded requests and auto-mocks all external dependencies, enabling deterministic regression testing.
 
 ### 🎯 Goals
 
@@ -20,7 +22,9 @@ tags:
 - 🔒 **TLS Support:** Secure connections in HTTPS or databases are supported.
 - 🔄 **Request Matching:** Mocking responses during testing by matching requests.
 
-## 🏗 High-level architecture
+## What is Keploy's high-level architecture?
+
+Keploy's architecture consists of three core components: an eBPF hooks loader that intercepts ingress and egress network traffic at the kernel level, a transparent network proxy that records or mocks outgoing calls to databases and external services, and an API server that manages test execution and resource lifecycle. This design enables zero-code instrumentation across any language or framework.
 
 Keploy uses eBPF to instrument applications without code changes. Key components include:
 
@@ -49,7 +53,9 @@ The Network Proxy acts as a transparent proxy for recording or mocking outgoing
 
 The API server manages commands for start/stop and resource management (e.g., testicles, stubs). It's evolving to enable full agent mode, beyond just CLI.
 
-## 🧪 Example
+## How does Keploy record and replay tests?
+
+Keploy operates in two modes. In record mode, eBPF hooks capture all incoming HTTP requests and redirect outgoing TCP/UDP traffic through a proxy that saves interactions as YAML files. In test mode, Keploy reads those YAML files, replays the recorded HTTP requests against the application, and mocks all outgoing dependency calls to prevent side effects.
 
 Consider an application server serving HTTP APIs for clients like web/mobile apps, postman, or curl, and depending on a database and another API.
 

versioned_docs/version-4.0.0/concepts/what-are-keploy-features.md

@@ -2,7 +2,7 @@
 id: what-are-keploy-features
 title: Keploy Features
 sidebar_label: Keploy Features
-description: Keploy platform automatically mocks application dependencies and safely replay writes. It does accurate noise detection and statistical de-duplication.
+description: Keploy features include automatic test generation from real traffic, production-like sandboxes, dependency virtualization, AI-powered flaky test elimination, infrastructure mocking, legacy application testing, migration regression testing, continuous validation, and CI/CD integration — all without code changes.
 tags:
   - explanation
   - keploy features
@@ -11,13 +11,24 @@
   - mock mutations
 keywords:
   - test cases
-  - data dumps
+  - dependency virtualization
+  - production sandbox
+  - infrastructure mocking
+  - flaky test elimination
+  - legacy application testing
+  - migration regression testing
+  - continuous validation
+  - production behavior replay
+  - AI-driven testing
+  - release confidence
   - keploy features
   - features
   - record replay test
   - mock mutations
 ---
 
+Keploy's key features include automatic test generation from real user traffic, production-like sandbox environments, dependency virtualization for databases and external services, AI-powered noise detection for flaky test elimination, infrastructure mocking for message queues and APIs, legacy application testing without code changes, migration regression testing against production baselines, continuous validation in CI/CD pipelines, and Time Freezing for deterministic replay — enabling teams to ship with AI-driven code velocity while maintaining release confidence.
+
 ## Key Features
 
 Keploy is built for a wide variety of use-cases, however, to kick things off, let's dive into some key features that

versioned_docs/version-4.0.0/concepts/what-is-a-keploy-ebpf.md

@@ -2,15 +2,23 @@
 id: what-is-keploy-ebpf
 title: What is Keploy eBPF
 sidebar_label: Keploy eBPF
-description: Keploy eBPF is a language-agnostic library that captures and replays API calls and subsequent network interactions.
+description: eBPF (Extended Berkeley Packet Filter) is a Linux kernel technology that Keploy uses to intercept network packets at the socket level with near-zero overhead — enabling production behavior replay, dependency virtualization, legacy application testing, and infrastructure mocking without code changes.
 tags:
   - explanation
   - ebpf
 keywords:
-  - ebpf
+  - eBPF-based testing
+  - eBPF
   - Testing API
+  - production behavior replay
+  - dependency virtualization
+  - legacy application testing
+  - infrastructure mocking
+  - kernel-level traffic capture
 ---
 
+eBPF (Extended Berkeley Packet Filter) is a Linux kernel technology that Keploy uses to intercept network packets at the socket level with near-zero overhead. By injecting eBPF hooks, Keploy captures all incoming API requests and outgoing dependency calls — database queries, external API calls, and message queue interactions — without modifying application code or requiring language-specific SDK installation. This kernel-level capture enables production behavior replay, dependency virtualization, legacy application testing for systems never designed for testability, and infrastructure mocking that replaces heavy staging environments with production-like sandboxes.
+
 A Keploy eBPF is a language-agnostic library that offers APIs to do the following:
 
 1. Capture all the network calls like