Skip to main content
Glama
Reqable MCP Server

Reqable MCP Server

by ElonJask

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+).

Related MCP server: ProxyPin MCP Server

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

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

Variable

Description

Default

REQABLE_INGEST_HOST

Report receiver host

127.0.0.1

REQABLE_INGEST_PORT

Report receiver port

18765

REQABLE_INGEST_PATH

Report receiver path

/report

REQABLE_WS_EVENTS_PATH

Incremental WebSocket event receiver path

/ws/events

REQABLE_DATA_DIR

Local data directory

platform app data dir

REQABLE_DB_PATH

SQLite file path

${REQABLE_DATA_DIR}/requests.db

REQABLE_MAX_BODY_SIZE

Max persisted body bytes per request/message

102400

REQABLE_MAX_REPORT_SIZE

Max accepted report payload bytes

10485760

REQABLE_MAX_IMPORT_FILE_SIZE

Max HAR import file bytes

104857600

REQABLE_RETENTION_DAYS

Local retention window

7

REQABLE_INGEST_TOKEN

Optional local auth token

unset

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

Available Tools

17 tools
analyze_apiC

Analyze API structure for a specific domain.

Inputs: domain (required). Returns: result

analyze_websocket_sessionB

Analyze a WebSocket session and summarize frame directions, types, JSON shapes, and close events.

Inputs: request_id (required), sample_limit. Returns: result

export_websocket_session_rawC

Export the raw uploaded WebSocket session entry and raw frame list.

Inputs: request_id (required), include_normalized. Returns: result

generate_codeC

Generate API call code from a captured request.

Inputs: request_id (required), language, framework. Returns: result

get_domainsB

Get all captured domains with request counts.

Inputs: no named parameters. Returns: result

get_requestB

Get detailed information for a single request.

Inputs: request_id (required), include_body. Returns: result

get_websocket_sessionB

Get WebSocket session details and messages by request ID.

Inputs: request_id (required), include_messages. Returns: result

health_reportC

Return ingest status plus data quality checks for WebSocket payloads.

Inputs: detail, sample_limit. Returns: result

import_harC

Import a HAR file (or line-delimited JSON entries) as fallback.

Inputs: file_path (required). Returns: result

ingest_statusB

Check local ingest server status.

Inputs: auto_start. Returns: result

list_active_websocket_sessionsB

List recently active WebSocket sessions inferred from latest captured frames.

Inputs: limit, domain, active_within_seconds, include_closing. Returns: result

list_requestsC

List recent HTTP/WebSocket handshake requests captured from Reqable reports.

Inputs: limit, detail, domain, method, +1 more. Returns: result

list_websocket_sessionsC

List captured WebSocket sessions.

Inputs: limit, detail, domain. Returns: result

repair_websocket_messagesB

Backfill missing WebSocket message fields from raw frames.

Inputs: max_rows, dry_run. Returns: result

search_requestsB

Search requests by keyword in URL, bodies, or raw uploaded entry (raw / raw_entry).

Inputs: keyword (required), search_in, limit. Returns: result

search_websocket_messagesC

Search WebSocket messages by keyword and precise frame filters.

Inputs: keyword, direction, message_type, opcode, +5 more. Returns: result

tail_websocket_messagesC

Tail WebSocket messages for one session using seq cursor.

Inputs: request_id (required), after_seq, direction, message_type, +2 more. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 17 tools

    Disambiguation4/5

    Most tools have distinct purposes targeting specific resources like HTTP requests, WebSocket sessions, or data operations, with clear boundaries. However, some overlap exists between list_websocket_sessions and list_active_websocket_sessions, which could cause confusion in selection without careful reading of descriptions.

    Naming Consistency5/5

    Tool names follow a highly consistent snake_case pattern with clear verb_noun structures throughout, such as analyze_api, get_request, list_requests, and search_websocket_messages. There are no deviations in naming conventions, making the set predictable and readable.

    Tool Count4/5

    With 17 tools, the count is slightly high but reasonable for the server's scope in API and WebSocket analysis, covering ingestion, querying, and data management. It feels comprehensive without being overly bloated, though it borders on the heavy side for typical MCP servers.

    Completeness5/5

    The tool set provides complete coverage for the domain of API and WebSocket analysis, including ingestion (import_har, ingest_status), querying (list_requests, search_requests), detailed access (get_request, get_websocket_session), analysis (analyze_api, analyze_websocket_session), and data management (export, repair, tail). No obvious gaps are present, supporting full lifecycle workflows.

    Maintenance

    ActivityInactive
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      An MCP server that enables AI assistants to capture and analyze HTTP/HTTPS traffic from Android devices. It supports smart searching of network requests and provides tools for detailed traffic analysis via natural language.
      11
      246
      MIT
    • A
      license
      B
      quality
      D
      maintenance
      Exposes ProxyPin's local network capture history to MCP-capable clients for searching, analyzing, and detailing captured HTTP traffic. It enables users to perform API structure analysis and generate client-side code directly from captured requests.
      6
      28 PyPI
      17
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to query, filter, and analyze local HTTP capture records and REST API test data from the Reqable tool. It provides read-only access to inspect request/response details, headers, and statistics through natural language.
      27
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Read-only MCP server that brings Reqable's captured HTTP traffic into Claude Code conversations, enabling querying, searching, waiting for, and analyzing requests without requiring Reqable Pro.
      7
      MIT