Krep

by bmorphism

1 stars

364 downloads

Not rated

GitHub

About

Provides a high-performance string search utility that automatically selects optimal algorithms and leverages hardware acceleration for significantly faster pattern matching than traditional tools like grep.

Details

Author: bmorphism
Repository: bmorphism/krep-mcp-server
GitHub stars: 1
Downloads: 364
Categories: Search, Developer Tools, Productivity, File Management, AI, Infrastructure, Other
Tags: #web

- High-Performance Search: Uses optimized algorithms (KMP, Boyer-Moore-Horspool, Rabin-Karp) selected based on pattern length
- Hardware Acceleration: Leverages SIMD instructions (SSE4.2/AVX2 on x86/x64, NEON on ARM) when available
- Optimized Multi-Threading: Automatically uses all available CPU cores for maximum parallel search performance
- Unified Interface: Single function with multiple modes (file search, string search, count-only)
- MCP Integration: Seamless integration with AI assistants through the Model Context Protocol

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below
Plugin Name Krep

Command (node, npx, python, etc.) node
Arguments
- Argument 1 /path/to/krep-mcp-server/src/index.js
Environment
- DEBUG true
- KREP_PATH /path/to/krep-native/krep
- CLAUDE_MCP true
Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

JSON

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

From the repository

The krep MCP server exposes a single unified function:

<use_mcp_tool>
<server_name>krep</server_name>
<tool_name>krep</tool_name>
<arguments>
{
  "pattern": "search pattern",
  "target": "file path or string to search",
  "mode": "file|string|count",
  "caseSensitive": true|false,
  "threads": null // Automatically uses all CPU cores if not specified
}
</arguments>
</use_mcp_tool>

We provide an automatic installation script to set up the Cline integration:

./install-cline-integration.sh ./run-cline-test.sh

./uninstall-cline-integration.sh

- CLAUDE_MCP: Set to "true" to run in MCP mode
- KREP_PATH: Path to the krep binary
- DEBUG: Set to "true" for verbose logging
- KREP_TEST_MODE: Set to "true" to run in test mode with mock responses
- KREP_SKIP_CHECK: Set to "true" to skip checking if the krep binary exists

`krep`

Unified function to perform pattern searching. Parameters: pattern (string, required), target (string, required), mode (optional, 'file'| 'string'| 'count'), caseSensitive (boolean, optional), threads (integer, optional)

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "krep": {
            "env": {
                "DEBUG": "true",
                "KREP_PATH": "/path/to/krep-native/krep",
                "CLAUDE_MCP": "true"
            },
            "args": [
                "/path/to/krep-mcp-server/src/index.js"
            ],
            "command": "node"
        }
    }
}

Linux

{
    "env": {
        "DEBUG": "true",
        "KREP_PATH": "/path/to/krep-native/krep",
        "CLAUDE_MCP": "true"
    },
    "args": [
        "/path/to/krep-mcp-server/src/index.js"
    ],
    "command": "node"
}

Macos

{
    "env": {
        "DEBUG": "true",
        "KREP_PATH": "/path/to/krep-native/krep",
        "CLAUDE_MCP": "true"
    },
    "args": [
        "/path/to/krep-mcp-server/src/index.js"
    ],
    "command": "node"
}

Windows

{
    "env": {
        "DEBUG": "true",
        "KREP_PATH": "/path/to/krep-native/krep",
        "CLAUDE_MCP": "true"
    },
    "args": [
        "/path/to/krep-mcp-server/src/index.js"
    ],
    "command": "node"
}

Krep MCP Server

