API Shakedown

Name: API Shakedown
Author: anzar-ahsan-commits

by anzar-ahsan-commitsversion 0.1.3i★ –iRuns on your computer

Registry nameio.github.anzar-ahsan-commits/api-shakedown

Install

Overview

Description from the maker (original English)

Turn an OpenAPI spec into WireMock stubs, contract tests and chaos scenarios, on local LLMs.

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

User voiceiNo reviews yetReviews open together with accounts in a later step
Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
UsageiNot measured yet★ –

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

Connection: Runs on your computer
Transport: stdio
Category: Search & AI memory
You need to fill in: OPENAI_API_KEY, ANTHROPIC_API_KEY

Install

Pick the AI app you use, then copy the settings.

Before you install

Basic checks: 1 of 1 passed
Runs on your computer with your user’s permissions (files, network, apps).
You fill in yourself: SHAKEDOWN_PROVIDER, SHAKEDOWN_MODEL, SHAKEDOWN_OLLAMA_URL, OPENAI_API_KEY, ANTHROPIC_API_KEY

Values marked secret are keys to your account. Never share them or paste them into a chat.

You need

PyPIPython’s uv installed (for the uvx command)

Which app do you use?

ClaudeClaude CodeCursorVS CodeChatGPT

Pick your app above. We remember it, so next time the button says “Install in …”.

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "api-shakedown": {
      "command": "uvx",
      "args": [
        "api-shakedown",
        "mcp"
      ],
      "env": {
        "SHAKEDOWN_PROVIDER": "your-value",
        "SHAKEDOWN_MODEL": "your-value",
        "SHAKEDOWN_OLLAMA_URL": "your-value",
        "OPENAI_API_KEY": "your-value",
        "ANTHROPIC_API_KEY": "your-value"
      }
    }
  }
}

Run this in your terminal

claude mcp add api-shakedown --env SHAKEDOWN_PROVIDER=your-value --env SHAKEDOWN_MODEL=your-value --env SHAKEDOWN_OLLAMA_URL=your-value --env OPENAI_API_KEY=your-value --env ANTHROPIC_API_KEY=your-value -- uvx api-shakedown mcp

Fill in the empty values before running it.

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "api-shakedown": {
      "command": "uvx",
      "args": [
        "api-shakedown",
        "mcp"
      ],
      "env": {
        "SHAKEDOWN_PROVIDER": "your-value",
        "SHAKEDOWN_MODEL": "your-value",
        "SHAKEDOWN_OLLAMA_URL": "your-value",
        "OPENAI_API_KEY": "your-value",
        "ANTHROPIC_API_KEY": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "api-shakedown": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "api-shakedown",
        "mcp"
      ],
      "env": {
        "SHAKEDOWN_PROVIDER": "your-value",
        "SHAKEDOWN_MODEL": "your-value",
        "SHAKEDOWN_OLLAMA_URL": "your-value",
        "OPENAI_API_KEY": "your-value",
        "ANTHROPIC_API_KEY": "your-value"
      }
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.

Your choice stays on this device in a cookie; no account needed.

Values you fill in

SHAKEDOWN_PROVIDER env
LLM provider: ollama (default, local), openai, or anthropic.
SHAKEDOWN_MODEL env
Model name; defaults per provider (qwen3:8b for Ollama).
SHAKEDOWN_OLLAMA_URL env
Where Ollama runs.
OPENAI_API_KEY secret env
Only for SHAKEDOWN_PROVIDER=openai.
ANTHROPIC_API_KEY secret env
Only for SHAKEDOWN_PROVIDER=anthropic.

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

Runs on your computer; the tool list appears in your AI app after you install it.

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 8, 2026

✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account anzar-ahsan-commits, which owns the repo
… Not checked yet
Still maintained
We have not read this repo from GitHub yet
… Not checked yet
Has a licence
We have not read this repo from GitHub yet
– Not applicable
Endpoint responds
This one runs on your computer; there is no internet endpoint
– Not applicable
Sign-in with OAuth
Runs on your computer and uses local settings instead
… Not checked yet
No hidden instructions in tool descriptions
Runs on your computer; we can only read tool lists from internet endpoints

Compared with others in Search & AI memoryi

More stars than 0% of the other 5675 servers in this category
Published to the registry more recently than 73% of the other 5675 servers in this category
Basic checks equal to or better than 100% of the other 5675 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is API Shakedown safe?

It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

You need to fill in: OPENAI_API_KEY, ANTHROPIC_API_KEY

Does it run on my computer or in the cloud?

It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).

Is it still maintained?

The GitHub repo last changed –, and the latest version (0.1.3) reached the registry 15 days ago.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. You also need Python (uv), Docker on your computer.

What can I use instead?

In the same category: Context7, Codebase Memory, Exa

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

Context7

by upstash

Feeds AI the latest docs for libraries and frameworks before it answers, so code it writes does not use outdated, removed functions.

Computer or cloud★ 64,224MITUpdated yesterday

Install

