Skip to main content
Glama
sita9580

Pare

by sita9580
OverviewSchemaSourceRelated ServersDiscussionsAdmin
TypeScript
Local

CI codecov npm Downloads TypeScript License: MIT Node.js >= 20 OpenSSF Scorecard OpenSSF Best Practices

Reliable, structured CLI output for AI agents — no more parsing fragile terminal text.

Pare provides MCP servers that wrap common developer tools (git, npm, docker, test runners, etc.) and return clean, schema-validated JSON instead of raw terminal text. Agents get typed data they can act on directly, without brittle string parsing.

The Problem

Parsing CLI output is fragile. Raw terminal text includes ANSI escape codes, decorative headers, progress bars, locale-specific formatting, and platform differences that break agent workflows in subtle ways. An agent that works fine with git status on macOS may fail on Windows because the output format changed. A test runner's summary line might shift between versions, silently breaking a regex.

Pare eliminates this entire class of errors by returning schema-validated JSON with consistent field names, regardless of platform, tool version, or locale. As a bonus, structured output is significantly smaller — agents use fewer tokens per tool call:

Tool Command

Raw Tokens

Pare Tokens

Reduction

docker build (multi-stage, 11 steps)

373

20

95%

git log --stat (5 commits, verbose)

4,992

382

92%

npm install (487 packages, warnings)

241

41

83%

vitest run (28 tests, all pass)

196

39

80%

cargo build (2 errors, help text)

436

138

68%

pip install (9 packages, progress bars)

288

101

65%

cargo test (12 tests, 2 failures)

351

190

46%

npm audit (4 vulnerabilities)

287

185

36%

Token estimates use ~4 chars/token. The biggest savings appear on verbose commands (builds, installs, tests). For simpler tools like eslint or tsc, the main advantage is reliable structured data — agents can use typed JSON directly rather than parsing strings.

Related MCP server: Pare

How It Works

Each Pare tool returns two outputs:

  • content — human-readable text, for MCP clients that display it

  • structuredContent — typed, schema-validated JSON, ready for agents to process

This uses MCP's structuredContent and outputSchema features to provide type-safe, validated data that agents can rely on without custom parsing.

Example: git status

Raw git output (~118 tokens):

On branch main
Your branch is ahead of 'origin/main' by 2 commits.
  (use "git push" to publish your local commits)

Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   src/index.ts
        new file:   src/utils.ts

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        temp.log

Pare structured output (~59 tokens):

{
  "branch": "main",
  "upstream": "origin/main",
  "ahead": 2,
  "staged": [
    { "file": "src/index.ts", "status": "modified" },
    { "file": "src/utils.ts", "status": "added" }
  ],
  "modified": ["README.md"],
  "deleted": [],
  "untracked": ["temp.log"],
  "conflicts": [],
  "clean": false
}

50% fewer tokens. Zero information lost. Fully typed. Savings scale with output verbosity — test runners and build logs see 80–92% reduction.

Available Servers (28 packages, 240 tools)

Install only the servers relevant to your stack — most projects need just 2–4. The full catalog covers a wide range of ecosystems so Pare works wherever you do.

Category

Servers

Tools

Wraps

Version Control

git, github

55

git, gh

Languages & Packages

npm, python, cargo, go, deno, bun, nix, dotnet, ruby, swift, jvm

101

npm, pip, cargo, go, deno, bun, nix, dotnet, gem, swift, gradle, maven

Build, Lint & Test

build, lint, test, cmake, bazel

23

tsc, esbuild, vite, webpack, eslint, prettier, biome, vitest, pytest, jest

Infrastructure

docker, k8s, infra, security, remote

40

docker, kubectl, helm, terraform, ansible, trivy, ssh

Utilities

search, http, make, process, db

21

ripgrep, fd, curl, make, just, psql, mysql, redis, mongosh

Tool Schemas — detailed response examples and field descriptions for every tool. See also Tool Response Examples for quick JSON samples.

Quick Setup

# 1. Configure MCP servers (non-interactive)
npx @paretools/init --client claude-code --preset web

# 2. Add agent rules to your project
#    (append to existing CLAUDE.md, or copy if new)
cat node_modules/@paretools/init/rules/CLAUDE.md >> CLAUDE.md

# 3. Restart your client session

# 4. Validate
npx @paretools/init doctor

