# JayOfemi/byakugan [Health: Active]

**Category:** 🏢 Workplace & Productivity  
**Repository:** https://github.com/JayOfemi/byakugan  
**GitHub Stars:** 0  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/jayofemi-byakugan

## Description
Private, local AI-text analysis (a detection read, the exact AI-tell spans, a reuse check, and a grammar pass) for the AI you already use.

## Tools
Capabilities this server exposes over MCP:

- **detect_ai_text** — Score how likely a passage reads as AI-written, fully on-device, with a per-signal breakdown and a confidence band. Returns a 0 to 100 likelihood, never a yes/no verdict. The signal is directional and biased against non-native English writers, so treat it as a second opinion and not proof. Get a read here, then call find_ai_tells to locate the spans worth rewriting.
- **find_ai_tells** — Locate the exact character spans that read as AI, covering stock phrasing, long dashes, and formulaic sentence openers. Returns a list of spans with start, end, the matched text, and a note. Use these to rephrase only the flagged parts and leave the rest of the writing intact. Deterministic.
- **check_reuse** — Compare the text against reference documents you provide, using word shingles, and return the share of overlap and the verbatim shared passages. This is a local check against the documents passed in. It does not search the web or any plagiarism database. Deterministic.
- **check_grammar** — Run a rule-based grammar and style check over the text, fully on-device, and return each issue with its character span, a message, the flagged text, and suggested fixes. Use it to tidy grammar and phrasing, before or after rewriting the flagged AI tells. Deterministic.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "byakugan": {
    "command": "npx",
    "args": ["-y","@jayofemi/ai-checker"]
  }
}
```

## Documentation

## What JayOfemi/byakugan MCP server does

JayOfemi/byakugan MCP server exposes four local text-analysis operations through the Model Context Protocol. It is intended for use from Claude Desktop, an IDE, or another MCP-compatible client. The project also includes a browser-based checker, but the MCP package is the part that lets an existing AI assistant request analysis and help rewrite the supplied text.

The processing is designed to remain on the local machine. No external AI-detection service, web search, or plagiarism database is involved in the MCP tools described here.

## How it works

The server accepts text through MCP tool calls and returns structured results. `detect_ai_text` produces a likelihood from 0 to 100, a confidence band, and a breakdown by signal. It does not return a yes-or-no authorship decision. The project warns that this signal is directional and can be biased against non-native English writers, so it should be treated as supporting evidence only.

`find_ai_tells` identifies character ranges that match patterns such as stock wording, long dashes, and formulaic sentence openings. Each result includes the start and end positions, the matched text, and an explanatory note. This makes it possible to revise only the flagged sections instead of rewriting an entire passage.

`check_reuse` compares text with reference documents supplied in the request. It uses word shingles and reports the overlap share along with verbatim passages that match. The comparison is limited to those provided documents and does not look for matches on the public web.

`check_grammar` applies rule-based grammar and style checks locally. Results include character spans, messages, the affected text, and suggested fixes. The checks can be used before or after revising the spans identified by the AI-tell analysis.

## Setup and configuration

The documented MCP setup runs the published package with Node's package runner:

```json
{
  "mcpServers": {
    "ai-checker": {
      "command": "npx",
      "args": ["-y", "@jayofemi/ai-checker"]
    }
  }
}
```

Add this entry to Claude Desktop's configuration and restart the application. Claude Code can instead install the project as a plugin using the marketplace and plugin commands documented by the repository. The project specifies Node 22 through its `.nvmrc` file, and the MCP implementation is located in the repository's `mcp/` package.

## Tools and capabilities

JayOfemi/byakugan MCP server includes these capabilities:

- Estimate how likely a passage is to read as AI-written, with signal details and confidence.
- Locate exact text spans associated with common AI-writing patterns.
- Compare supplied text with supplied reference documents for local reuse.
- Report grammar and style issues with spans and suggested corrections.

The detection and analysis results are intended to guide review and editing. They do not establish whether a person or AI wrote a passage.

## Limitations and notes

Detection is not a proof mechanism, and the repository specifically notes bias against non-native English writers. Reuse checking only covers documents provided to the tool; it is not an internet search or database-backed plagiarism check. AI-tell and grammar findings are narrow, actionable signals, so users should review suggested changes rather than applying them as unquestionable corrections.

The project is free, open source, and released under the MIT license. Its MCP workflow is local, so it does not require a third-party API credential according to the provided setup.

_Full upstream README: https://allmcps.com/mcp/jayofemi-byakugan/readme_