Codebase Memory

by DeusData

Codebase knowledge graph for AI agents — 162 languages, sub-ms queries, 99% fewer tokens.

Runs on your computer★ 48,148MITUpdated 21 days ago

Install

Exa

by exa-labs

Connect AI agents to Exa for web search, content fetching, and multi-step research.

Runs in the cloud★ 5,213MITUpdated 2 months ago

Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

API Shakedown

Give it an OpenAPI spec. Get back a ready-to-run test harness: WireMock stubs, contract tests, robustness probes, and chaos scenarios, written by a team of LLM agents that review each other's work.

Runs locally on [Ollama](https://ollama.com) by default: no API key, no data leaves your machine. Cloud models (OpenAI, Anthropic) are bring-your-own-key. Available as a CLI, a Docker image, and an MCP server so an AI assistant can drive it.

Status: alpha (0.1.3). Works end to end on the example spec with a local 8B model.

*A real run on the bundled example with qwen3:8b on a laptop, sped up: generation took about 9 minutes. Recording: docs/demo.cast.*

Why
Where it helps
Quick start
What you get
How it works
Install
Usage
Configuration
MCP server
Docker
Architecture
Limitations
Roadmap
Development
Contributing
License

Why

Teams that consume an API need three things that are tedious to write by hand and go stale quickly:

A realistic mock of the API to develop and test against.
Contract tests that tell you when the real API stops matching its spec.
Failure drills: what does your client do when the API is slow, flaky, rate limited, returns garbage, or goes down?

API Shakedown generates all three from the spec you already have, and keeps them honest: the LLMs never write code that runs. They propose *data* (response bodies, test cases, failure scenarios, test records), and code validates every item against the spec, feeds problems back to the model, and falls back to deterministic output when a model cannot get it right. Without any model at all (--offline), every part still works.

Where it helps

Situation	Typical teams	What API Shakedown gives you
Building before the backend exists	Frontend, mobile, partner integrators	A virtual service generated from the agreed spec, so work starts on day one instead of after the backend ships or after hand-written mocks.
Depending on APIs you don't control (payments, shipping, identity checks, credit bureaus)	Fintech, e-commerce, logistics, insurance	Vendor sandboxes are often rate-limited, flaky or billed per call. Test locally what your app does when the provider times out, rate-limits you, or returns 503 twice before recovering.
Proving clients survive failure	Microservice teams, SRE game days	Switch timeouts, rate limits, flaky calls and partial outages on and off while your client runs, and confirm retries, backoff and fallbacks really work.
Catching spec drift before release	API owners, platform and public-API teams	Contract tests run against a real deployment in CI and fail when the implementation stops matching its spec.
Hardening input validation	Any API team	Robustness probes check that malformed requests get a 4xx, never a 500. A complement to a security review, not a replacement.
Regulated or offline environments	Banking, healthcare, government	Everything runs on a local model: the spec never leaves the machine, where many AI tools cannot be used at all.
Migrating or rewriting a service	Legacy modernisation	Generate contract tests from the existing spec and run them against the new implementation to confirm it behaves the same.
Working through an AI assistant	Developers using Claude and other MCP clients	The assistant generates the harness and runs failure drills on request.

It is not a load-testing tool or a security scanner, and the virtual service does not keep state between calls; see Limitations.

Quick start

Prerequisites: Python 3.11+, Docker (for WireMock), and Ollama with a model (ollama pull qwen3:8b) unless you use --offline or a cloud model.

pip install api-shakedown

shakedown doctor # is the model ready? shakedown run openapi.yaml --out my-harness # minutes on a local model cd my-harness docker compose up -d # WireMock with your stubs on :8080 pip install -r requirements.txt SHAKEDOWN_SELECT_STATUS=1 pytest tests/test_contract.py python chaos/chaos.py on flaky-start # now point your client at :8080 python chaos/chaos.py off

Try it on the bundled example: shakedown run examples/petstore.yaml --out petstore.

A real run on the example spec with qwen3:8b:

Petstore 1.0.0: 5 operations (ollama / qwen3:8b)

Generating test data... Test data ready (3 Pet). Generating stubs, contract tests, and chaos scenarios... stubs: done contracts: done chaos: done review contracts: approved review stubs: approved review chaos: approved

Wrote 14 files to harness in 436s: 15 stubs, 11 contract cases, 11 chaos scenarios, 30 probes. Next: cd harness && docker compose up -d (then see README.md)

What you get

my-harness/

├── README.md # generated: how to run it, every scenario, review notes ├── docker-compose.yml # WireMock 3 serving the stubs (port: SHAKEDOWN_WIREMOCK_PORT) ├── wiremock/mappings/ # stub mappings ├── tests/ │ ├── test_contract.py # contract tests (cases in contract_cases.json) │ └── test_robustness.py # malformed-request probes (cases in robustness_cases.json) ├── chaos/ │ ├── chaos.py # switch failure scenarios on/off (standard library only) │ └── chaos_scenarios.json ├── data/dataset.json # test records and edge-case values per field ├── requirements.txt # pytest, httpx, openapi-schema-validator └── shakedown.json # manifest: counts, review outcome, generation notes

Part	What it does
Stubs	Every documented response of every operation. Known ids return their own record, unknown ids return the documented 404, and any other response can be requested with `X-Shakedown-Status:` .
Contract tests	Happy paths, documented error statuses, and boundary values. Each checks the status code, `Content-Type`, and the body against the response schema. Run them against the stubs or a real deployment.
Robustness probes	Invalid bodies and parameters derived from the schemas (missing required fields, wrong types, out-of-range values, broken JSON). A robust server answers 4xx, never 5xx.
Chaos scenarios	Seven baseline failures every client should survive, plus scenarios the LLM targets at your API.
Test data	Realistic, consistent records per entity, shared by the stubs and the tests, plus edge-case values for every field.

Baseline chaos scenarios:

Scenario	What happens	A resilient client should
`total-outage`	Every endpoint returns 503	Fail fast, back off, not hammer the API
`slow-responses`	Every response takes 3 s	Stay responsive
`timeouts`	Every response takes 30 s	Give up on its own and free resources
`connection-resets`	Connections are reset	Retry idempotent calls with backoff
`flaky-start`	First 2 calls fail with 503, then recover	Retry and succeed on the third attempt
`rate-limited`	First 3 calls return 429	Honour `Retry-After`
`truncated-json`	Success bodies are cut off mid-JSON	Report a parse error, never crash

LLM-targeted scenarios from a real run include *createPet fails 3 times with 503 then recovers*, *listPets is rate limited*, and *getPet loses required fields*.

How it works

flowchart LR

spec[/"OpenAPI spec"/] --> load["Load, validate, normalize, chunk"] load --> data["Test data agent"] data --> stubs["Stub agent"] data --> contracts["Contract agent"] data --> chaos["Chaos agent"] stubs --> review{"Reviewer agent"} contracts --> review chaos --> review review -- "blocker: revise with feedback" --> stubs review -- "blocker" --> contracts review -- "blocker" --> chaos review -- "approved, or budget spent" --> coord["Coordinator"] coord --> harness[/"Harness directory"/]

Spec layer: loads YAML/JSON from a path or URL, validates it (problems become warnings), inlines $refs safely, and splits operations into prompt-sized chunks so large specs fit small models.
Test data agent runs first: the stubs and tests share its records.
Stub, contract, and chaos agents run in parallel.
Reviewer judges each artifact. Blockers send it back to its author with the feedback, for a bounded number of rounds; suggestions are kept as notes.
Coordinator assembles the harness and its README, including anything the reviewer still rejected when the revision budget ran out.

Every agent follows the same pattern, which is what keeps small local models reliable:

sequenceDiagram

participant A as Agent participant M as LLM participant C as Code checks A->>M: task + JSON schema (constrained decoding on Ollama) M-->>A: proposal (bodies, cases, scenarios, records) A->>C: validate against the spec alt problems found C-->>A: exact errors, e.g. "listPets 200: 'id' is a required property" A->>M: fix these problems M-->>A: corrected proposal end A->>A: keep valid items, fall back to deterministic ones for the rest

Things code guarantees, so the model never has to:

Request matching, URL patterns, priorities, and path-parameter types in the stubs.
Response bodies valid against their schemas.
Test inputs that route (valid path parameters, required query parameters), success cases that use ids that exist, 404 cases that use ids that do not.
Authentication from the spec's security schemes.
Chaos scenarios that are internally consistent (a "flaky" failure must recover, a rate limit is a 429, a partial outage leaves some endpoints up).
Reviewer findings that cite real items, and blockers only on what the author controls.

Install

pip install api-shakedown              # local models via Ollama; includes the MCP server

pip install "api-shakedown[cloud]" # plus OpenAI and Anthropic

Or use the Docker image, which includes everything: see Docker.

Generated harnesses need Docker (for WireMock) and Python for their tests.

Usage

shakedown doctor                     Check the LLM provider is reachable and ready

shakedown inspect SPEC [--json] Show the operations the agents will see shakedown run SPEC [options] Generate a harness shakedown version

shakedown run options:

Option	Default
`--out PATH`	`shakedown-output`	Where to write the harness (refuses a non-empty directory)
`--offline`	off	No LLM: deterministic output in seconds

| --no-review | review on | Skip the revie

Only the beginning is shown; read the rest in the repo

API Shakedown

Overview

PopNx MCP’s three pillars

What you can do with it

Install

Before you install

Values you fill in

What it can do

Basic checksi

Maker matches the repo

Still maintained

Has a licence

Endpoint responds

Sign-in with OAuth

No hidden instructions in tool descriptions

Compared with others in Search & AI memoryi

Common questions

Alternatives

Context7

Codebase Memory

Exa

README from the maker

API Shakedown

Contents

Why

Where it helps

Quick start

What you get

How it works

Install

Usage