Available presets: web, python, rust, go, jvm, dotnet, ruby, swift, mobile, devops, full

Setup Guides by Client

Claude Code

Claude Desktop

Cursor

VS Code / Copilot

Windsurf

Cline / Roo Code

OpenAI Codex

Gemini CLI

Zed

Continue.dev

Full Quickstart Guide — presets, ecosystem mapping, validation

Manual Configuration — config paths and formats for all clients

Agent Integration Guide — rule files, hooks, CLI-to-MCP mapping

Configuration

Tool Selection

By default, every Pare server registers all of its tools. If a server exposes tools you don't need — or you want to limit which tools are available to an agent — you can filter them with environment variables.

Per-server filter — restrict a single server's tools:

# Only register status and log in the git server
PARE_GIT_TOOLS=status,log npx @paretools/git

Universal filter — restrict tools across all servers:

# Only register these specific tools across any server
PARE_TOOLS=git:status,git:log,npm:install npx @paretools/git

Disable all tools — set the env var to an empty string:

PARE_GIT_TOOLS= npx @paretools/git   # no tools registered

Env Var

Scope

Format

Example

PARE_TOOLS

All servers

server:tool,...

git:status,npm:install

PARE_{SERVER}_TOOLS

One server

tool,...

status,log,diff

Rules:

  • No env var = all tools enabled (default)

  • PARE_TOOLS (universal) takes precedence over per-server vars

  • Server names use uppercase with hyphens replaced by underscores (e.g., PARE_MY_SERVER_TOOLS)

  • Whitespace around commas is ignored

Common patterns:

# Read-only git (no push, commit, add, checkout)
PARE_GIT_TOOLS=status,log,diff,branch,show

# Minimal npm
PARE_NPM_TOOLS=install,test,run

# Only specific tools across all servers
PARE_TOOLS=git:status,git:diff,npm:install,test:run

In JSON MCP config, set via the env key:

{
  "mcpServers": {
    "pare-git": {
      "command": "npx",
      "args": ["-y", "@paretools/git"],
      "env": {
        "PARE_GIT_TOOLS": "status,log,diff,show"
      }
    }
  }
}

Troubleshooting

Issue

Solution

npx not found / ENOENT on Windows

Use cmd /c npx wrapper (see your client's setup guide)

Slow first start

Run npx -y @paretools/git once to cache, or install globally: npm i -g @paretools/git

Node.js version error

Pare requires Node.js >= 20

NVM/fnm PATH issues

Use absolute path to npx: e.g., ~/.nvm/versions/node/v22/bin/npx

MCP connection timeout

Set MCP_TIMEOUT=30000 for Claude Code, or increase initTimeout in client config

Too many tools filling context

Use tool selection env vars to limit tools, or only install the servers you need

Contributing

Each server is a self-contained package. See CONTRIBUTING.md for the full guide.

License

MIT

This server cannot be deployed

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

Maintenance

ActivityActive
ResponsivenessNo issues

Resources

Related MCP Connectors

Related MCP Servers

  • ToolPipe MCP Server

    Aldric-Core
    F
    license
    Not graded
    quality
    Not graded
    maintenance
    Provides a suite of 35 developer utility APIs including code formatting, data conversion, and infrastructure generation. It enables AI agents to perform tasks like JSON validation, Dockerfile creation, and network lookups directly through natural language.
    -

  • Pare

    Dave-London
    A
    license
    Not graded
    quality
    A
    maintenance
    Provides MCP servers that wrap common developer tools (git, npm, docker, etc.) returning structured JSON output, enabling AI agents to reliably interact with these tools without parsing fragile terminal text.
    1 npm
    138
    MIT

  • nc-tools-mcp

    ncdevshiv
    A
    license
    Not graded
    quality
    B
    maintenance
    Enables coding agents to perform file, search, patch, git, process, test, package, network, and system operations through 60 typed MCP tools with structured inputs/outputs, structured errors, and a full event journal, replacing terminal use with a typed machine API.
    MIT

  • Pare

    emma10741
    A
    license
    Not graded
    quality
    A
    maintenance
    Provides MCP servers that wrap common developer tools such as git, npm, Docker, Kubernetes, and test runners, returning schema-validated structured JSON instead of raw terminal text. This lets AI agents consume typed, token-efficient results directly without brittle string parsing or platform-dependent formatting issues.
    1 npm
    MIT