Krep MCP Server

Un servidor de búsqueda de cadenas de alto rendimiento impulsado por el binario krep.

GitHub
1
Prueba este MCPPatrocinado

Documentación

Servidor MCP Krep

Una utilidad de búsqueda de cadenas de alto rendimiento con integración MCP (Protocolo de Contexto de Modelo) para el entorno infinity-topos. Este es un envoltorio alrededor de krep, una utilidad de coincidencia de patrones ultrarrápida que supera significativamente a herramientas tradicionales como 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

Descripción General

El Servidor MCP Krep proporciona una interfaz unificada al binario krep, una utilidad de búsqueda de cadenas de alto rendimiento similar a grep pero con algoritmos optimizados y capacidades de múltiples hilos. Expone la funcionalidad de krep a través del Protocolo de Contexto de Modelo, permitiendo a los asistentes de IA realizar búsquedas de patrones eficientes en archivos y cadenas.

Características

  • Búsqueda de Alto Rendimiento: Utiliza algoritmos optimizados (KMP, Boyer-Moore-Horspool, Rabin-Karp) seleccionados según la longitud del patrón
  • Aceleración por Hardware: Aprovecha instrucciones SIMD (SSE4.2/AVX2 en x86/x64, NEON en ARM) cuando están disponibles
  • Múltiples Hilos Optimizados: Utiliza automáticamente todos los núcleos de CPU disponibles para un rendimiento máximo de búsqueda paralela
  • Interfaz Unificada: Una sola función con múltiples modos (búsqueda en archivos, búsqueda en cadenas, solo conteo)
  • Integración MCP: Integración perfecta con asistentes de IA a través del Protocolo de Contexto de Modelo

Por Qué Este Código Base Es Trágico

Este código base demuestra cómo una herramienta simple (un envoltorio para una utilidad de búsqueda de cadenas) se volvió inflada con complejidad innecesaria:

  1. Núcleo Simple, Implementación Compleja: La funcionalidad real es sencilla pero está enterrada bajo capas de sobre-ingeniería

  2. Sobrecarga de Documentación: 15 archivos de documentación para una herramienta que podría explicarse en un único README bien estructurado

  3. Locura de Integraciones: 3 sistemas de integración separados (Cline, Claude Desktop, SDK), cada uno con scripts y documentación redundantes

  4. Proliferación de Scripts de Instalación: 7 scripts de instalación cuando un solo script configurable sería suficiente

  5. Duplicación en el Manejo de Errores: El manejo de errores está duplicado en múltiples niveles en lugar de tener un enfoque unificado

  6. Fragmentación de Pruebas: Los archivos de prueba están dispersos por todo el código base en lugar de estar organizados sistemáticamente

  7. Redundancia de Configuración: Los archivos de configuración y las variables de entorno están duplicados en múltiples componentes

  8. Exceso de Rutas de Binario: Busca en 37 rutas diferentes un solo binario que debería estar en una ubicación predecible

Lo Que Debería Haber Sido:

┌──────────────────────┐
│    krep-mcp-server   │
│  ┌────────────────┐  │
│  │  index.js      │  │
│  │  - one function│  │
│  └────────────────┘  │
│  ┌────────────────┐  │
│  │  README.md     │  │
│  │  - clear docs  │  │
│  └────────────────┘  │
│  ┌────────────────┐  │
│  │  install.sh    │  │
│  │  - one script  │  │
│  └────────────────┘  │
└──────────────────────┘

Estructura del Proyecto

Aquí está la estructura real del proyecto:

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...

Instalación

  1. Asegúrate de tener el binario krep instalado:

    cd /path/to/krep-native
make

  2. Configura el servidor MCP en tu archivo de configuración MCP:

    {
  "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"
      ]
    }
  }
}

Uso

El servidor MCP krep expone una única función unificada:

<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>

Parámetros

  • pattern (obligatorio): El patrón a buscar
  • target (obligatorio): Ruta de archivo o cadena en la que buscar
  • mode (opcional): Modo de búsqueda
    • file (predeterminado): Buscar en un archivo
    • string: Buscar en una cadena
    • count: Contar solo las ocurrencias
  • caseSensitive (opcional): Si la búsqueda distingue entre mayúsculas y minúsculas (predeterminado: true)
  • threads (opcional): Número de hilos a utilizar (predeterminado: auto-detectado según los núcleos de CPU)

Ejemplos

Consulta examples.md para ejemplos de uso detallados y patrones.

Cómo Funciona

El servidor MCP krep funciona de la siguiente manera:

  1. Recibe solicitudes a través del Protocolo de Contexto de Modelo
  2. Analiza los parámetros de la solicitud
  3. Construye el comando krep apropiado según el modo y los parámetros
  4. Ejecuta el comando usando el binario krep
  5. Analiza los resultados y los devuelve en un formato estructurado

Rendimiento

Krep está diseñado para la búsqueda de patrones de alto rendimiento:

  • Selección de Algoritmo: Selecciona automáticamente el algoritmo óptimo según la longitud del patrón
    • KMP (Knuth-Morris-Pratt) para patrones muy cortos (< 3 caracteres)
    • Boyer-Moore-Horspool para patrones de longitud media (3-16 caracteres)
    • Rabin-Karp para patrones más largos (> 16 caracteres)
  • Aceleración por Hardware: Utiliza instrucciones SIMD cuando están disponibles
  • Múltiples Hilos Dinámicos: Utiliza automáticamente todos los núcleos de CPU disponibles para un rendimiento óptimo de búsqueda paralela

Integración con la Extensión Cline de VSCode

El servidor MCP krep se puede integrar con la extensión Cline de VSCode, permitiéndote usar capacidades de búsqueda de cadenas de alto rendimiento directamente en tu entorno VSCode.

Instalación con Cline

Proporcionamos un script de instalación automática para configurar la integración con Cline:

# Install the integration
./install-cline-integration.sh

# Test the integration before installing
./run-cline-test.sh

# Uninstall the integration
./uninstall-cline-integration.sh

Uso de krep en Cline

Una vez integrado, puedes usar krep directamente en conversaciones de Cline:

/krep krep pattern="function" target="/path/to/search" mode="file"

Para instrucciones detalladas y ejemplos de uso, consulta:

Integración con Infinity Topos

El Servidor MCP Krep está diseñado para funcionar perfectamente dentro del entorno infinity-topos:

  • Integración con Babashka: Usa Babashka para procesar resultados de búsqueda
  • Integración con Say: Vocaliza resultados de búsqueda usando el servidor MCP Say
  • Integración con Coin-Flip: Usa aleatorización para determinar estrategias de búsqueda

Desarrollo

Variables de Entorno

  • CLAUDE_MCP: Establecer en "true" para ejecutar en modo MCP
  • KREP_PATH: Ruta al binario krep
  • DEBUG: Establecer en "true" para registro detallado (verbose)
  • KREP_TEST_MODE: Establecer en "true" para ejecutar en modo de prueba con respuestas simuladas
  • KREP_SKIP_CHECK: Establecer en "true" para omitir la verificación de que el binario krep existe

Modo Servidor HTTP

Cuando no se ejecuta en modo MCP, el servidor inicia un servidor HTTP con los siguientes endpoints:

  • GET /health: Endpoint de verificación de salud
  • GET /: Información del servidor
  • POST /search: Buscar patrones en archivos
  • POST /match: Coincidir patrones en cadenas
  • GET /performance: Información de rendimiento
  • GET /algorithm-selection: Guía de selección de algoritmos

Licencia

MIT