# TraceWeave (pypi · traceweave-mcp)

Portable MCP runtime for RTL logs and VCD; repository setup adds FSDB and site EDA integration

- Trust score: 83/100 (high trust)
- Change this week: +13
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-30

## Components

- pypi · `traceweave-mcp`: 83/100 (this document), [markdown](https://verifymcp.io/servers/gokeshenzhen-traceweave/traceweave-mcp.md), [page](https://verifymcp.io/servers/gokeshenzhen-traceweave/traceweave-mcp)

## Channel facts

- Registry: `pypi`
- Package: `traceweave-mcp`
- Version: `2.0.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-30.

- **Supply Chain Security**: 83/100
  - No malware found by supply-chain analysis.
  - CVE check failed: a known high-severity CVE affects mcp 1.27.0, a direct dependency. A fixed version is available.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 0 of 29 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to gokeshenzhen/TraceWeave).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 30 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 61/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 12460 tokens (~327/item across 38 items; 38 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 80/100
  - Stability observed for 24 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 94/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 82% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "cursor_delete" implies "delete" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 39 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the TraceWeave MCP server?

TraceWeave runs locally as a PyPI package, launched with uvx traceweave-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add gokeshenzhen-traceweave -- uvx traceweave-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "gokeshenzhen-traceweave": {
      "command": "uvx",
      "args": [
        "traceweave-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "gokeshenzhen-traceweave": {
      "command": "uvx",
      "args": [
        "traceweave-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add gokeshenzhen-traceweave -- uvx traceweave-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "gokeshenzhen-traceweave": {
      "type": "local",
      "command": [
        "uvx",
        "traceweave-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add gokeshenzhen-traceweave --command uvx --arg traceweave-mcp
```

### Hermes

```yaml
mcp_servers:
  gokeshenzhen-traceweave:
    command: "uvx"
    args: ["traceweave-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "gokeshenzhen-traceweave": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "traceweave-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add gokeshenzhen-traceweave -t stdio -c uvx -a traceweave-mcp
```

### Other

```json
{
  "mcpServers": {
    "gokeshenzhen-traceweave": {
      "command": "uvx",
      "args": [
        "traceweave-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-30 (score 83, −2)

- [functional] Stability: pass → 0.80

### 2026-09-29 (score 85, 0)

- [security] Stability: 0.97 → pass

### 2026-09-28 (score 85, +11)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-26 (score 74, +1)

No change was recorded against any check on this day. Stability & Change Management went from 87 to 90. That category is still filling its 30-day observation window: 26 days of observed history at the previous scan, 27 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-25 (score 73, +18)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-24 (score 55, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-23 (score 70, +1)

No change was recorded against any check on this day. Stability & Change Management went from 77 to 80. That category is still filling its 30-day observation window: 23 days of observed history at the previous scan, 24 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-22 (score 69, +15)

- [security improvement] Malware scan: unverified → pass

## MCP tools (38)

### `get_sim_paths` (~267 tokens)

Discover compile logs, simulation logs, and waveform files under a verif directory. If case_name is omitted, the tool returns available cases. For non-standard layouts you may pass explicit sim_log / wave_file / compile_log paths; any provided field is used as-is and the omitted ones are still auto-discovered (a sim_log path also anchors discovery of the matching waveform and compile/elab logs).

Input parameters:

- `case_name` (string): Optional case name, for example case0 (matching make SV_CASE=case0)
- `compile_log` (string): Optional explicit compile/elaborate log path, absolute or relative to verif_root. Used verbatim when given; otherwise discovered from the case dir, the parent top, or a sibling build/elab dir.
- `sim_log` (string): Optional explicit simulation log path (absolute, or relative to verif_root). Used verbatim, and its directory anchors discovery of the waveform and compile/elab logs for the same case.
- `verif_root` (string, required): Absolute path to the project's verif/ directory, for example /path/to/project/verif
- `wave_file` (string): Optional explicit waveform path (FSDB/VCD), absolute or relative to verif_root. Used verbatim when given; otherwise discovered.

### `parse_sim_log` (~174 tokens)

Parse a VCS or Xcelium simulation log and return grouped runtime failures by signature. The simulator argument is required and is not auto-detected here. candidate_previous_logs uses bounded evidence sampling and excludes compile/elaboration logs. The first error group automatically includes about 100 lines of surrounding log context in first_group_context; use get_error_context for other groups.

Input parameters:

- `detail_level` (string): Detail level to return. Default: summary
- `log_path` (string, required): Absolute path to the simulation log, for example irun.log
- `max_events_per_group` (integer): Maximum failure_events returned per group in compact/full modes. Default: 3
- `max_groups` (integer): Maximum number of error groups to return. Default: 20
- `simulator` (string, required): vcs / xcelium

### `diff_sim_failure_results` (~206 tokens)

Compare normalized failure events from two simulation logs. Returns resolved, persistent, and newly introduced failures, plus changes in failure type, X/Z presence, first-failure timing, and a convergence summary. If a simulator overwrites the same log path between runs, pass new_log_path only after parse_sim_log has captured the baseline snapshot, or pass snapshot IDs returned by parse_sim_log.

Input parameters:

- `base_log_path` (string): Baseline simulation log. Optional when base_snapshot_id is supplied, or when new_log_path has a previous parsed snapshot.
- `base_snapshot_id` (string): Baseline log snapshot ID returned by parse_sim_log.
- `new_log_path` (string): New simulation log. For same-path reruns, this may be the overwritten log path.
- `new_snapshot_id` (string): New log snapshot ID returned by parse_sim_log.
- `simulator` (string): vcs / xcelium / auto. Defaults to simulator discovered by get_sim_paths when omitted.

### `get_error_context` (~99 tokens)

Extract raw log text around a given error line. Typically used with first_line returned by parse_sim_log.

Input parameters:

- `after` (integer): Number of lines after the target line. Default: 100
- `before` (integer): Number of lines before the target line. Default: 100
- `line` (integer, required): Center error line number
- `log_path` (string, required): Absolute path to the simulation log, for example irun.log

### `search_signals` (~303 tokens)

Search for signals in a waveform file (FSDB/VCD) and return full hierarchical paths. Use this when the client knows a leaf signal name but not the full path. keyword accepts a single string OR a list of strings: pass a list to batch several lookups in one call (one result entry per keyword, in input order) instead of issuing consecutive single-keyword searches. Each result also carries `direction` (input/output/inout/implicit/...) and `var_type` (wire/reg/integer/real/parameter/memory/...), so callers can filter by port direction or language type within a scope by combining a hierarchical keyword with these fields — no separate listing tool is needed. Note: VCD format does not encode port direction; `direction` is always null for VCD waves, while `var_type` is populated. FSDB populates both. FSDB search uses a scope-tree index and does not read value changes, so it scales well to large files. FSDB support depends on fsdb_runtime.enabled returned by get_sim_paths.

Input parameters:

- `keyword` (required): Signal keyword (for example s_bits, clk, or data), or a list of keywords (max 16) to batch several lookups in one call — prefer the list form over consecutive single-keyword calls
- `max_results` (integer): Maximum number of matches to return. Default: 50
- `wave_path` (string, required): Absolute path to the waveform file

### `get_signal_at_time` (~140 tokens)

Query a signal value in a waveform file at a specific time in ps. FSDB support depends on fsdb_runtime.enabled.

Input parameters:

- `signal_path` (string, required): Full hierarchical path, for example top_tb.dut.s_bits. A bare bus name (no [msb:lsb]) is auto-completed when it resolves uniquely (resolved_from echoes the input); an unresolved name raises with a di…
- `time_ps` (required): Query time. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `wave_path` (string, required)

### `get_signal_transitions` (~220 tokens)

Return transitions for a signal over the strict closed time range [start_time_ps, end_time_ps] (capped at 1000 by default; truncated=true + hint mark a clipped result, transition_count is always the total found). FSDB support depends on fsdb_runtime.enabled. The last value-change strictly before the window is returned separately as predecessor and is never mixed into transitions.

Input parameters:

- `end_time_ps`: -1 means through the end of simulation. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `max_transitions` (integer): Cap on returned transitions (earliest in range kept). Raise explicitly only for deliberate bulk extraction; prefer narrowing the time range.
- `signal_path` (string, required)
- `start_time_ps`: Window start. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `wave_path` (string, required)

### `get_signals_around_time` (~715 tokens)

Return values and transitions for multiple signals in a NARROW window around a target timestamp (typically the failure time). Designed for local causal-chain inspection; NOT for bulk trace extraction. For round-by-round or multi-cycle sampling use get_signals_by_cycle.

Unit reminder: all times are picoseconds. If the sim log reports `Time: X ns`, set center_time_ps = X*1000 (example: 75,100 ns -> 75,100,000 ps).

Typical window_ps:
  \- Glitch inspection:     1,000 - 5,000 ps
  \- One clock cycle:       = clock_period_ps (NOT exposed by
                             get_waveform_summary; use
                             get_signals_by_cycle after you
                             identify a clock_path, or read it
                             from your sim environment /
                             compile log)
  \- N cycles around fail:  N * clock_period_ps

The server enforces a cap of MAX_WAVE_WINDOW_CYCLES (default 256) clock cycles per call, computed at runtime from an auto-detected clock_period_ps. It also rejects center_time_ps past the recorded simulation end. For multi-cycle sampling, get_signals_by_cycle still requires an explicit clock_path. FSDB support depends on fsdb_runtime.enabled.

If a value_at_center is a SUB-CYCLE TRANSIENT — a combinational glitch at the clock edge that settles back within the same cycle (e.g. an interconnect mux re-settling to idle for ~1ns at each edge) — the result sets `transient_note` and the signal carries `center_transient`/`center_settles_to`/`center_settle_ps`. Treat the SETTLED value as the protocol value; do not attribute a root cause to an edge-sampled value that is flagged transient.

return_mode="values_only" keeps the atomic multi-signal sample but strips the transition lists from every signal: each entry carries value_at_center + window_transition_count (+ any transient annotation, computed before stripping). Use it when you only need the values at one instant — e.g. comparing the same time point across several trace…

Input parameters:

- `center_time_ps` (required): Center time in PICOSECONDS (not ns). Convert sim-log ns via *1000. Must be within the waveform duration reported by get_waveform_summary. Accepts an integer (ps), a cursor reference like '@div_3a7c',…
- `extra_transitions` (integer): Extra transitions to include before the time window. Default: 5. 0 means none.
- `return_mode` (string): values_only drops transitions_in_window/pre_window_transitions from every signal, returning value_at_center + window_transition_count (+ transient annotation). Compact point-sample mode for multi-tra…
- `signal_paths` (array, required): List of full hierarchical signal paths. A bare bus name (no [msb:lsb]) is auto-completed when unique (see resolved_aliases); unresolved names get did_you_mean entries in signal_suggestions.
- `wave_path` (string, required)
- `window_ps` (integer): Half-window in ps (center +/- window_ps). Default: 2000. Hard cap: MAX_WAVE_WINDOW_CYCLES clock cycles. For N-cycle sweeps prefer get_signals_by_cycle.

### `get_signals_by_cycle` (~368 tokens)

Return cycle-by-cycle sampled values for multiple signals aligned to a clock edge. Useful for state machines, pipelines, and round-by-round algorithm checks.

Input parameters:

- `clock_path` (string, required): Full hierarchical clock path, for example top_tb.des_clk
- `edge` (string): Sampling edge. Default: posedge
- `end_time_ps`: Alternative count axis: window end; num_cycles is derived as the count of clock edges in [start, end_time_ps] (inclusive). Mutually exclusive with num_cycles. Accepts an integer (ps), a cursor refere…
- `num_cycles` (integer): Number of cycles to sample. Default: 16. The server caps a single query at 256 cycles. Mutually exclusive with end_time_ps.
- `sample_offset_ps` (integer): Sampling offset relative to the clock edge in ps. Default: 1, to capture post-delta register values.
- `signal_paths` (array, required): List of full hierarchical signal paths to sample. A bare bus name (no [msb:lsb]) is auto-completed when unique (see resolved_aliases); unresolved names get did_you_mean entries in signal_suggestions.
- `start_cycle` (integer): Starting cycle index (0-based). Default: 0. Mutually exclusive with start_time_ps.
- `start_time_ps`: Alternative start axis: window start; snapped to the first clock edge at/after this time. Mutually exclusive with start_cycle. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit…
- `wave_path` (string, required): Absolute path to the waveform file

### `get_waveform_summary` (~42 tokens)

Return basic waveform metadata such as format, duration, and top modules. FSDB support depends on fsdb_runtime.enabled.

Input parameters:

- `wave_path` (string, required)

### `build_tb_hierarchy` (~238 tokens)

Stream one compile/elaborate log plus optional complementary phase logs, scan source files, and cache the full testbench hierarchy server-side without retaining raw source bodies. For split VCS flows, prefer the source-compile log as compile_log and pass VHDL/source/elaboration companions in build order; later connectivity tools continue using that primary path. Returns a SLIM payload: project, stats, tree_skeleton (depth 2), interfaces, ambiguous_basenames, build_metrics, and hierarchy_handle. A configured timeout/source-byte guard returns build_status='blocked' plus a fixed blocker and no handle. Use a completed handle with get_tb_subtree / lookup_tb_files / find_tb_instance / get_tb_file_detail / get_tb_class_hierarchy / dump_tb_section to access the full data on demand.

Input parameters:

- `compile_log` (string, required): Absolute path to the primary compile or elaborate log
- `simulator` (string): vcs / xcelium / auto (default: auto)
- `supplementary_compile_logs` (array): Optional ordered complementary compile/elaboration logs from the same simulator build; their order participates in the hierarchy and Source Graph identity

### `scan_structural_risks` (~163 tokens)

Run a Scope 1 regex-based structural risk scan on RTL/TB source files from the compile file list. This is a heuristic detector: it reports suspicious patterns, not confirmed root causes. Always read coverage_status: only complete with total_risks=0 supports a clean-scan observation; zero_coverage scanned no supported sources, and degraded covers only part of the source set.

Input parameters:

- `categories` (array): Optional list of risk categories to scan. If omitted, all categories are scanned.
- `compile_log` (string, required): Absolute path to a compile or elaborate log
- `scan_scope` (string): Scan scope version. Currently only scope1 is supported.
- `simulator` (string): vcs / xcelium / auto (default: auto)

### `analyze_failures` (~193 tokens)

Core failure-analysis tool. Focuses on the first occurrence of a single failure group and returns the log summary, raw error context, and waveform snapshot. FSDB support depends on fsdb_runtime.enabled.

Input parameters:

- `extra_transitions` (integer): Extra transitions to include before the window for each signal. Default: 5
- `group_index` (integer): Failure group index to analyze. Default: 0
- `log_path` (string, required): Simulation log path, for example irun.log
- `signal_paths` (array, required): Signal paths to inspect. Clients should confirm full paths with search_signals after inferring candidates from RTL or log output.
- `simulator` (string, required): vcs / xcelium
- `wave_path` (string, required): Waveform file path, for example top_tb.fsdb
- `window_ps` (integer): Waveform window around each failure time in ps. Default: 2000

### `analyze_failure_event` (~100 tokens)

Start from a single normalized failure_event and combine waveform, hierarchy, and source information to return recommended instances, signals, and source files.

Input parameters:

- `compile_log` (string)
- `failure_event` (object, required): Normalized failure_event from parse_sim_log for the same log
- `log_path` (string, required)
- `simulator` (string, required): vcs / xcelium
- `top_hint` (string)
- `wave_path` (string, required)

### `recommend_failure_debug_next_steps` (~100 tokens)

Choose the highest-priority failure to investigate from the current log, waveform, and optional hierarchy, then recommend signals, instances, and suspected failure class. Also suggests a diff_sim_failure_results call to use on the next run.

Input parameters:

- `compile_log` (string)
- `log_path` (string, required)
- `simulator` (string, required): vcs / xcelium
- `top_hint` (string)
- `wave_path` (string, required)

### `get_diagnostic_snapshot` (~253 tokens)

Cold-start accelerator that aggregates cached tool results into a single summary view. It never triggers sub-steps and only reads cache. Returns availability status, compact summaries, and suggested calls for missing steps. The result cache is process-global and survives across cases, so at the start of a new session pass your target case (verif_root and/or case_dir): the snapshot validates the cache against it and reports a clean cold start if the cache belongs to a different case. If you pass no target, a cached sim_paths is returned with summary.carried_over=true to signal it may belong to a previous case — confirm it or re-run get_sim_paths.

Input parameters:

- `case_dir` (string): Absolute path to the specific case directory you are debugging. When given, the snapshot confirms the cached get_sim_paths is for this case; if it is for a different case, the snapshot degrades to a…
- `verif_root` (string): Absolute path to the project's verif/ directory. Builds a suggested_call when get_sim_paths has not run, and validates that a cached get_sim_paths result belongs to this project (mismatch ⇒ honest co…

### `explain_signal_driver` (~818 tokens)

Trace a waveform signal path back to the most likely RTL driver. Supports direct assigns, simple always blocks, and module output ports. Set recursive=true to walk multiple hops upstream across instance boundaries. When a Verdi KDB is detected, an NPI backend transparently engages and walks the elaborated netlist with fan_in_reg_list, crossing instance port boundaries the static source-regex backend cannot reach. Recursive NPI fan-in is admitted inside the native traversal (4,096 states, 32 returned facts); Source Graph and NPI both publish traversal counts, limits, truncation, exhaustive-search, and fixed incomplete reasons. A partial positive prefix is usable evidence but not a complete or exclusive driver-set claim. If NPI is unavailable or cannot return a trustworthy result, TraceWeave next attempts a bounded, on-demand Source Graph projection; Legacy Static remains the normal final fallback. The explicit allow_bounded_bootstrap path is the resource-bounded exception: without a full hierarchy it returns only proved positive Source Graph facts, and an inconclusive/blocker result does not start a whole-source Static scan. Source Graph preserves per-bit port-binding provenance, so mixed bindings such as concatenations, constants, truncation, and width extension are reported as segments instead of forcing an all-or-nothing exact-width match. When a dynamic segment reaches a projection boundary, bounded sibling-scope expansion re-runs the original query from a fresh artifact; constant segments are terminal and never trigger expansion. Signal-not-declared and bit-selection-out-of-range are distinct Source Graph blockers. Legacy Static normalizes trailing numeric selects to the bare RTL symbol, but stops honestly at composite port expressions that need per-bit provenance. Parameter specializations and named generate scopes remain instance-specific; dotted packed struct/union members are mapped from their field-local indices onto exact root-aggregate bits. backend_stat…

Input parameters:

- `allow_bounded_bootstrap` (boolean): If true and full hierarchy is unavailable, prove a hard-bounded single-endpoint Source Graph context. Only positive facts may be returned; no-match remains inconclusive and never triggers a whole-sou…
- `compile_log` (string, required)
- `max_depth` (integer): Maximum recursive depth when recursive=true
- `recursive` (boolean): Whether to trace the upstream driver chain recursively
- `signal_path` (string, required)
- `simulator` (string): vcs / xcelium / auto. Optional — if omitted, server auto-injects the value discovered by get_sim_paths.
- `supplementary_compile_logs` (array): Optional complementary compile/elaboration logs used by bounded bootstrap when no hierarchy handle exists.
- `top_hint` (string)
- `wave_path` (string, required)

### `find_signal_loads` (~553 tokens)

List places that consume (load) a signal: child instance input ports, RHS of assigns/procedural assignments, and always-block sensitivity lists. When a Verdi KDB is detected, an NPI backend transparently engages and resolves the cross-hierarchy / interface-positional / generate-block cases that the static source-regex backend cannot reach. If NPI is unavailable or cannot return a trustworthy result, TraceWeave next attempts the bounded, on-demand Source Graph; Legacy Static remains the normal final fallback (shallow_only). When allow_bounded_bootstrap=true and no full hierarchy exists, only proved positive Source Graph facts are returned; an inconclusive/blocker does not trigger a whole-source Static rescan. backend_status preserves the complete attempt chain and Source Graph coverage/build receipt. claim_semantics separates confidence in returned positive load facts from whole-artifact coverage; exhaustive_search is required before treating the list as all loads, and negative_claim_allowed is required before claiming there are none. A complete Source Graph not_connected is distinct from an inconclusive no-match, which falls through to Static only on the normal full-hierarchy route. Every backend publishes enumeration.{returned_count, output_limit, output_truncated, search_exhaustive, incomplete_reasons, continuation_supported}. High-fanout output is capped at 256; capped positive loads remain usable but are not a complete list, and no backend currently promises a continuation token. Each load query normalizes trailing numeric selects for Legacy Static matching, while Source Graph validates the selected bits against the declaration. Each load carries source_info_origin ('compile_log', 'npi', or 'source_graph') so consumers can tell which provenance produced its file:line.

Input parameters:

- `allow_bounded_bootstrap` (boolean): If true and full hierarchy is unavailable, prove a hard-bounded single-endpoint Source Graph context. Only positive facts may be returned; no-match remains inconclusive and never triggers a whole-sou…
- `compile_log` (string, required)
- `include_expr` (boolean): Include the surrounding expression for each load.
- `kind_filter` (array): Restrict result to a subset of load kinds.
- `max_depth` (integer): Reserved for future transitive walks. Static backend always behaves as 1; NPI backend's fan-out walk is depth-bounded internally regardless of this argument.
- `signal_path` (string, required)
- `simulator` (string): vcs / xcelium / auto. Optional — if omitted, server auto-injects the value discovered by get_sim_paths.
- `supplementary_compile_logs` (array): Optional complementary compile/elaboration logs used by bounded bootstrap when no hierarchy handle exists.
- `top_hint` (string)

### `trace_signal_path` (~233 tokens)

Find a structural connectivity path between two signals. A trusted Verdi NPI result wins; otherwise TraceWeave tries a bounded, dual-endpoint Source Graph before Legacy Static. Source Graph follows only projected IR facts across bindings and supported combinational dependencies. claim_semantics reports confidence in a proved positive path independently from global coverage; a found path is not an exhaustive enumeration. A no-path result is exact only when negative_claim_allowed=true; an inconclusive result falls through to unsupported_reason='static_backend_no_path_api'. This is connectivity, NOT temporal driver direction — use explain_signal_driver for driver semantics.

Input parameters:

- `compile_log` (string, required)
- `expand_assigns` (boolean): Expose supported assignment transitions. NPI may show assign cells; Source Graph shows only real IR/source evidence and never invents an NPI cell identity. This changes presentation, not the connecti…
- `from_signal` (string, required)
- `simulator` (string): vcs / xcelium / auto. Optional — auto-injected from get_sim_paths.
- `to_signal` (string, required)
- `top_hint` (string)

### `build_kdb` (~261 tokens)

Auto-build a Verdi KDB from a parsed compile log using vericom + elabcom. Use this when the simulator is Xcelium (xrun) and the NPI backend reports no KDB, or to force-refresh a stale cached KDB. Output is cached under TRACEWEAVE_CACHE_DIR (default ~/.cache/traceweave/kdb/<hash>/); cache hits reuse the previous KDB without re-invoking Verdi. When TRACEWEAVE_NPI_EXECUTION=lsf, every cache-miss/rebuild runs on the configured LSF queue and never falls back to a local licensed build. A runnable build.sh is written next to the KDB for inspection or reproduction. Requires VERDI_HOME with bin/vericom and bin/elabcom.

Input parameters:

- `compile_log` (string, required): Absolute path to the compile/elaborate log to drive the build from.
- `force_rebuild` (boolean): Rebuild even if the cache key matches an existing KDB. Default: false.
- `simulator` (string): vcs / xcelium / auto. Optional — auto-detected from the log when omitted.
- `top_hint` (string): Override the top module. Defaults to the first non-recorder top in compile_result.

### `trace_x_source` (~285 tokens)

When a signal shows X/Z at a target time, trace its propagation chain through upstream driver logic. Uses the selected connectivity route (trusted local/LSF NPI, bounded Source Graph, then Static). A Source Graph trace may expand to bounded direct-child frontiers when an unresolved parent net can be driven by a child output. Any backend or artifact change discards the partial chain and restarts from the original signal, so one returned chain never mixes provenance. Connectivity queries run outside waveform locks. backend_status reports selected versus actual backend; trace_restarted reports a whole-trace retry. Source Graph chain nodes preserve claim_semantics, so an exact positive edge can be used without implying global coverage or exclusive drive. NPI testbench-driven/cross-check evidence is preserved on the node.

Input parameters:

- `compile_log` (string, required)
- `max_depth` (integer): Maximum trace depth. Default: 20
- `signal_path` (string, required)
- `simulator` (string): vcs / xcelium / auto. Optional — if omitted, server auto-injects the value discovered by get_sim_paths.
- `time_ps` (required): Trace start time. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `top_hint` (string)
- `wave_path` (string, required)

### `get_tb_subtree` (~124 tokens)

Return a slice of the component_tree starting at `root` (dotted instance path) with up to `depth` levels. Use after build_tb_hierarchy to drill into a branch without pulling the whole tree into context.

Input parameters:

- `depth` (integer): -1 = unbounded; otherwise number of levels to include
- `handle` (string, required): hierarchy_handle from build_tb_hierarchy
- `max_nodes` (integer): hard cap on emitted nodes
- `root` (string): dotted instance path (e.g. 'top.u_cpu'); empty = top module

### `lookup_tb_files` (~150 tokens)

Query the compiled file set by objective scan facts. At least one filter is required. Use this to disambiguate multi-version files (basename collisions are also reported via build_tb_hierarchy.ambiguous_basenames).

Input parameters:

- `basename` (string): exact basename match
- `contains_uvm` (boolean): scan saw `import uvm_pkg::` or `extends uvm_*`
- `file_type` (string): module | interface | package | class | program (from SV scan)
- `handle` (string, required)
- `has_module` (string): file defines this module
- `limit` (integer)
- `name_contains` (string)
- `path_contains` (string)

### `find_tb_instance` (~74 tokens)

Locate instance(s) in the component_tree by exact path OR by module name. `path` and `module` are mutually exclusive.

Input parameters:

- `handle` (string, required)
- `limit` (integer)
- `module` (string): module name; returns all instances
- `path` (string): exact dotted instance path

### `get_tb_file_detail` (~56 tokens)

Return symbols (modules/classes/interfaces) defined in a single compiled file. If the path is not in the compile set, error includes basename-similar suggestions.

Input parameters:

- `handle` (string, required)
- `path` (string, required)

### `get_tb_class_hierarchy` (~63 tokens)

Return UVM/class inheritance tree built from compiled-source scan results. Use `root_class` to start from a specific class; empty = all roots.

Input parameters:

- `depth` (integer)
- `handle` (string, required)
- `root_class` (string)

### `dump_tb_section` (~47 tokens)

Escape hatch: return a named raw section of the full hierarchy result. Prefer targeted handle tools — this is intentionally heavy.

Input parameters:

- `handle` (string, required)
- `section` (string, required)

### `cursor_set` (~110 tokens)

Register a named time anchor (in ps) for the current session. Other tools that take a time may reference '@<name>' instead of copying ps integers across calls. Cursors are process-scoped and dropped on server restart. Names must match [A-Za-z_][A-Za-z0-9_-]*.

Input parameters:

- `name` (string, required): Cursor name.
- `note` (string): Optional human-readable note.
- `time_ps` (integer, required): Anchor time in ps. Must be >= 0.

### `cursor_list` (~22 tokens)

List all cursors registered in the current session, ordered by time.

### `cursor_delete` (~30 tokens)

Delete a named cursor. Returns whether the cursor existed.

Input parameters:

- `name` (string, required): Cursor name to delete.

### `diff_first_divergence` (~280 tokens)

Find the first time two signals hold unequal values. Works across two waveforms (passing run vs failing run) or within one waveform between two signals (expected vs actual). Auto-registers a cursor at the divergence time so downstream calls can reference it by name. Reads existing waveforms only — does NOT rerun simulation.

Input parameters:

- `cursor_name` (string): Optional explicit cursor name. If omitted, a deterministic name (div_<sha8>) is generated.
- `cursor_note` (string): Optional note attached to the registered cursor.
- `end_time_ps`: End of comparison window. -1 means end of simulation. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `signal_a` (string, required): Full hierarchical signal path in wave_path_a.
- `signal_b` (string, required): Full hierarchical signal path in wave_path_b.
- `start_time_ps`: Start of comparison window. Default 0. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `wave_path_a` (string, required): First waveform (FSDB or VCD).
- `wave_path_b` (string, required): Second waveform. May equal wave_path_a for within-run diff.

### `period` (~309 tokens)

Estimate a signal's dominant period inside a window and flag the first beat that deviates from it. Use for rhythm/throughput questions an LLM cannot eyeball from a transition dump: stalled clocks, dropped burst beats, backpressure bubbles, irregular strobes. The dominant period is the median edge-to-edge interval; the first off-beat is auto-registered as a cursor. Reads existing waveforms only — does NOT rerun simulation.

Input parameters:

- `cursor_name` (string): Optional explicit cursor name for the first off-beat. Defaults to beat_<sha8>.
- `cursor_note` (string): Optional note attached to the registered cursor.
- `edge` (string): Edge to count. 'any' for multi-bit/strobe signals. Default posedge.
- `end_time_ps`: Window end. -1 means end of simulation. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `signal` (string, required): Full hierarchical signal path.
- `start_time_ps`: Window start. Default 0. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `tolerance_frac` (number): Fraction of the period a beat may deviate before counting as an off-beat. Default 0.05 (5%).
- `wave_path` (string, required): Waveform (FSDB or VCD).

### `suggest_handshakes` (~200 tokens)

Scan a waveform and propose ready-to-use inspect_handshake bundles: it pairs *valid/*ready signals by scope and stem, finds the clock, and groups the channel payload buses (the signals that must hold steady during a stall). Use this BEFORE inspect_handshake so you don't have to hand-assemble {clock, valid, ready, payload} signal paths. Covers AXI *valid/*ready, generic valid/ready, and req/ack. It does NOT synthesise an AHB 'valid' (there is no literal valid signal — it is htrans != IDLE); use suggest_protocol_bundles for AHB/APB. Reads existing waveforms only.

Input parameters:

- `max_candidates` (integer): Max bundles to return. Default 8.
- `scope` (string): Optional hierarchy prefix to restrict candidates (e.g. 'tb_top.u_dut').
- `wave_path` (string, required): Waveform (FSDB or VCD).

### `suggest_protocol_bundles` (~243 tokens)

Scan a waveform for protocol-specific AHB/APB bundles. AHB candidates return ready-to-use inspect_handshake args with valid_htrans + ready + payload (address-phase control), plus hwrite/write_data (HWDATA, for the write data-phase hold check) ONLY on initiator-side interfaces (a responder's HWDATA is an interconnect-mux output that glitches at the clock edge, so the check is withheld there to stay zero-FP), because AHB has no literal valid signal. APB candidates return psel/penable/pready facts and loudly report that inspect_handshake still needs a derived valid signal for psel && penable. Direction tags are mechanical discovery facts only; unknown/conflicting markers degrade to direction_tag='unknown' rather than guessing a side. Reads existing waveforms only.

Input parameters:

- `max_candidates` (integer): Max bundles to return. Default 8.
- `protocol` (string, required): Protocol bundle family to discover.
- `scope` (string): Optional hierarchy prefix to restrict candidates (e.g. 'tb_top.u_dut').
- `wave_path` (string, required): Waveform (FSDB or VCD).

### `sweep_handshakes` (~431 tokens)

Whole-design handshake anomaly sweep: discover EVERY valid/ready interface and every AHB interface, then inspect each over the window in one call, returning a comparative fact table (per-interface stalls, deadlock signature ended_in_stall, x-while-valid, payload-hold, write-data-hold, premature valid deassertion, backpressure) ordered by a transparent mechanical key. Use on opaque global symptoms (timeout/hang) when you don't know which of many interfaces misbehaves — it collapses N suggest+inspect round-trips into one. Always interpret flagged_count together with coverage_status: zero_coverage means no protocol interfaces were checked and is NOT a pass; truncated/degraded means partial coverage. Workflow follow-ups relay only parameter-changing retries: an unscoped zero-coverage result is not blindly replayed, but remains inconclusive. FSDB native transition-buffer truncation is propagated per row and forces degraded coverage; zero findings then cover only returned prefixes. Returns FACTS, not a root-cause verdict; re-rank as the symptom warrants. Reads existing waveforms only.

Input parameters:

- `edge` (string): Clock edge to sample on. Default posedge.
- `end_time_ps`: Window end. -1 = end of trace. Accepts ps int, '@cursor', or unit literal.
- `max_interfaces` (integer): Max interfaces to sweep (default 64). If discovery exceeds this the result is flagged truncated=true — raise it for full coverage.
- `max_wait_cycles` (integer): Stall length (cycles) above which a stall becomes a long_stall finding. Default 16.
- `scope` (string): Optional hierarchy prefix to limit the sweep (e.g. 'tb_top.u_dut'). If the scope contains no discovered interfaces the result reports coverage_status=zero_coverage; retry unscoped or with a parent/in…
- `start_time_ps`: Window start (ps int, '@cursor', or unit literal like '12.3ns'). Default 0.
- `wave_path` (string, required): Waveform (FSDB or VCD).

### `verify_window` (~769 tokens)

Evaluate a temporal predicate over a clock window and return a precise verdict (holds) plus a concrete witness/counterexample (cycle + sampled values). You state the predicate; the tool checks it against the waveform over thousands of cycles you cannot read yourself. Templates, not a DSL: a term is {signal, op, value} (op: eq/ne/gt/ge/lt/le/is_x/is_known); a predicate is a list of terms (implicit AND — run two calls for OR). Modes: always(P), never(P), eventually(P), implication (A |-> B within N cycles, the protocol-response template; set overlap=false for |=> = a stability/hold property where B must STILL hold the NEXT cycle, e.g. HTRANS/valid held through a wait state), and sequence (the per-accepted-beat increment of a signal — address-stride checks like AHB haddr +stride; supports modulo for WRAP bursts and restart_when for burst boundaries). x/z cycles are reported as unknown (never silently passed); an implication whose response window runs past end-of-trace is reported inconclusive (never silently failed). On a finding it sets violating_signal + a next_action to explain_signal_driver (bus facts do not self-attribute master/slave). Use to prove/disprove an RTL inference in one call. Reads existing waveforms only.

Input parameters:

- `antecedent` (array): implication only: the A predicate (list of terms).
- `clock` (string, required): 1-bit clock signal full path.
- `consequent` (array): implication only: the B predicate that must follow A.
- `cursor_name` (string): Optional explicit cursor name for the witness/counterexample.
- `cursor_note` (string): Optional note for the registered cursor.
- `delta` (object): sequence only: check the per-accepted-beat increment of one signal. predicate is the accepted-beat gate (e.g. hready==1 && htrans active). E.g. AHB byte INCR: {signal:'top.haddr', value:1}. For WRAP…
- `edge` (string): Clock edge to sample on. Default posedge.
- `end_time_ps`: Window end. -1 = end of trace.
- `mode` (string, required): Temporal template to evaluate.
- `overlap` (boolean): implication only. true (default, |->): the response window includes A's own cycle. false (|=>): the window starts the NEXT cycle [i+1, i+within] — use this for a stability/hold property ('B must STIL…
- `predicate` (array): always/never/eventually: list of {signal, op, value} terms, AND-combined.
- `start_time_ps`: Window start (ps int, '@cursor', or unit literal). Default 0.
- `wave_path` (string, required): Waveform (FSDB or VCD).
- `within_cycles` (integer): implication only: B must hold within this many cycles of A. The response window is [i, i+within] when overlap=true (includes A's cycle) or [i+1, i+within] when overlap=false. Default 1.

### `reconstruct_transactions` (~1003 tokens)

Reconstruct id-correlated request/response transactions from two handshake channels: walk every clock edge, match accepted request beats to completion beats by id, and return per-transaction latency plus aggregate facts (outstanding curve incl. per-id peak, ordering, unmatched=hang signature). One generic core, not a tool per protocol. AXI READ: req=AR (req_valid=arvalid, req_ready=arready, req_id=arid), cmp=R (cmp_valid=rvalid, cmp_ready=rready, cmp_id=rid, cmp_last=rlast); AXI WRITE: req=AW (awvalid/awready/awid), cmp=B (bvalid/bready/bid, no cmp_last). Pass req_fields/cmp_fields (e.g. araddr,arlen / rresp) to capture payload per txn; pass req_len (arlen/awlen) to also check each txn's beat_count against AxLEN+1 (beat_count_mismatch). Out-of-order completion across ids is supported (per-id FIFO); reorder_count is an informational FACT (legal in AXI), latency is a distribution not an 'outlier' verdict. Reads waveforms only.

Input parameters:

- `active_high` (boolean): valid/ready/last polarity. Default true.
- `capture_beats` (boolean): Include per-beat data (data_beats[]) on each txn. Default false (only beat_count). Enable for data-integrity debugging; can be large.
- `clock` (string, required): Shared 1-bit clock full path (e.g. AXI aclk).
- `cmp_fields` (array): Optional completion payload signals to capture per txn (e.g. rresp, bresp).
- `cmp_id` (string): Completion id bus (e.g. rid/bid). Optional; see req_id (omit both for in-order FIFO pairing).
- `cmp_last` (string): Optional last-beat signal (e.g. rlast). With it, a multi-beat burst completes one txn on last; without it every completion beat is a txn (e.g. AXI B channel).
- `cmp_ready` (string, required): Completion channel ready (e.g. rready/bready).
- `cmp_valid` (string, required): Completion channel valid (e.g. rvalid/bvalid).
- `cursor_name` (string): Optional explicit cursor name.
- `cursor_note` (string): Optional cursor note.
- `data_fields` (array): AXI WRITE only: W-channel payload to capture per beat (e.g. wdata, wstrb).
- `data_last` (string): AXI WRITE only: W-channel last (wlast); marks the end of a write burst's data.
- `data_ready` (string): AXI WRITE only: W-channel ready (wready).
- `data_valid` (string): AXI WRITE only: W-channel valid (wvalid). The W channel carries no id; beats attach in order to the oldest data-incomplete request. Needs data_ready too.
- `edge` (string): Clock edge to sample on. Default posedge.
- `end_time_ps`: Window end. -1 = end of trace.
- `max_transactions` (integer): Max txn records returned (default 256); counts/stats are over ALL. Sets transactions_truncated when exceeded.
- `req_fields` (array): Optional request payload signals to capture per txn (e.g. araddr, arlen, arsize, arburst).
- `req_id` (string): Request id bus (e.g. arid/awid). Optional: omit both req_id and cmp_id for an unindexed in-order stream (AXI-Lite, APB) — txns pair in FIFO order and report id=null.
- `req_len` (string): Optional AxLEN bus (arlen/awlen). Each txn's observed beat_count is compared to req_len+1; a mismatch (early/late LAST, dropped/extra beat) is a real burst-length violation, surfaced per-txn (beat_co…
- `req_ready` (string, required): Request channel ready (e.g. arready/awready).
- `req_valid` (string, required): Request channel valid (e.g. arvalid/awvalid).
- `reset` (string): Optional reset signal; while asserted, in-flight transactions are cleared so a txn straddling reset is not reported as a phantom hang.
- `reset_active_low` (boolean): reset is active-low (rst_n). Default true.
- `start_time_ps`: Window start (ps int, '@cursor', or unit literal). Default 0.
- `timeout_cycles` (integer): Optional: count completed txns with latency above this many cycles (slow_count fact).
- `wave_path` (string, required): Waveform (FSDB or VCD).

### `inspect_handshake` (~1112 tokens)

Classify a clocked valid/ready handshake cycle-by-cycle and report protocol facts that leave no value pattern in scoreboard logs: stalls (valid high, ready low), the longest/over-threshold stall windows, backpressure imbalance (ready high, valid low), and — when payload signals are given — payload-hold violations (a payload that changes while the transfer is still stalled), and premature valid deassertion (a stalled beat whose valid/htrans drops before ready/HREADY arrives — the AHB master-not-waiting-for-HREADY bug, which needs no payload to detect). For AHB (valid_htrans) it ALSO runs x_while_valid (a control field is x/z while valid is asserted) and, when hwrite+write_data are given, a write data-phase HWDATA-hold check (HWDATA must stay stable through a write data-phase wait state). Protocol-agnostic: AXI *valid/*ready, an AHB pair (ready=hready, valid=a 1-bit 'htrans!=IDLE' signal, payload=[haddr,hwrite,hsize] address-phase control which must hold while hready is low; HWDATA goes in write_data, not payload), a generic valid-ready stream, or a credit interface. Returns coverage facts for the checks it actually ran (stall, backpressure, payload-hold, valid-hold, x-while-valid, write-data-hold) without assigning protocol side. Auto-registers a cursor at the first problem (x-while-valid > payload-hold > write-data hold > premature deassertion > long stall > longest stall). On AHB it also returns a protocol_semantics receipt naming which metrics are faithful vs suppressed. For the one-sided violations (x-while-valid, payload-hold, write-data hold, premature deassertion) it also returns a structured `attribution` block (violating_side=valid_driver, exonerated_side=ready_driver) so the caller does NOT start in the slave driver/monitor — the responder cannot cause either; a plain two-sided stall leaves attribution empty. Reads existing waveforms only — does NOT rerun simulation.

Input parameters:

- `active_high` (boolean): valid/ready are active-high. Set false for active-low handshakes. Default true.
- `check_payload_hold` (boolean): Flag payload changes during a stall. Default true (only meaningful when payload is given).
- `check_valid_hold` (boolean): Flag premature valid/transfer deassertion: a stalled beat (valid high, ready low) whose valid goes low the next edge before ready arrives = the master dropped the transfer instead of waiting (e.g. AH…
- `clock` (string, required): 1-bit clock signal full path.
- `cursor_name` (string): Optional explicit cursor name. Defaults to hs_<sha8>.
- `cursor_note` (string): Optional note attached to the registered cursor.
- `edge` (string): Clock edge to sample on. Default posedge.
- `end_time_ps`: Window end. -1 means end of simulation. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `htrans_rule` (string): How valid_htrans derives valid. 'active' (default) = NONSEQ/SEQ (htrans[1]==1); 'non_idle' = htrans != IDLE (counts BUSY too).
- `hwrite` (string): AHB only: path to HWRITE. With write_data, enables the write data-phase HWDATA-hold check.
- `max_wait_cycles` (integer): A stall longer than this many cycles becomes a long_stall finding. Default 16.
- `payload` (array): Optional signals that MUST stay stable while stalled (e.g. AHB htrans/haddr/hwrite/hsize, AXI awaddr/awlen). A mid-stall change is a payload_hold_violation. For AHB do NOT include hwdata here — pass…
- `ready` (string, required): Receiver ready/grant signal (1-bit). For AHB, hready.
- `start_time_ps`: Window start. Default 0. Accepts an integer (ps), a cursor reference like '@div_3a7c', or a unit literal like '12.34ns'.
- `valid` (string): Initiator valid/request signal (1-bit). Provide this OR valid_htrans.
- `valid_htrans` (string): AHB only: path to the htrans signal. A derived valid is computed from it (AHB has no literal valid). Provide this OR valid, not both.
- `wave_path` (string, required): Waveform (FSDB or VCD).
- `write_data` (string): AHB only: path to HWDATA. With hwrite, checks that write data is held stable through a data-phase wait state (HREADY low) — a write_data_hold_violation otherwise. This is the data-phase window, disti…

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Vulnerabilities, Dependencies. The full working is on the page: https://verifymcp.io/servers/gokeshenzhen-traceweave/traceweave-mcp#diagnostics

## Score history

- 2026-09-30: 83
- 2026-09-29: 85
- 2026-09-28: 85
- 2026-09-27: 74
- 2026-09-26: 74
- 2026-09-25: 73
- 2026-09-24: 55
- 2026-09-23: 70
- 2026-09-22: 69
- 2026-09-21: 54
- 2026-09-20: 53
- 2026-09-19: 53
- 2026-09-18: 52
- 2026-09-17: 52
- 2026-09-16: 51
- 2026-09-15: 51
- 2026-09-14: 65
- 2026-09-13: 50
- 2026-09-12: 49
- 2026-09-11: 49
- 2026-09-10: 48
- 2026-09-09: 48
- 2026-09-08: 48
- 2026-09-07: 47
- 2026-09-06: 43
- 2026-09-05: 43
- 2026-09-04: 43
- 2026-09-03: 43
- 2026-09-02: 43
- 2026-09-01: 43

## Common questions

### What is the TraceWeave MCP server?

TraceWeave is an MCP server listed in the public MCP registry as io.github.gokeshenzhen/traceweave. Portable MCP runtime for RTL logs and VCD; repository setup adds FSDB and site EDA integration. This page covers its PyPI package (traceweave-mcp).

### Is the TraceWeave MCP server safe to use?

TraceWeave scores 83 out of 100 on VerifyMCP. We recorded 6 known advisories against it as of 30 September 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the TraceWeave MCP server expose?

TraceWeave exposes 38 tools: get_sim_paths, parse_sim_log, diff_sim_failure_results, get_error_context, search_signals, and 33 more. Their descriptions and schemas cost roughly 10,754 tokens of context every time the server is loaded.

### Is the TraceWeave MCP server still maintained?

TraceWeave is still listed as active in the MCP registry. We last reached this channel on 30 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the TraceWeave MCP server under?

TraceWeave declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/traceweave-mcp/
- Socket report: https://socket.dev/pypi/package/traceweave-mcp
- Repository: https://github.com/gokeshenzhen/TraceWeave
- Changelog RSS feed: https://verifymcp.io/servers/gokeshenzhen-traceweave/traceweave-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/gokeshenzhen-traceweave/traceweave-mcp.json
- HTML version of this page: https://verifymcp.io/servers/gokeshenzhen-traceweave/traceweave-mcp