# Keploy [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/keploy/keploy  
**GitHub Stars:** 18709  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/keploy

## Description
End-to-end API testing — generate and run tests from OpenAPI, curl, Postman, or real user traffic.

## Claude Desktop Quick Installation
No confirmed install details yet, so no config is published. Follow the setup steps in the repository above.

## Documentation

## What Keploy MCP server does

The Keploy MCP server is built around Keploy’s record-and-replay testing workflow. Keploy captures API calls, database queries, and streaming events while an application runs, then stores the observed interactions as test cases and data mocks. Those artifacts can be replayed later to validate API and integration behavior.

The workflow is intended for applications where reproducing external dependencies is difficult or expensive. Captured dependencies can include HTTP services, Postgres, MySQL, MongoDB, Kafka, and RabbitMQ interactions. The material also identifies support for HTTP/REST, gRPC, and GraphQL traffic.

Keploy can use existing recordings and Swagger or OpenAPI schemas to expand test coverage. The listed generation targets include boundary values, missing or extra fields, incorrect types, ordering changes, retries, and timeouts. Coverage reporting includes API, integration, unit, and end-to-end views, as well as statement, branch, schema, and business-use-case coverage.

## How it works

Keploy operates at the network layer with eBPF. Because capture happens outside the application code, the documented workflow does not require adding an SDK or changing the application. The approach is described as language- and framework-independent, with examples spanning Go, Java, Node.js, Python, Rust, C#, C/C++, TypeScript, Scala, Kotlin, Swift, Dart, PHP, Ruby, Elixir, and .NET.

During recording, the application is started under Keploy and real API or integration flows are exercised. Keploy converts the observed traffic into test cases and mocks. During testing, those artifacts provide the recorded responses and dependency behavior so tests can run offline rather than requiring the original external systems.

## Setup and configuration

Install the Keploy agent with the provided shell command:

```bash
curl --silent -O -L https://keploy.io/install.sh && source install.sh
```

Record an application by passing its start command to `keploy record`:

```bash
keploy record -c "python main.py"
```

Run the resulting tests with `keploy test`. The quick-start example adds a ten-second delay:

```bash
keploy test -c "CMD_TO_RUN_APP" --delay 10
```

It documents the command-line workflow above instead.

## Tools and capabilities

The Keploy MCP server’s documented workflow supports:

- Recording API and integration flows as test cases and mocks.
- Replaying complex distributed flows deterministically.
- Virtualizing database, queue, streaming, and external API interactions.
- Running recorded tests locally, in CI pipelines, or across Kubernetes clusters.
- Calculating API, integration, unit, end-to-end, statement, branch, schema, and business-use-case coverage.
- Viewing and managing recorded tests and mocks through a console.
- Freezing system time during replay.
- Managing reusable mock versions through a centralized mock registry.

## Limitations and notes

The Keploy MCP server is most relevant when the target application can be exercised through observable network traffic and the resulting interactions are suitable for replay. It also states that those dependencies are not supported in Keploy Enterprise.

Although Keploy is described as working with any language, framework, or runtime through eBPF capture, individual protocols and infrastructure components may have their own parsing or dependency considerations.

_Full upstream README: https://allmcps.com/mcp/keploy/readme_