Krep MCP Server

Um servidor de busca de strings de alto desempenho alimentado pelo binário krep.

GitHub
1
Experimente este MCPPatrocinado

Documentação

Servidor MCP Krep

Uma utilidade de busca de strings de alta performance com integração MCP (Model Context Protocol) para o ambiente infinity-topos. Este é um wrapper em torno do krep, uma utilidade de correspondência de padrões ultra-rápida que supera significativamente ferramentas tradicionais 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

Visão Geral

O Servidor MCP Krep fornece uma interface unificada para o binário krep, uma utilidade de busca de strings de alta performance semelhante ao grep, mas com algoritmos otimizados e capacidades de multi-threading. Ele expõe a funcionalidade do krep através do Model Context Protocol, permitindo que assistentes de IA realizem buscas eficientes de padrões em arquivos e strings.

Recursos

  • Busca de Alta Performance: Utiliza algoritmos otimizados (KMP, Boyer-Moore-Horspool, Rabin-Karp) selecionados com base no comprimento do padrão
  • Aceleração de Hardware: Aproveita instruções SIMD (SSE4.2/AVX2 em x86/x64, NEON em ARM) quando disponíveis
  • Multi-Threading Otimizado: Usa automaticamente todos os núcleos de CPU disponíveis para máxima performance de busca paralela
  • Interface Unificada: Função única com múltiplos modos (busca em arquivo, busca em string, apenas contagem)
  • Integração MCP: Integração perfeita com assistentes de IA através do Model Context Protocol

Por Que Este Código-Fonte É Trágico

Este código-fonte demonstra como uma ferramenta simples (um wrapper para uma utilidade de busca de strings) tornou-se inflada com complexidade desnecessária:

  1. Núcleo Simples, Implementação Complexa: A funcionalidade real é direta, mas está enterrada sob camadas de engenharia excessiva

  2. Excesso de Documentação: 15 arquivos de documentação para uma ferramenta que poderia ser explicada em um único README bem estruturado

  3. Loucura de Integração: 3 sistemas de integração separados (Cline, Claude Desktop, SDK), cada um com scripts e documentação redundantes

  4. Proliferação de Scripts de Instalação: 7 scripts de instalação quando um único script configurável seria suficiente

  5. Duplicação de Tratamento de Erros: Tratamento de erros duplicado em múltiplos níveis em vez de ter uma abordagem unificada

  6. Fragmentação de Testes: Arquivos de teste espalhados pelo código-fonte em vez de organizados sistematicamente

  7. Redundância de Configuração: Arquivos de configuração e variáveis de ambiente duplicados em múltiplos componentes

  8. Exagero de Caminhos de Binário: Busca em 37 caminhos diferentes por um único binário que deveria estar em um local previsível

O Que Deveria Ter Sido:

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

Estrutura do Projeto

Aqui está a estrutura real do projeto:

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

Instalação

  1. Certifique-se de ter o binário krep instalado:

    cd /path/to/krep-native
make

  2. Configure o servidor MCP no seu arquivo de configurações 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

O servidor MCP krep expõe uma única função 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 (obrigatório): O padrão a ser buscado
  • target (obrigatório): Caminho do arquivo ou string para buscar
  • mode (opcional): Modo de busca
    • file (padrão): Buscar em um arquivo
    • string: Buscar em uma string
    • count: Contar apenas ocorrências
  • caseSensitive (opcional): Se a busca diferencia maiúsculas de minúsculas (padrão: true)
  • threads (opcional): Número de threads a usar (padrão: detectado automaticamente com base nos núcleos da CPU)

Exemplos

Consulte examples.md para exemplos detalhados de uso e padrões.

Como Funciona

O servidor MCP krep funciona da seguinte forma:

  1. Recebendo solicitações através do Model Context Protocol
  2. Analisando os parâmetros da solicitação
  3. Construindo o comando krep apropriado com base no modo e nos parâmetros
  4. Executando o comando usando o binário krep
  5. Analisando os resultados e retornando-os em um formato estruturado

Performance

Krep é projetado para busca de padrões de alta performance:

  • Seleção de Algoritmo: Seleciona automaticamente o algoritmo ideal com base no comprimento do padrão
    • KMP (Knuth-Morris-Pratt) para padrões muito curtos (< 3 caracteres)
    • Boyer-Moore-Horspool para padrões de comprimento médio (3-16 caracteres)
    • Rabin-Karp para padrões mais longos (> 16 caracteres)
  • Aceleração de Hardware: Usa instruções SIMD quando disponíveis
  • Multi-Threading Dinâmico: Utiliza automaticamente todos os núcleos de CPU disponíveis para performance ideal de busca paralela

Integração com a Extensão Cline do VSCode

O krep-mcp-server pode ser integrado com a extensão Cline do VSCode, permitindo que você use capacidades de busca de strings de alta performance diretamente no seu ambiente VSCode.

Instalação com Cline

Fornecemos um script de instalação automática para configurar a integração com Cline:

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

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

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

Usando krep no Cline

Uma vez integrado, você pode usar krep diretamente nas conversas do Cline:

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

Para instruções detalhadas e exemplos de uso, consulte:

Integração com Infinity Topos

O Servidor MCP Krep é projetado para funcionar perfeitamente dentro do ambiente infinity-topos:

  • Integração Babashka: Use Babashka para processar resultados de busca
  • Integração Say: Vocalize resultados de busca usando o servidor MCP Say
  • Integração Coin-Flip: Use randomização para determinar estratégias de busca

Desenvolvimento

Variáveis de Ambiente

  • CLAUDE_MCP: Defina como "true" para executar em modo MCP
  • KREP_PATH: Caminho para o binário krep
  • DEBUG: Defina como "true" para registro detalhado (verbose logging)
  • KREP_TEST_MODE: Defina como "true" para executar em modo de teste com respostas simuladas
  • KREP_SKIP_CHECK: Defina como "true" para pular a verificação se o binário krep existe

Modo Servidor HTTP

Quando não está em modo MCP, o servidor inicia um servidor HTTP com os seguintes endpoints:

  • GET /health: Endpoint de verificação de saúde
  • GET /: Informações do servidor
  • POST /search: Buscar padrões em arquivos
  • POST /match: Corresponder padrões em strings
  • GET /performance: Informações de performance
  • GET /algorithm-selection: Guia de seleção de algoritmos

Licença

MIT