Skip to main content
Glama
henningziech

Claude Error Collector

by henningziech
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local

Claude Error Collector

An MCP server for Claude Code that learns from your corrections. When you tell Claude "that was wrong" or "no, do it like this", it records the lesson as a rule in your CLAUDE.md - so the same mistake doesn't happen twice.

How It Works

  1. You correct Claude during a coding session

  2. Claude recognizes the correction and calls the record_error tool

  3. The server derives a rule and writes it to the appropriate CLAUDE.md

  4. Claude reads that rule in future sessions and avoids repeating the mistake

The server automatically detects whether you're in a project directory (writes to project CLAUDE.md) or your home directory (writes to ~/.claude/CLAUDE.md).

Related MCP server: claude-memory-mcp

Tools

record_error

Records a correction and saves it as a learned rule with metadata (date, category).

Parameter

Type

Required

Description

error_description

string

yes

What was wrong

correction

string

yes

What is correct

rule

string

yes

Derived guideline, e.g. "ALWAYS use X instead of Y"

category

string

no

Rule category (e.g. "n8n", "bash", "google-workspace"). Auto-detected if omitted.

project_dir

string

no

Current working directory (for finding project CLAUDE.md)

list_errors

Lists all learned rules from the relevant CLAUDE.md. Supports filtering and grouping.

Parameter

Type

Required

Description

category

string

no

Filter rules by category

grouped

boolean

no

Group rules by category with headings

project_dir

string

no

Current working directory

delete_rule

Deletes a learned rule by index or substring match.

Parameter

Type

Required

Description

index

number

no*

1-based index of the rule to delete

match

string

no*

Substring to match (must match exactly one rule)

project_dir

string

no

Current working directory

*Exactly one of index or match must be provided.

update_rule

Updates an existing rule's text, date, and optionally category.

Parameter

Type

Required

Description

index

number

no*

1-based index of the rule to update

match

string

no*

Substring to match (must match exactly one rule)

new_rule

string

yes

The new rule text

category

string

no

New category (keeps existing if omitted)

project_dir

string

no

Current working directory

*Exactly one of index or match must be provided.

review_rules

Reviews all rules with their age for lifecycle management.

Parameter

Type

Required

Description

older_than_days

number

no

Threshold in days to consider "old" (default: 30)

project_dir

string

no

Current working directory

Output Format

Rules are stored in a ## Learned Rules section in your CLAUDE.md with metadata as HTML comments:

## Learned Rules

- Legacy rule without metadata (still supported)

### N8n

- Bei n8n IMMER nodeId verwenden <!-- @date:2026-02-15 @category:n8n -->

### Bash

- NEVER embed large JSON inline in Bash commands <!-- @date:2026-02-20 @category:bash -->

Metadata fields:

  • @date:YYYY-MM-DD — when the rule was created/updated

  • @category:name — rule category for grouping

Rules without metadata (legacy format) remain fully supported and appear at the top of the section without a category heading.

Installation

git clone https://github.com/henningziech/claude-error-collector-mcp.git
cd claude-error-collector-mcp
npm install && npm run build
claude mcp add error-collector -s user -- node "$PWD/dist/index.js"

Restart Claude Code after installation. No manual CLAUDE.md editing needed — the server provides its own instructions to Claude via MCP server metadata.

CLAUDE.md Resolution

The server finds the right CLAUDE.md using this logic:

  1. If project_dir is provided: walk up the directory tree looking for CLAUDE.md

  2. If found and not in the home directory: use it (project-level rules)

  3. Fallback: ~/.claude/CLAUDE.md (global rules)

Duplicate Detection

Duplicate detection works on two levels:

  1. Server-side: Before writing a rule, the server checks existing rules using case-insensitive substring matching. If the new rule is already covered by an existing one (or vice versa), it skips the write.

  2. Semantic (via instructions): The server instructs Claude to review existing learned rules for semantic equivalence before calling record_error — even if the wording differs. Claude will:

    • Skip silently if the rule clearly already exists

    • Record it if the rule is clearly new

    • Ask the user if a similar rule exists but it's not 100% clear whether it's a duplicate, offering options to add alongside, consolidate, or skip

License

MIT

Available Tools

2 tools
list_errorsC

List all learned rules from the CLAUDE.md file.

ParametersJSON Schema
NameRequiredDescriptionDefault
project_dirNoCurrent working directory (to find project CLAUDE.md)

TDQS

C2.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists rules but doesn't clarify if this is a read-only operation, what permissions are needed, how the output is formatted, or any limitations (e.g., file size constraints). This leaves significant behavioral gaps for the agent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, straightforward sentence that efficiently conveys the core purpose without unnecessary words. It's front-loaded with the main action, making it easy to parse, though it could be slightly more structured for clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'learned rules' are, how they're formatted in the output, or any error handling (e.g., if CLAUDE.md is missing). For a tool with no structured support, this leaves the agent under-informed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the single parameter 'project_dir' clearly documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('List') and resource ('learned rules from the CLAUDE.md file'), which clarifies what the tool does. However, it doesn't distinguish from its sibling 'record_error' (which presumably records errors rather than listing rules), leaving some ambiguity about the tool's unique role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention the sibling tool 'record_error' or explain scenarios where listing rules is appropriate versus recording errors, leaving the agent without contextual usage cues.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

record_errorA

Record a correction from the user and save it as a learned rule in CLAUDE.md. Call this whenever the user corrects you.

ParametersJSON Schema
NameRequiredDescriptionDefault
error_descriptionYesWhat was wrong
correctionYesWhat is correct
ruleYesDerived guideline, e.g. "ALWAYS use X instead of Y"
project_dirNoCurrent working directory (to find project CLAUDE.md)

TDQS

A4.1/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It states the tool saves corrections as learned rules, implying persistence and mutation, but lacks details on permissions, file overwrite behavior, error handling, or response format. It adequately describes the core behavior but misses operational specifics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences that are front-loaded with the core purpose and usage trigger. Every word serves a clear function with zero waste, making it highly efficient and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description adequately covers the tool's purpose and usage but lacks details on behavioral traits like file I/O specifics, error responses, or system impacts. For a mutation tool with 4 parameters, it provides a functional overview but could be more complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or interdependencies. This meets the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Record a correction'), the resource ('save it as a learned rule in CLAUDE.md'), and the precise trigger ('whenever the user corrects you'). It distinguishes from the sibling 'list_errors' by focusing on recording rather than listing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit usage guidance with 'Call this whenever the user corrects you,' establishing a clear context for when to invoke this tool. It implicitly distinguishes from 'list_errors' by focusing on correction recording rather than error listing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 2 tool updatesv1.0.0
    • First observedlist_errors
    • First observedrecord_error
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0
Disambiguation5/5

The two tools have completely distinct purposes: list_errors retrieves existing rules, while record_error adds new rules. There is no overlap in functionality, making it impossible to confuse them.

Naming Consistency5/5

Both tools follow a consistent verb_noun pattern (list_errors, record_error) with clear action-object naming. The style is uniform throughout the set.

Tool Count2/5

With only 2 tools, the server feels thin for error collection and learning. While it covers basic listing and recording, typical error management systems would benefit from additional operations like updating rules, deleting outdated ones, or searching/filtering errors.

Completeness3/5

The tools provide minimal CRUD coverage: create (record_error) and read (list_errors) are present, but update and delete operations are missing. This creates a dead-end where rules cannot be modified or removed once recorded, limiting practical utility.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/henningziech/claude-error-collector-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server