A high-performance string search utility with MCP (Model Context Protocol) integration for the infinity-topos environment. This is a wrapper around krep, an ultra-fast pattern matching utility that significantly outperforms traditional tools like grep.

                   THE KREP-MCP-SERVER ABSURDITY DIAGRAM
                   ====================================
                             
          +-----------------------------------------------------+
          |                                                     |
          |                The KREP MCP Redundancy Zone         |
          |                                                     |
          +-----^--------------------+------------------------+-+
                |                    |                        |
    +-----------+----------+  +------+-------------+  +------+-------+
    |                      |  |                    |  |              |
    |    M E T A D A T A   |  |  F U N C T I O N   |  |  B I N A R Y |
    |    E X P L O S I O N  |  |  N A M E   C H A O S|  |  H U N T    |
    |                      |  |                    |  |              |
    +-----+----------+-----+  +---+-----------+----+  +------+-------+
          |          |            |           |              |
          v          v            v           v              v
 +--------+--+  +----+-----+  +---+----+  +---+-----+  +----+------+
 |           |  |          |  |        |  |         |  |           |
 | "Unified" |  | 37 Paths |  | krep   |  |krepSearch|  |  5 Error |
 | Function  |  | To Find  |  |        |  |krepMatch |  | Handlers |
 | That Does |  | The Same |  |        |  |krepCount |  |   For    |
 | 3 Things  |  | Binary   |  |        |  |          |  | 1 Error  |
 |           |  |          |  |        |  |          |  |           |
 +-----------+  +----------+  +--------+  +----------+  +-----------+
                                                  
          +-----------------------------------------------------+
          |                                                     |
          |         Configuration & Shell Script Hell           |
          |                                                     |
          +-----^--------------------+------------------------+-+
                |                    |                        |
    +-----------+----------+  +------+-------------+  +------+-------+
    |                      |  |                    |  |              |
    |    3 Scripts to      |  |  Integer           |  | Test Mode   |
    |    Install 1 Thing   |  |  Arithmetic in     |  | that Mocks  |
    |                      |  |  Shell that says   |  | Success When|
    |                      |  |  0 + 0 = Syntax    |  | Everything  |
    |                      |  |  Error             |  | Fails       |
    +----------------------+  +--------------------+  +--------------+
"It's not redundant if it's resilient!"

                         - MCP Engineer, probably

Overview

Krep MCP Server provides a unified interface to the krep binary, a high-performance string search utility similar to grep but with optimized algorithms and multi-threading capabilities. It exposes krep's functionality through the Model Context Protocol, allowing AI assistants to perform efficient pattern searching in files and strings.

Features

Why This Codebase Is Tragic

This codebase demonstrates how a simple tool (a wrapper for a string search utility) became bloated with unnecessary complexity:

1. Simple Core, Complex Implementation: The actual functionality is straightforward but buried under layers of over-engineering

2. Documentation Overload: 15 documentation files for a tool that could be explained in a single well-structured README

3. Integration Madness: 3 separate integration systems (Cline, Claude Desktop, SDK), each with redundant scripts and documentation

4. Installation Script Proliferation: 7 installation scripts when one configurable script would suffice

5. Error Handling Duplication: Error handling duplicated at multiple levels rather than having a unified approach

6. Test Fragmentation: Test files scattered across the codebase rather than being organized systematically

7. Configuration Redundancy: Configuration files and environment variables duplicated across multiple components

8. Binary Path Overkill: Searches 37 different paths for a single binary that should be in one predictable location

What It Should Have Been:

┌──────────────────────┐

│    krep-mcp-server   │

│  ┌────────────────┐  │

│  │  index.js      │  │

│  │  - one function│  │

│  └────────────────┘  │

│  ┌────────────────┐  │

│  │  README.md     │  │

│  │  - clear docs  │  │

│  └────────────────┘  │

│  ┌────────────────┐  │

│  │  install.sh    │  │

│  │  - one script  │  │

│  └────────────────┘  │

└──────────────────────┘

Project Structure

Here's the actual project structure:

