paiml-mcp-agent-toolkit
Pragmatic AI Labs MCP Agent Toolkit - An MCP Server designed to make code with agents more deterministic
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Check it deeper on your machine
It has changed since its scan on 11 Nov 2026.
As a Claude Code plugin, install it and then ask Claude Code:
/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/paiml/paiml-mcp-agent-toolkit with scanskillsafety
Or from a terminal, clone it and run it:
git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/paiml/paiml-mcp-agent-toolkit'
It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.
Badge for your README
Markdown
[](/listings/paiml--paiml-mcp-agent-toolkit)HTML
<a href="/listings/paiml--paiml-mcp-agent-toolkit"><img src="/api/listings/paiml--paiml-mcp-agent-toolkit/badge.svg" alt="findsafeskills safety rating" /></a>Install
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
# Install from crates.io cargo install pmat
> **Note for macOS Users:** If you experience issues installing via `rustup`, we recommend installing/updating Rust using Homebrew: `brew install rust` before running `cargo install pmat`.
# Or from source (latest) git clone https://github.com/paiml/paiml-mcp-agent-toolkit cd paiml-mcp-agent-toolkit && cargo install --path .
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
README.md · README · 659 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- <h1 align="center">PMAT</h1>
- <p align="center">
- <img src="docs/images/pmat-logo.svg" alt="PMAT" width="500">
- </p>
- <p align="center">
- <strong>Zero-configuration AI context generation for any codebase</strong>
- </p>
- <div align="center">
- [](https://crates.io/crates/pmat)
- [](https://docs.rs/pmat)
- [](https://github.com/paiml/paiml-mcp-agent-toolkit)
- [](https://github.com/paiml/paiml-mcp-agent-toolkit)
- [](LICENSE)
- [](https://www.rust-lang.org)
- [](CHANGELOG.md)
- [Installation](#installation) | [MCP Server](#mcp-server) | [Usage](#usage) | [Features](#features) | [Examples](#examples) | [Documentation](https://paiml.github.io/pmat-book/)
- </div>
- ---
- ## Table of Contents
- - [What is PMAT?](#what-is-pmat)
- - [Installation](#installation)
- - [MCP Server](#mcp-server)
- - [Usage](#usage)
- - [Features](#features)
- - [Architecture](#architecture)
- ## What is PMAT?
- **PMAT** (Pragmatic Multi-language Agent Toolkit) provides everything needed to analyze code quality and generate AI-ready context:
- - **Context Generation** - Deep analysis for Claude, GPT, and other LLMs
- - **Technical Debt Grading** - A+ through F scoring with 6 orthogonal metrics
- - **Mutation Testing** - Test suite quality validation (85%+ kill rate)
- - **Repository Scoring** - Quantitative health assessment (0-289 scale, 11 categories)
- - **Git History RAG** - Semantic search across commit history with RRF fusion
- - **Semantic Search** - Natural language code discovery
- - **Compliance Governance** - 157 checks across code quality, best practices, and reproducibility
- - **Design by Contract** - Toyota Way contract profiles with checkpoint validation and rescue protocols
- - **Autonomous Kaizen** - Toyota Way continuous improvement with auto-fix and commit
- - **MCP Integration** - 20 tools for Claude Code, Cline, and AI agents over **stdio and HTTP** (identical surfaces), validated end-to-end for concurrent multi-agent (ultracode) workflows — see [MCP Server](#mcp-server)
- - **Quality Gates** - Pre-commit hooks, CI/CD integration, `.pmat-gates.toml` config
- - **20+ Languages** - Rust, TypeScript, Python, Go, Java, C/C++, Lua, Lean, and more
- Part of the [PAIML Stack](https://github.com/paiml), following Toyota Way quality principles (Jidoka, Genchi Genbutsu, Kaizen).
- ### Annotated Code Search
- <div align="center">
- <img src="docs/images/pmat-query-screenshot.png" alt="pmat query annotated output" width="800">
- <p><em><code>pmat query "cache invalidation" --churn --duplicates --entropy --faults</code></em></p>
- </div>
- Every result includes TDG grade, Big-O complexity, git churn, code clones, pattern diversity, fault annotations, call graph, and syntax-highlighted source.
- ## Installation
- ```bash
- # Install from crates.io
- cargo install pmat
- ```
- > **Note for macOS Users:** If you experience issues installing via `rustup`, we recommend installing/updating Rust using Homebrew: `brew install rust` before running `cargo install pmat`.
- ```bash
- # Or from source (latest)
- git clone https://github.com/paiml/paiml-mcp-agent-toolkit
- cd paiml-mcp-agent-toolkit && cargo install --path .
- ```
- ## MCP Server
- PMAT is an MCP server first and a CLI second. One binary serves **three surfaces**, and
- they share one tool registry — you pick a surface, not a feature set.
- | Surface | Start it with | Use it when |
- |---------|---------------|-------------|
- | **CLI** | `pmat analyze complexity --path .` | A human or a shell script reads the output. |
- | **MCP over stdio** | `pmat --mode mcp` | An MCP client launches pmat itself as a subprocess — Claude Code, Claude Desktop, Cline. One client, one process, no port, no token. |
- | **MCP over HTTP** | `pmat serve --transport http --port 8765` | One long-lived server that several clients — or another machine — talk to. Streamable HTTP, bearer auth. |
- > **New in 3.32.0:** `mcp-http` moved into the **default** feature set. `cargo install pmat`
- > now gives you the HTTP transport; the old `--features mcp-http` dance is gone. Compiling
- > the transport in does not open a socket — only `pmat serve` binds one.
- ### Quickstart — stdio
- Claude Code launches pmat as a subprocess. Nothing to keep running, nothing to authenticate.
- ```bash
- cargo install pmat
- claude mcp add --scope user pmat -- pmat --mode mcp
- claude mcp list
- # pmat: pmat --mode mcp - ✔ Connected
- ```
- Claude Desktop takes the same command as JSON, in its own `claude_desktop_config.json`:
- ```json
- {
- "mcpServers": {
- "pmat": { "command": "pmat", "args": ["--mode", "mcp"] }
- }
- }
- ```
- For clients that cannot pass flags, `MCP_VERSION=1 pmat` starts the identical server.
- Smoke-test the stdio surface without any client at all:
- ```bash
- printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' \
- | pmat --mode mcp 2>/dev/null | jq -r '.result.tools | length'
- # 19
- ```
- ### Quickstart — HTTP
- One server, many clients. Copy-paste the whole block:
- ```bash
- cargo install pmat
- export PMAT_MCP_HTTP_TOKEN='pmat-mcp-demo-token-0123456789' # >= 16 chars; use your own
- pmat serve --transport http --port 8765 &
- # pmat MCP (streamable HTTP) listening on http://127.0.0.1:8765/
- # auth: Bearer, from PMAT_MCP_HTTP_TOKEN; unauthenticated requests get 401
- # tools: 20
- sleep 2
- claude mcp add --scope user --transport http pmat http://127.0.0.1:8765/ \
- --header "Authorization: Bearer $PMAT_MCP_HTTP_TOKEN"
- claude mcp list
- # pmat: http://127.0.0.1:8765/ (HTTP) - ✔ Connected
- ```
- The server binds `127.0.0.1` unless you pass `--host`. To reach it from another machine, bind an
- externally routable address and treat `PMAT_MCP_HTTP_TOKEN` as a real secret — the tool
- surface can read and analyse any path the server process can read.
- ### Four gotchas that cost an hour each
- **1. MCP is served at the root path `/`, not `/mcp`.** There is no path prefix.
- ```bash
- for p in / /mcp /health; do
- printf '%-7s %s\n' "$p" "$(curl -s -o /dev/null -w '%{http_code}' -X POST "http://127.0.0.1:8765$p" \
- -H "Authorization: Bearer $PMAT_MCP_HTTP_TOKEN" \
- -H "Content-Type: application/json" \
- -H "Accept: application/json, text/event-stream" \
- -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}')"
- done
- # / 200
- # /mcp 404
- # /health 404
- ```
- **2. `PMAT_MCP_HTTP_TOKEN` is mandatory and must be at least 16 characters.** Below that
- the server refuses to start rather than falling back to serving unauthenticated — the
- underlying pmcp transport answers every request when no auth provider is wired, so "no
- token" has to mean "no server". Requests with no token, or a wrong one, get `401`.
- ```bash
- PMAT_MCP_HTTP_TOKEN=too-short-123 pmat serve --transport http --port 8765
- # Error: PMAT_MCP_HTTP_TOKEN must be at least 16 characters; got 13
- ```
- **3. Hand-rolled clients must send `Accept: application/json, text/event-stream`.** The
- streamable transport rejects the request without it, and `curl -f` turns that into an
- empty string with no message — so probe with plain `curl -s` while debugging.
- ```bash
- curl -s -w '\n-> HTTP %{http_code}\n' -X POST http://127.0.0.1:8765/ \
- -H "Authorization: Bearer $PMAT_MCP_HTTP_TOKEN" \
- -H "Content-Type: application/json" \
- -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
- # {"jsonrpc":"2.0","error":{"code":-32700,"message":"Accept header must include application/json or text/event-stream"},"id":null}
- # -> HTTP 406
- ```
- **4. There is no `/health` endpoint.** `GET /health` is a `404`, so a `curl -f
- .../health` readiness loop never turns green and never says why. Probe with a real
- `tools/list` call instead:
- ```bash
- curl -s -X POST http://127.0.0.1:8765/ \
- -H "Authorization: Bearer $PMAT_MCP_HTTP_TOKEN" \
- -H "Content-Type: application/json" \
- -H "Accept: application/json, text/event-stream" \
- -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' \
- | jq -r '.result.tools | length'
- # 19
- ```
- No MCP session id is involved: `initialize` returns no `Mcp-Session-Id` header, and
- `tools/call` works directly — with or without a preceding `initialize`.
- ### HTTP is not a reduced surface
- Both transports are built from the same registry, so HTTP serves **all 20 tools, not a
- subset**. The `tools/list` payloads are byte-identical:
- ```bash
- printf '%s\n%s\n' \
- '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"p","version":"1"}}}' \
- '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' \
- | pmat --mode mcp 2>/dev/null \
- | jq -Sc 'select(.id==2)|.result.tools|sort_by(.name)' > /tmp/pmat-stdio-tools.json
- curl -s -X POST http://127.0.0.1:8765/ \
- -H "Authorization: Bearer $PMAT_MCP_HTTP_TOKEN" \
- -H "Content-Type: application/json" \
- -H "Accept: application/json, text/event-stream" \
- -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' \
- | jq -Sc '.result.tools|sort_by(.name)' > /tmp/pmat-http-tools.json
- cmp /tmp/pmat-stdio-tools.json /tmp/pmat-http-tools.json && echo "identical"
- # identical
- ```
- The 19: `analyze_complexity`, `analyze_satd`, `analyze_dead_code`, `analyze_dag`,
- `analyze_deep_context`, `analyze_big_o`, `analyze_reachability`,
- `analyze_hardcoded_paths`, `analyze_vacuous_tests`, `quality_gate`, `quality_proxy`,
- `generate_context`, `scaffold_project`, `git_operation`, `pmat_query_code`,
- `pmat_get_function`, `pmat_find_similar`, `pmat_index_stats`,
- `pdmt_deterministic_todos`. Names and descriptions are also committed as the machine-checked
- manifest [`mcp.json`](mcp.json) at the repository root, regenerated from the server's own
- registrations — so it cannot drift from what the two transports actually serve.
- ### Transports that are not implemented
- `--transport` also accepts `web-socket`, `http-sse`, `both` and `all`. None of them are
- implemented; each exits `2` with a message saying so. `http` is the only value that
- serves.
- ```bash
- pmat serve --transport web-socket --port 8765
- # error: pmat serve --transport websocket is not yet implemented
- ```
- There is no `stdio` value for `--transport` — passing one is a clap error. Stdio is
- `pmat --mode mcp`.
- ## Usage
- ```bash
- # Generate AI-ready context
- pmat context --output context.md --format llm-optimized
- # Analyze code complexity
- pmat analyze complexity
- # Grade technical debt (A+ through F)
- pmat analyze tdg
- # Score repository health
- pmat repo-score .
- # Pre-flight verify before committing (CI-faithful: fmt + complexity + satd + clippy + tests)
- pmat verify --format json
- # Run mutation testing
- pmat mutate --target src/
- # Start the MCP server over stdio, for Claude Code, Cline, etc. (see "MCP Server" above)
- pmat --mode mcp
- ```
- ### Autonomous-agent pre-flight (`pmat verify`)
- `pmat verify` runs the exact gate set CI enforces — **format, complexity, satd, clippy, tests** — fail-fast, with machine-readable output, so an agent gets *"green here ⇒ green in CI"* before committing. The canonical loop: `edit → pmat verify --format json → fix on red → commit on green`. See [`docs/agent-instructions/autonomous-verify-loop.md`](docs/agent-instructions/autonomous-verify-loop.md).
- ### Ultracode validated
- PMAT releases are dogfooded with **ultracode** — Claude Code's multi-agent
- dynamic-workflow orchestration — as both the test harness and the target
- workload:
- - **Full CLI sweep**: 111 commands exercised by parallel agent fleets per release
- - **MCP surface**: all 20 tools validated over stdio JSON-RPC — per-tool calls
- with schema-derived arguments, 8-way concurrent server sessions against one
- working tree (zero lock errors, zero scratch leftovers), and byte-level
- framing checks (stdout is exclusively JSON-RPC) — plus a transport-parity
- check that the HTTP `tools/list` payload is byte-identical to the stdio one
- - **Determinism**: TDG baselines and penalty attributions serialize
- byte-identically across runs, so independent agents converge instead of
- diverging on ordering noise
- - **Concurrency-safe caches**: PID-unique scratch files with atomic
- rename-into-place and stale-orphan sweeping; advisory-locked metric recording
- Findings from each sweep are adversarially re-verified by skeptic agents
- before they drive fixes — see the release case studies in the
- [pmat book](https://paiml.github.io/pmat-book/).
- ## Features
- ### Context Generation
- Generate comprehensive context for AI assistants:
- ```bash
- pmat context # Basic analysis
- pmat context --format llm-optimized # AI-optimized output
- pmat context --include-large-files # Include files >500KB normally skipped
- ```
- ### Technical Debt Grading (TDG)
- Six orthogonal metrics for accurate quality assessment:
- ```bash
- pmat analyze tdg # Project-wide grade
- pmat analyze tdg --include-components # Per-component breakdown
- pmat tdg baseline create # Create quality baseline
- pmat tdg check-regression # Detect quality degradation
- ```
- **Grading Scale:**
- - **A+/A**: Excellent quality, minimal debt
- - **B+/B**: Good quality, manageable debt
- - **C+/C**: Needs improvement
- - **D/F**: Significant technical debt
- ### Mutation Testing
- Validate test suite effectiveness:
- ```bash
- pmat mutate --target src/lib.rs # Single file
- pmat mutate --target src/ --threshold 85 # Quality gate
- pmat mutate --failures-only # CI optimization
- ```
- **Supported Languages:** Rust, Python, TypeScript, JavaScript, Go, C/C++, C#, Lua, Lean, Java, Kotlin, Ruby, Swift, PHP, Bash, SQL, Scala, YAML, Markdown + MLOps model formats (GGUF, SafeTensors, APR)
- ### Repository Health Scoring
- Evidence-based quality metrics (0-289 scale, 11 categories):
- ```bash
- pmat rust-project-score # Fast mode (~3 min)
- pmat rust-project-score --full # Comprehensive (~10-15 min)
- pmat repo-score . --deep # Full git history
- ```
- ### Workflow Prompts
- Pre-configured AI prompts enforcing EXTREME TDD:
- ```bash
- pmat prompt --list # Available prompts
- pmat prompt code-coverage # 85%+ coverage enforcement
- pmat prompt debug # Five Whys analysis
- pmat prompt quality-enforcement # All quality gates
- ```
- ### Git History RAG
- Search git history by intent using TF-IDF semantic embeddings:
- ```bash
- # Fuse git history into code search
- pmat query "fix memory leak" -G
- # Search with churn, clones, entropy, faults
- pmat query "error handling" --churn --duplicates --entropy --faults
- ```
- ```bash
- # Run the example
- cargo run --example git_history_demo
- ```
- ### Git Hooks
- Automatic quality enforcement:
- ```bash
- pmat hooks install # Install pre-commit hooks
- pmat hooks install --tdg-enforcement # With TDG quality gates
- pmat hooks status # Check hook status
- ```
- ### Compliance Governance (`pmat comply`)
- 162 automated checks across code quality, best practices, and governance:
- ```bash
- pmat comply check # Run all compliance checks
- pmat comply check --strict # Exit non-zero on failure
- pmat comply check --format json # Machine-readable output
- pmat comply migrate # Update to latest version
- ```
- **Key Checks:**
- - **CB-200**: TDG Grade Gate — blocks on definitions below the minimum grade (default `A`). Reads the index `pmat query` built; it never builds or rewrites one, and reports Skip / "Not measured" when `.pmat/context.db` is absent
- - **CB-304**: Dead code percentage enforcement
- - **CB-400**: Shell/Makefile quality via bashrs
- - **CB-500**: Rust best practices (30+ patterns)
- - **CB-600**: Lua best practices
- - **CB-900**: Markdown link validation
- - **CB-1000**: MLOps model quality
- **Provable-Contracts Enforcement (CB-1200..1210):**
- - **CB-1208**: Binding existence — verifies `binding.yaml` functions exist in `src/`, detects ghost bindings (L0-L3 enforcement levels)
- - **CB-1209**: Contract trait enforcement — checks `tests/contract_traits.rs` for compiler-verified trait impls (13 kernel traits)
- - **CB-1210**: Precondition quality — flags mass-generated boilerplate and missing postconditions
- Configure via `.pmat.yaml`:
- ```yaml
- comply:
- thresholds:
- min_tdg_grade: "A" # CB-200 floor; `.pmat-gates.toml` [tdg] min_grade overrides this
- pv_lint_is_error: true # CB-1201: FAIL on pv lint failure
- min_binding_existence: 95 # CB-1208: 95% binding verification
- require_all_traits: true # CB-1209: 13/13 traits required
- min_kani_coverage: 20 # CB-1206: minimum Kani proof %
- ```
- ### Infrastructure Score (`pmat infra-score`)
- CI/CD quality scoring (0-100 + 10 bonus for provable-contracts):
- ```bash
- pmat infra-score # Text output
- pmat infra-score --format json # Machine-readable
- pmat infra-score -v --failures-only # Show only failing checks
- ```
- **Categories:** Workflow Architecture (25pts), Build Reliability (25pts),
- Quality Pipeline (20pts), Deployment & Release (15pts), Supply Chain (15pts),
- Provable Contracts bonus (10pts).
- ### Document Search (`pmat query --docs`)
- Search documentation files (Markdown, text, YAML) alongside code:
- ```bash
- pmat query "authentication" --docs # Code + docs results
- pmat query "deployment" --docs-only # Only documentation
- pmat query "API endpoints" --no-docs # Exclude docs (default)
- ```
- ### Autonomous Kaizen (`pmat kaizen`)
- Toyota Way continuous improvement — scan, auto-fix, commit:
- ```bash
- pmat kaizen --dry-run # Scan only (no changes)
- pmat kaizen # Apply safe auto-fixes
- pmat kaizen --push # Fix, commit, and push (use --no-commit to skip)
- pmat kaizen --format json -o report.json # CI/CD integration
- # Cross-stack mode: scan all batuta stack crates in one invocation
- pmat kaizen --cross-stack --dry-run # Scan all crates
- pmat kaizen --cross-stack # Fix and commit per-crate
- pmat kaizen --cross-stack -f json # Grouped JSON report
- ```
- ### Function Extraction (`pmat extract`)
- Extract function boundaries with metadata:
- ```bash
- pmat extract --list src/lib.rs # Function/struct/enum/trait boundaries, as JSON
- ```
- ## Examples
- ### Generate Context for AI
- ```bash
- # For Claude Code
- pmat context --output context.md --format llm-optimized
- # With semantic search
- pmat embed sync --path ./src
- pmat semantic search "error handling patterns"
- ```
- ### CI/CD Integration
- ```yaml
- # Add to your CI pipeline
- steps:
- - uses: actions/checkout@v4
- - run: cargo install pmat
- - run: pmat analyze tdg --fail-on-violation --min-grade B
- - run: pmat mutate --target src/ --threshold 80
- ```
- ### Quality Baseline Workflow
- ```bash
- # 1. Create baseline
- pmat tdg baseline create --output .pmat/baseline.json
- # 2. Check for regressions
- pmat tdg check-regression \
- --baseline .pmat/baseline.json \
- --max-score-drop 5.0 \
- --fail-on-regression
- ```
- ## Architecture
- ```
- pmat/
- ├── src/
- │ ├── cli/ Command handlers and dispatchers
- │ ├── services/ Analysis engines (TDG, SATD, complexity, agent context)
- │ ├── mcp_server/ MCP protocol server
- │ ├── mcp_pmcp/ PMCP protocol integration
- │ └── models/ Configuration and data models
- ├── examples/ 113 runnable examples
- └── docs/
- └── specifications/ Technical specs
- ```
- ## Quality
- | Metric | Value |
- |--------|-------|
- | Tests | 21,200+ passing |
- | Coverage | 99.66% |
- | Mutation Score | >80% |
- | Languages | 20 supported + MLOps model formats |
- | MCP Tools | 20 available |
- ### Falsifiable Quality Commitments
- Per [Popper's demarcation criterion](https://en.wikipedia.org/wiki/Demarcation_problem), all claims are measurable and testable:
- | Commitment | Threshold | Verification Method |
- |------------|-----------|---------------------|
- | **Context Generation** | < 5 seconds for 10K LOC project | `time pmat context` on test corpus |
- | **Memory Usage** | < 500 MB for 100K LOC analysis | Measured via `heaptrack` in CI |
- | **Test Coverage** | ≥ 85% line coverage | `cargo llvm-cov` (CI enforced) |
- | **Mutation Score** | ≥ 80% killed mutants | `pmat mutate --threshold 80` |
- | **Build Time** | < 3 minutes incremental | `cargo build --timings` |
- | **CI Pipeline** | < 15 minutes total | GitHub Actions workflow timing |
- | **Binary Size** | < 50 MB release binary | `ls -lh target/release/pmat` |
- | **Language Parsers** | All 20 languages parse without panic | Fuzz testing in CI |
- **How to Verify:**
- ```bash
- # Run self-assessment with Popper Falsifiability Score
- pmat popper-score --verbose
- # Individual commitment verification
- cargo llvm-cov --html # Coverage ≥85%
- pmat mutate --threshold 80 # Mutation ≥80%
- cargo build --timings # Build time <3min
- ```
- **Failure = Regression:** Any commitment violation blocks CI merge.
- ### Benchmark Results (Statistical Rigor)
- All benchmarks use Criterion.rs with proper statistical methodology:
- | Operation | Mean | 95% CI | Std Dev | Sample Size |
- |-----------|------|--------|---------|-------------|
- | Context (1K LOC) | 127ms | [124, 130] | ±12.3ms | n=1000 runs |
- | Context (10K LOC) | 1.84s | [1.79, 1.90] | ±156ms | n=500 runs |
- | TDG Scoring | 156ms | [148, 164] | ±18.2ms | n=500 runs |
- | Complexity Analysis | 23ms | [22, 24] | ±3.1ms | n=1000 runs |
- **Comparison Baselines (vs. Alternatives):**
- | Metric | PMAT | ctags | tree-sitter | Effect Size |
- |--------|------|-------|-------------|-------------|
- | 10K LOC parsing | 1.84s | 0.3s | 0.8s | d=0.72 (medium) |
- | Memory (10K LOC) | 287MB | 45MB | 120MB | - |
- | Semantic depth | Full | Syntax only | AST only | - |
- See [docs/BENCHMARKS.md](docs/BENCHMARKS.md) for complete statistical analysis.
- ### ML/AI Reproducibility
- PMAT uses ML for semantic search and embeddings. All ML operations are reproducible:
- **Random Seed Management:**
- - Embedding generation uses fixed seed (SEED=42) for deterministic outputs
- - Clustering operations use fixed seed (SEED=12345)
- - Seeds documented in [docs/ml/REPRODUCIBILITY.md](docs/ml/REPRODUCIBILITY.md)
- **Model Artifacts:**
- - Pre-trained models from HuggingFace (all-MiniLM-L6-v2)
- - Model versions pinned in Cargo.toml
- - Hash verification on download
- ## Dataset Sources
- PMAT does not train models but uses these data sources for evaluation:
- | Dataset | Source | Purpose | Size |
- |---------|--------|---------|------|
- | CodeSearchNet | GitHub/Microsoft | Semantic search benchmarks | 2M functions |
- | PMAT-bench | Internal | Regression testing | 500 queries |
- Data provenance and licensing documented in [docs/ml/REPRODUCIBILITY.md](docs/ml/REPRODUCIBILITY.md).
- ## Sovereign Stack
- PMAT is built on the PAIML Sovereign Stack - pure-Rust, SIMD-accelerated libraries:
- | Library | Purpose | Version |
- |---------|---------|---------|
- | [aprender](https://crates.io/crates/aprender) | ML library (text similarity, clustering, topic modeling) | 0.64 |
- | [aprender-graph](https://crates.io/crates/aprender-graph) | CSR graph database (PageRank, Louvain) | 0.64 |
- | [aprender-db](https://crates.io/crates/aprender-db) | Columnar analytics database (lib `trueno_db`, optional) | 0.64 |
- | [aprender-rag](https://crates.io/crates/aprender-rag) | RAG pipeline with VectorStore | 0.64 |
- | [aprender-viz](https://crates.io/crates/aprender-viz) | Terminal graph visualization | 0.64 |
- | [aprender-compute](https://crates.io/crates/aprender-compute) | SIMD/GPU compute for matrix operations (lib `trueno`) | 0.64 |
- | [aprender-zram-core](https://crates.io/crates/aprender-zram-core) | SIMD LZ4/ZSTD compression (optional) | 0.64 |
- | [aprender-contracts](https://crates.io/crates/aprender-contracts) | Provable contracts (with `aprender-contracts-macros`) | 0.64 |
- | [pmcp](https://crates.io/crates/pmcp) | MCP protocol SDK (streamable HTTP transport) | 2.17 |
- | **pmat** | Code analysis toolkit | 3.40.0 |
- **Key Benefits:**
- - Pure Rust (no C dependencies, no FFI)
- - SIMD-first (AVX2, AVX-512, NEON auto-detection)
- - 2-4x speedup on graph algorithms via aprender adapter
- ## Documentation
- - [PMAT Book](https://paiml.github.io/pmat-book/) - Complete guide
- - [API Reference](https://docs.rs/pmat) - Rust API docs
- - [MCP Tools](docs/mcp/TOOLS.md) - MCP integration guide
- - [Specifications](docs/specifications/) - Technical specs
- - 🤖 [Coursera Hugging Face AI Development Specialization](https://www.coursera.org/specializations/hugging-face-ai-development) - Build Production AI systems with Hugging Face in Pure Rust
- ## Contributing
- See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, testing, and pull request guidelines.
- ## See Also
- - [Cookbook](examples/) — 113 runnable examples
- ## License
- MIT License - see [LICENSE](LICENSE) for details.
- ---
- <div align="center">
- <sub>Built with Extreme TDD | Part of <a href="https://github.com/paiml">PAIML</a></sub>
- </div>
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.