mcpField
R
Reqable Mcp Server

Reqable Mcp Server

Local
github.com/ElonJaskDeveloper Tools237Updated 24w ago

About Reqable Mcp Server

Reqable MCP Server exposes local Reqable capture traffic to MCP clients. It runs local-only by default, storing data in SQLite, and suits developers who need to analyze HTTP and WebSocket traffic.

Key features

  1. 01Ingests HAR and WebSocket events from Reqable
  2. 02Local SQLite storage with retention cleanup
  3. 03HTTP request query, search and domain statistics
  4. 04WebSocket session and message query and analysis
  5. 05HAR file import as a fallback

Use cases

  1. 01Searching API requests and responses captured by Reqable
  2. 02Analyzing message structure within WebSocket sessions
  3. 03Generating sample client code from a captured request

MCP support

The server acts as an MCP server, exposing capture query and analysis tools such as search_requests and get_websocket_session to clients including Windsurf, Cursor, Claude and Codex.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"reqable": {
"command": "npx",
"args": [
"-y",
"reqable-mcp"
]
}
}
}
Run commandnpx -y reqable-mcp

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
npmreqable-mcp

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

Reqable MCP Server

NPM Version PyPI Version GitHub License

Reqable MCP Server exposes local Reqable capture traffic to MCP clients (Windsurf/Cursor/Claude/Codex).

Default architecture is local-only:

  1. Reqable posts HAR(JSON) to http://127.0.0.1:18765/report.
  2. Optional incremental WebSocket events can be posted to http://127.0.0.1:18765/ws/events.
  3. reqable-mcp normalizes and stores requests/messages in local SQLite.
  4. MCP tools query local data only (no cloud relay by default).

Docs: English | 中文

Features

  • Local-first, privacy-first ingest path.
  • Real-time ingest via Reqable Report Server.
  • HAR file import fallback for missed sessions.
  • HTTP request query/search/domain stats/API analysis.
  • WebSocket session/message parsing for HAR entries carrying message-frame extensions.
  • Cross-platform runtime (macOS / Linux / Windows with Python 3.10+).

Prerequisites

  1. Install and open Reqable.
  2. Configure Reqable Report Server to post to http://127.0.0.1:18765/report.
  3. Ensure Node.js (for npx) and uv (for uvx) are available.

Installation

Run via npx (recommended)
npx -y reqable-mcp@latest
Local development
uv run reqable-mcp

MCP Client Configuration

{
  "mcpServers": {
    "reqable": {
      "command": "npx",
      "args": ["-y", "reqable-mcp@latest"]
    }
  }
}

Reqable Report Server Setup

Use these values in Reqable "Add Report Server":

  1. Name: reqable-mcp-local
  2. Match rule: * (or your target domains)
  3. Server URL: http://127.0.0.1:18765/report
  4. Compression: None (or keep consistent with your receiver)

After saving, generate traffic and call ingest_status to verify incoming payload count.

Important note: reqable-mcp still uses HTTP-only ingest transport (no native ws:// listener), but now supports two HTTP ingest paths: /report for HAR/session payload and /ws/events for incremental WebSocket events. WebSocket capture works when Reqable payload includes frame data (for example _webSocketMessages or event frame objects). Raw entry JSON and raw message JSON are preserved and exposed by WebSocket tools. HAR export/import remains the fallback when live pushes miss frames.

Available Tools

  • ingest_status: ingest server state and counters
  • import_har: import HAR from file path
  • list_requests: list recent HTTP/WebSocket handshake requests with filters
  • get_request: fetch request details by ID (full includes raw_entry)
  • search_requests: keyword search in HTTP URL/body/raw uploaded entry (raw / raw_entry)
  • list_websocket_sessions: list captured WebSocket sessions
  • list_active_websocket_sessions: list recently active WebSocket sessions by latest captured frames
  • get_websocket_session: fetch WebSocket session details and messages by ID (including raw_entry and message raw)
  • tail_websocket_messages: incremental fetch by request_id + after_seq cursor
  • search_websocket_messages: precise WebSocket message search by keyword, direction, type, opcode, close code, domain, and request ID
  • analyze_websocket_session: summarize directions, message types, JSON shapes, and close events for a session
  • export_websocket_session_raw: export the raw uploaded WebSocket entry and raw frame list
  • health_report: ingest status + WebSocket data quality report
  • repair_websocket_messages: backfill missing fields from raw frames (supports dry-run)
  • get_domains: domain-level request statistics
  • analyze_api: infer API shapes for a domain
  • generate_code: generate sample client code from captured HTTP request

Environment Variables

VariableDescriptionDefault
REQABLE_INGEST_HOSTReport receiver host127.0.0.1
REQABLE_INGEST_PORTReport receiver port18765
REQABLE_INGEST_PATHReport receiver path/report
REQABLE_WS_EVENTS_PATHIncremental WebSocket event receiver path/ws/events
REQABLE_DATA_DIRLocal data directoryplatform app data dir
REQABLE_DB_PATHSQLite file path${REQABLE_DATA_DIR}/requests.db
REQABLE_MAX_BODY_SIZEMax persisted body bytes per request/message102400
REQABLE_MAX_REPORT_SIZEMax accepted report payload bytes10485760
REQABLE_MAX_IMPORT_FILE_SIZEMax HAR import file bytes104857600
REQABLE_RETENTION_DAYSLocal retention window7
REQABLE_INGEST_TOKENOptional local auth tokenunset

Privacy and Data Retention

  • Data stays on local machine in default mode.
  • Retention cleanup is applied to local DB records, including WebSocket messages.
  • If ingest server is offline, Reqable failed report push is not retried.

License

MIT

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.