krep-mcp-server/
├── CLINE_README.md
├── CLINE_SETUP.md
├── CLAUDE_DESKTOP_INTEGRATION.md
├── CLAUDE_DESKTOP_README.md
├── EXAMPLES.md
├── IMPLEMENTATION_SUMMARY.md
├── INSTALL_NOW.md
├── LIFECYCLE_DESIGN.md
├── MCP_COMPLIANCE.md
├── MCP_URIS.md
├── README.md
├── SETUP_CLAUDE_DESKTOP.md
├── TESTING_STRATEGY.md
├── THREAD_OPTIMIZATION.md
├── analysis/
│   └── index.tree.json
├── auto-install-claude.sh
├── cline-config.js
├── direct-install.sh
├── eslint.config.js
├── fix-claude-desktop.sh
├── go-integration/
│   ├── example/
│   └── krep.go
├── install-claude-desktop.sh
├── install-cline-integration.sh
├── install-sdk-integrations.sh
├── jest.config.js
├── just-krep.sh
├── mcp-config.json
├── package-lock.json
├── package.json
├── python-integration/
│   └── krep_mcp_client.py
├── run-claude-desktop.sh
├── run-claude-integration.sh
├── run-cline-mcp-server.sh
├── run-cline-test.sh
├── run-tests.sh
├── run.sh
├── sdk-integration.js
├── src/
│   ├── index.js
│   ├── index.min.js
│   ├── mcp_server.js
│   └── mcp_server.min.js
├── Support/
│   └── Claude/
├── test/
│   ├── benchmark.js
│   ├── fixtures/
│   ├── integration/
│   ├── mcp_benchmark.js
│   ├── mock-server.js
│   ├── unit/
│   └── utils.js
└── various test scripts...

Installation

1. Ensure you have the krep binary installed:

   cd /path/to/krep-native

   make

2. Configure the MCP server in your MCP settings file:

   {

     "mcpServers": {

       "krep": {

         "command": "node",

         "args": [

           "/path/to/krep-mcp-server/src/index.js"

         ],

         "env": {

           "CLAUDE_MCP": "true",

           "KREP_PATH": "/path/to/krep-native/krep",

           "DEBUG": "true"

         },

         "description": "High-performance string search utility with unified interface",

         "disabled": false,

         "autoApprove": [

           "krep"

         ]

       }

     }

   }

Usage

The krep MCP server exposes a single unified function:

<use_mcp_tool>
<server_name>krep</server_name>
<tool_name>krep</tool_name>
<arguments>
{
  "pattern": "search pattern",
  "target": "file path or string to search",
  "mode": "file|string|count",
  "caseSensitive": true|false,
  "threads": null // Automatically uses all CPU cores if not specified
}
</arguments>
</use_mcp_tool>

Parameters

- pattern (required): The pattern to search for
- target (required): File path or string to search in
- mode (optional): Search mode
- file (default): Search in a file
- string: Search in a string
- count: Count occurrences only
- caseSensitive (optional): Whether the search is case-sensitive (default: true)
- threads (optional): Number of threads to use (default: auto-detected based on CPU cores)

Examples

See examples.md for detailed usage examples and patterns.

How It Works

The krep MCP server works by:

1. Receiving requests through the Model Context Protocol
2. Parsing the request parameters
3. Building the appropriate krep command based on the mode and parameters
4. Executing the command using the krep binary
5. Parsing the results and returning them in a structured format

Performance

Krep is designed for high-performance pattern searching:

- Algorithm Selection: Automatically selects the optimal algorithm based on pattern length
- KMP (Knuth-Morris-Pratt) for very short patterns (< 3 characters)
- Boyer-Moore-Horspool for medium-length patterns (3-16 characters)
- Rabin-Karp for longer patterns (> 16 characters)
- Hardware Acceleration: Uses SIMD instructions when available
- Dynamic Multi-Threading: Automatically utilizes all available CPU cores for optimal parallel search performance

Cline VSCode Extension Integration

The krep-mcp-server can be integrated with the Cline VSCode extension, allowing you to use high-performance string search capabilities directly in your VSCode environment.

Installation with Cline

We provide an automatic installation script to set up the Cline integration:

```bash

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

krep

Claude Desktop / Cursor

Linux

Macos

Windows

Krep MCP Server

Overview

Features

Why This Codebase Is Tragic

Project Structure

Installation

Usage

Parameters

Examples

How It Works

Performance

Cline VSCode Extension Integration

Installation with Cline

Install

More like this

Time

Sentry

Github

Brave Search

Git

GitLab

`krep`